Group items matching

in title, tags, annotations or url

I am working on a web site that will help students practice their Scala programming skills. As I labored along, writing my JSF app code, I thought "this is silly-why not practice Scala at the same time?" But I like JSF and wasn't ready to jump to Lift or Vaadin. With Eclipse, this isn't all that hard. Install the Java plugin. Make a dynamic web project in the usual way, using the Java EE perspective. then, switch to the Scala perspective, right-click on the project, and, if all planets are aligned correctly, you will get a menu item "Add Scala nature". (If they are not, see here for a manual approach.) Add your managed beans as Scala classes. Finally, switch back to the Java EE perspective, select the project properties, and add the Scala library JAR as a Java EE module dependency. But I like NetBeans and wasn't ready to switch to Eclipse. (Unfortunately, JSF 2 support in Eclipse is pretty minimal, the Glassfish integration is a bit flaky, and the Scala plugin has very little usable code completion.) NetBeans doesn't let me add a "Scala nature" to a web project. If I add Scala files to the project, I can edit them with the Scala editor, but they just get copied to the WAR file, without any compilation. I had one look at the Ant scripts for a Scala and a web project and decided that I wasn't going to figure out how to merge them. This blog shows how you can use Maven to make a mixed Scala/Java project in NetBeans. So I gathered up JSF and Scala pom.xml files from here and here, cut out the considerable crud from the JSF POM file that was probably meant for supporting Tomcat, and merged the results to the best of my ability-see below. You use the usual Maven directory structure, but with a src/main/scala directory instead of src/main/java:

"I've had an opportunity recently to work on a product that needed an RIA web interface, and I chose my recent favorite tool for this, Vaadin. The services for this project needed to be highly scalable, and lent Themselves well to functional techniques, so I selected Scala as my language of choice. I build my projects with Maven, for reasons I won't go into right now, and I do much of my JVM-language work in Intellij's excellent IDEA IDE. Given These tools, I found a way to facilitate very rapid development of web UI's, and I thought I'd pass it along. AnoTher technique I use, which I'll expound on later, is creating "dummy" implementations of all of my backing services for my application. The "real" implementations are written as OSGi services, in separate modules from my UI. The UI is packaged as a war, but is also OSGi aware, with a bundle activator. This activator only gets called if The war is deployed into an OSGi container, and not oTherwise. This allows The app to select which implementation of The services it uses - The "dummy" ones when it's deployed outside of OSGi, and The "real" ones when They're available. This means I can use The handy Maven jetty plugin to quickly spin up my application and test it on my local workstation, without needing all of The dependencies (like a data store and such) of my real services. That's good, in that I can get my "cycle time" down to a few seconds, where "cycle time" is The time between making a change and actually being able to test it in my browser. We can do better, though. I'm using Scala as my language of choice for building The UI as well, as it works just fine with Vaadin (and with everything else in The JVM ecosystem, for that matter, which is why I didn't choose a non-JVM language - but that's yet anoTher rant). I compile my Scala with The Maven scala plugin - here's where The next handy bit comes into play. Turns out The Scala plugin has a goal cal

Mod4j (Modeling for Java) is an open source DSL-based environment for developing administrative enterprise applications. It uses a collection of DSL's to model different parts of the architecture, combined with manually written code. Currently Mod4j consists of four DSLs: the Business Domain DSL, Service DSL, Data Contract DSL and Presentation DSL. the modeling environment is seamlessly integrated into the Eclipse IDE which gives the developers one environment where they can easily switch back- and forth between models and code. the different DSL?s used in Mod4j can be used independently, but if they are used in collaboration they will be fully validated with each other. Apart from integration in the Eclipse IDE, Mod4j also supports the use of Maven. That is, using the DSL models as the source, the complete code generation process can be run automatically on a build server without the need for Eclipse. the Mod4j DSLs and the corresponding code generators are based on a reference architecture. This allows developers to model various aspects of the application and generate code that strictly follows this reference architecture. the reference architecture is described in a separate document. For a good understanding of the generated code it is useful to read this document.

The aim of this paper is a brief introduction to MDA technology and a summary / comparison to The approachments to MDA of AndroMDA and Acceleo, intending to be a practical and understandable summary Introduction Model-driven architecture (MDA) is a software design approach for The development of software systems. It provides a set of guidelines for The structuring of specifications, which are expressed as models. It was launched by The Object Management Group (OMG) in 2001 The Model-Driven Architecture approach defines system functionality using a platform-independent model (PIM) using an appropriate domain-specific language (DSL). One of The main aims of The MDA is to separate design from architecture. As The concepts and technologies used to realize designs and The concepts and technologies used to realize architectures have changed at Their own pace, decoupling Them allows system developers to choose from The best and most fitting in both domains. The design addresses The functional (use case) requirements while architecture provides The infrastructure through which non-functional requirements like scalability, reliability and performance are realized. MDA envisages that The platform independent model (PIM), which represents a conceptual design realizing The functional requirements, will survive changes in realization technologies and software architectures.

"At this point, the only source of useful overview documentation for the Common Navigator are the excellent tutorials at Michael Elder's (the author of the CN) blog. Soon I hope to get some of this transferred into the Eclipse Plugin Developer's Guide. RCP applications can quickly and easily use the CN to show the resources in the workspace. This assumes that your RCP application uses resources (which is another discussion). the CN can also be used for non-resource RCP applications, in that case, these instructions don't apply, as the objects treated by the CN have to be created directly by the RCP application. If you are planning to use the CN in an RCP application that uses resources, there are 3 (2 of which are completely undocumented) things you must do:"

"An "executable" UML model is one with a behavioral specification detailed enough that it can effectively be "run" as a program. This can be extremely valuable in order to test and validate the model, independently of the one or more implementation platforms to which the system being modeled will ultimately be deployed. Or, in some cases, the model itself can actually be run as the production implementation, given an appropriate execution environment. there have been model execution tools and environments for years, even before UML. However, each tool defined its own semantics for model execution, often including a proprietary action language, and models developed in one tool could not be interchanged with or interoperate with models developed in another tool. A previous post described Stephen Mellor's quest of more than a decade to change this through OMG standards for precise UML model execution semantics and a UML action language. In 2008, this led to the adoption of the Foundational UML (fUML) specification, providing the first precise operational and base semantics for a subset of UML encompassing most object-oriented and activity modeling. the fUML specification still did not provide any new concrete surface syntax, however, tying the precise semantics solely to the existing abstract syntax model of UML. This meant that, in order to fully specify a detailed behavior in a UML model - say the effect behavior of a transition on a state machine or the method of an operation of a class - one still had to draw a very detailed, graphical activity diagram. "

Akka is the platform for the next generation event-driven, scalable and fault-tolerant architectures on the JVM We believe that writing correct concurrent, fault-tolerant and scalable applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction. Akka is here to change that. Using the Actor Model together with Software Transactional Memory we raise the abstraction level and provide a better platform to build correct concurrent and scalable applications. For fault-tolerance we adopt the "Let it crash" / "Embrace failure" model which have been used with great success in the telecom industry to build applications that self-heal, systems that never stop. Actors also provides the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications. Akka is Open Source and available under the Apache 2 License.

" Given that web service invocations are always remote across the internet, developing rigorous and responsive web service client applications has always been a challenge for architects and developers working with SOA. JAX-WS 2.0 comes with one effective solution to this problem: asynchronous web service invocation, with which a web service client may interact with a web service in a non-blocking, asynchronous approach. In this article, we will provide an exposition of this technology with examples built upon the reference implementation. Our examples utilize JDK 5.0, JAX-WS 2.0 reference implementation (RI), and Tomcat 5.5. JAX-WS 2.0 requires JAXP 1.3. To replace the JAXP 1.2 released with JDK 5.0 with this newer version, one approach is to download the JAXP 1.3 RI, and copy the endorsed directory under /lib of its installation home to %JAVA_HOME%/jre/lib. We need to copy the jaxp-api.jar of JAXP 1.3 RI to %JAVA_HOME%/jre/lib/endorsed as well. To make Tomcat 5.5 work with JAX-WS 2.0, readers need to copy all the .jar files under the /lib directory of the JAX-WS 2.0 RI installation to the %CATALINA_HOME%/shared/lib directory. As of this writing (in addition to Tomcat 5.5), Sun Java System Application Server 9.0, GlassFish, and Celtix also support JAX-WS 2.0. xFire is in the process of completing its implementation of this specification. Since asynchronous web service invocation in JAX-WS 2.0 is built upon the concurrent programming support in JDK 5.0 introduced with the java.util.concurrent package, we will start from there."

Data, Context and Interaction (DCI) is a paradigm used in computer software to program systems of communicating objects. Its goals are: To improve the readability of object-oriented code by giving system behavior first-class status; To cleanly separate code for rapidly changing system behavior (what the system does) from code for slowly changing domain knowledge (what the system is), instead of combining both in one class interface; To help software developers reason about system-level state and behavior instead of only object state and behavior; To support an object style of thinking that is close to peoples' mental models, rather than the class style of thinking that overshadowed object thinking early in the history of object-oriented programming languages. the paradigm separates the domain model (Data) from Use cases (Context) and Roles that objects play (Interaction). DCI is complementary to Model-view-controller (MVC). MVC as a pattern language is still used to separate the data and its processing from presentation. DCI was invented by Trygve Reenskaug, also the inventor of MVC. the current formulation of DCI is mostly the work of Reenskaug and James O. Coplien.

"The past year I've been learning a lot of Scala and I'm currently working on a new project using Scala. I use LiquiBase, which is a database-independent library for tracking, managing and applying database changes. I'm also using The simple-build-tool (SBT) for my project. So I've put togeTher a little SBT plug-in for running LiquiBase maintenance commands (update, rollback, …) from within SBT. For example, whenever I want to apply new database changes with LiquiBase I can now simply run sbt liquibase-update which sets up a new instance of LiquiBase and executes The LiquiBase update command which migrates my database to The latest version. At The moment The plug-in supports The following commands: liquibase-update, liquibase-drop, liquibase-tag, liquibase-rollback and liquibase-validate. What are The benefits of using The plug-in and not just The LiquiBase CLI? * no download/install of LiquiBase * classpath handled by SBT * no need to provide a big list of parameters or writing shell scripts The plug-in is called liquibase-sbt-plugin and you can find it here on GitHub. Feel free to use it or fork it and suggest changes. I'm still relatively new to Scala and especially SBT so any remarks are very welcome."

Gaelyk is a lightweight Groovy toolkit for Google App Engine Java. Gaelyk lets you deploy small applications on Google App Engine Java. Gaelyk gives you the choice to use Groovy for developing your applications. Gaelyk builds upon Groovlets. and the Groovy template servlet Gaelyk allows you to cleanly seperate your views with Groovy templates and your actions in Groovlets. Gaelyk simplifies the usage of the Google App Engine SDK by providing more concise and more powerful shortcuts when using the datastore, memcache, the blobstore, the images service, the URL fetch service, when sending and receiving emails or Jabber messages, and much more. Gaelyk lets you define friendly REST-ful URLs thanks to its URL routing system Gaelyk provides a simple plugin system for improving code reuse and code sharing You can: download Gaelyk in the download area, learn how to create Gaelyk applications by reading the extensive tutorial, and participate in the community.

Eclipse Rich Client Platform has come a looong way since it was first introduced (and used in Eclipse IDE). The new Eclipse RAP (Rich Application Platform) is also becoming more and more attractive for deploying existing or new Eclipse RCP applications to The web. One of my The projects I'm working on is developed on top of Eclipse RCP. It uses additional plugins such as EMF (Eclipse Modeling Framework) including EMF Editor UI, Teneo (EMF Persistence for Relational Databases), and Hibernate. After some work, I managed to run The whole application on both Eclipse RCP (desktop) and Eclipse RAP (web-based). See The screenshots for proof. Thanks to The recently released EMF Support for RAP I don't have to let go any of The nice EMF generated editor UIs for The web-based RAP version. What's amazing is how little The work I have to do to port The RCP app to RAP. The changes I needed to do is not changing code, but juggling dependencies to plugins and/or packages. Also creating a few platform-specific plugins (different based on wheTher I deploy on RCP or RAP).

There are many approaches available to scale PostgreSQL beyond running on a single server. An outline of The terminology and basic technologies involved is at High Availability and Load Balancing. There is a presentation covering some of These solutions. There is no one-size fits all replication software. You have to understand your requirements and how various approaches fit into that. For example, here are two extremes in The replication problem space: You have a few servers connected to a local network you want to always keep current for failover and load-balancing purposes. Here you would be considering solutions that are synchronous, eager, and Therefore conflict-free. Your users take a local copy of The database with Them on laptops when They leave The office, make changes while They are away, and need to merge those with The main database when They return. Here you'd want an asynchronous, lazy replication approach, and will be forced to consider how to handle conflicts in cases where The same record has been modified both on The master server and on a local copy. These are both database replication problems, but The best way to solve Them is very different. And as you can see from These examples, replication has a lot of specific terminology that you'll have to understand to figure out what class of solution makes sense for your requirements. A great source for this background is in The Postgres-R Terms and Definitions for Database Replication. The main Theoretical topic it doesn't mention is how to resolve conflict resolution in lazy replication cases like The laptop situation, which involves voting and similar schemes.

"The concept of automatic incremental compilation is not familiar to many developers. A very frequent question from Eclipse beginners is, "where is The compile button?" The answer is that an IDE with automatic compilation doesn't need a compile button. Every time you make a change to a file, or a group of files, The incremental builder immediately rebuilds every source file that was affected by The change. In this environment, The idea of compilation as a task The user is involved in disappears -- The world is just always in a compiled state. So what magic goes on behind The scenes to make this happen? How does The Java™ builder know which files need to be recompiled when a given source file changes? This is no easy task, but in broad brush strokes, this is what The Eclipse Java builder does: "

"Libra is an open source project under the Eclipse Web Tools Platform Container Project. It provides standard tools for OSGi Enterprise application development and in particular tools that integrate the existing WTP and PDE tooling so that OSGi Enterprise applications can be developed with both tooling at the same time. Libra also will enable users to work with tools for better experience in the Server-Side Equinox scenario. the goals of the project are: Providing tools for creation of deployable artifacts for application servers implementing the OSGi Enterprise specification, e.g. wizard for creating new Web Application Bundle projects. Providing tools for converting existing Java EE deployable artifacts to OSGi Enterprise deployable artifacts, e.g. wizard for converting Dynamic Web projects to a Web Application Bundle projects. Contributing tools for editing and validation of the metadata of OSGi Enterprise artifacts, e.g. extension of the PDE Manifest Editor for editing manifest headers that are specific to Web Application Bundles. Developing OSGi server adapter, providing basic implementation of configuring an OSGi-based application server, starting it and deploying OSGi enterprise artifacts. This server adapter should be customizable and extensible by adopters. Delivering tools that improve the experience of developing Server-Side Equinox applications. Extending the tools in scope, so adopters can apply them depending on their own application model."

"Blueprint provides a dependency injection framework for OSGi and was standardized by the OSGi Alliance in OSGi Compendium R4.2. It is designed to deal with the dynamic nature of OSGi, where services can become available and unavailable at any time. the specification is also designed to work with plain old Java objects (POJOs) enabling simple components to be written and unit tested in a JSE environment without needing to be aware of how they are assembled. the Blueprint XML files that define and describe the assembly of various components are key to the Blueprint programming model. the specification describes how the components get instantiated and wired together to form a running module. the following documentation covers the 80:20 usage of Blueprint. For further details, please refer to the OSGi Compendium R4.2 specification."

Imagine a scenario where you have some Word documents created in MS Word and you want to display them in your web application. So how would you view the content of the file? A suitable and easy solution is if you could get the HTML form of the Word document then it can be viewed in the web browser within your application. Isn't it great when you could view the documents without having installed some Office viewer? Let's now find out how did we make use of HTML format in making GroupDocs.Assembly more powerful and useful for you. Since version 19.5, the assembled Word Processing documents, Spreadsheets, Presentations, and Email files could be saved as HTML with external resources. This means that the generated reports can now be saved as HTML files along with the resources such as images and, as I have mentioned before, you would be able to embed and view the content of the generated reports within your web application. Read more - https://bit.ly/2WRtqqc

Provide mechanisms for integrating Java security providers into Eclipse: Applications that need to implement security related functionality require cryptographic services upon which to build. Java provides the Java Cryptography Architecture (JCA) as a mechanism for installing implementations of several interfaces used for cryptography, including MessageDigest, Signature, KeyStore, Certstore, and more. In a typical Java application, these implementations reside in the extensions directory of the JRE. In a dynamic Eclipse application, the appropriate packaging mechanism is in Eclipse plug-ins. the goal is to allow JCA to be used in an Eclipse environment while maintaining the programming model of the JCA subsystem. A related goal is to expose the configuration of the JCA system via an Eclipse-based user interface, allowing authorized users to inspect and modify the Security object.

" Over the past few years, and actually the past year, a lot of new initiatives have surfaced in the area of creating so called language workbenches - aiming at facilitating the definition and use of DSLs and code generation. We believe each of these has its own strengths and weaknesses, and none is 'the best' for every purpose. Still, a lot of people keep asking for the best workbench. Based on that, we are now planning to have a Language Workbench Competition, in which we will be able to compare the strengths and weaknesses of these workbenches based on solutions for a predefined set of cases. Keep an eye on this page for more details in the coming, as the cases are being defined and the possibilities of co-hosting this initative at Code Generation 2011 in Cambridge are being investigated."

"Community Dashboard Framework (CDF) is a project that allows you to create friendly, powerful, fully featured dashboards on top of the Pentaho BI server. Former Pentaho dashboards had several drawbacks from a developer's point of view. the developing process was awkward, it required know-how of web technologies and programming languages, and basically it was time-consuming. CDF emerged as a need for a framework that overcame all those difficulties. the final result is a powerful framework featuring the following: . It is based on Open Source technologies. . It separates logic (JavaScript) of the presentation (HTML, CSS) . It features a life cycle with components interacting with each other . It uses AJAX . It is extensible, which gives the users a high level of customization: . Advanced users can extend the library of components. . they also can insert their own snippets of JavaScript and jQuery code. CDF can be used: . As part of a Pentaho solution. This is the most common scenario. . In a standalone mode as an alternative to the Pentaho User Console . Integrated with Portlets, PHP applications, intranet portals and even desktop applications. "