Group items tagged

"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."

Vaadin is a Rapid Application Development (RAD) framework for RIA applications. I only know it for a few months but since I started experimenting with it, I'm really in favor of it. I see a lot of advantages compared to Sun's Java EE standard front-end framework JSF. First of all Vaadin is a java library, so you only have to write Java to build a complete frontend. No need for a specific frontend language, no need for converters (for comboboxes),… This also implies that you can use the full Java power on the frontend side and that's an huge advantage because frontend code is now type-safe and easily refactorable. You can unit test your frontend with JUnit. You can also use all existing java libraries on the frontend side, for example LOG4J. Another advantage is the fact that Vaadin is easy to learn (JSF isn't!) and to use: it's straigtforward. It feels like developing desktop apps and for me developing desktop apps feels much more intuitive than developing web-apps the way I'm used to. Vaadin uses convention over configuration. No need to register new components, validators or whatever in different xml files. Themes have a default folder and a default folder structure. Vaadin is very well documented. There's the book of Vaadin wich explains every aspect of the framework very clear. On the site there's a blog, a FAQ section, a wiki, a forum, examples with Java source code, … It's very easy to extend. Want to create your own Validator? Just implement an interface or extend another Validator and use it. Want to create your own custom server side component? Just extend the CustomComponent class or extend from another component. There's also an add-on directory where you can download UI components, data components, tools, themes, …

"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

"The Open Services for Lifecycle Collaboration (OSLC) is an open (creative commons) REST based service specification aimed at improving/simplifying Application Lifecycle Management (ALM) system integration. A number of aspects of ALM integration are covered by OSLC ranging from Requirements Management to Automation(Build/Deploy). The OSLC Change Management (CM) spec outlines a standard for creating, modifying, and querying for change requests (tasks) from OSLC based service providers. A goal of the Mylyn project is to implement a client for OSLC-CM (see [1]). Additionally, support for both OSLC Automation and OSLC SCM are part of the Mylyn restructuring proposal: http://www.eclipse.org/project-slides/mylyn-restructuring-review.html Once these plans have solidified, we can begin to fill out the roadmaps for each specification. "

"Let's imagine we want to create an application for orders. People can sign in to the system, place orders for various items, check out and have them sent to their address. Very simple, but we can show a lot of things here. As we expect to be writing more than one application of this type and as we also would like to be able to express the structure of the application on a business level (one of the major drivers for DSLs and MDSD for that matter), we come up with the idea of using a DSL to describe what the application does. Defining the DSL is what we did last week. This week, we need to map the concepts of the DSL to some code and some APIs we're going to program against. So, we're going to create a set of code templates for a code generator that can then read our DSL models and create persistence code for us."

"A hub for integrating your enterprise with the rich information available on the Web, the WSO2 Mashup Server leverages popular Web 2.0 formats and protocols into your service platform. Combining simple yet rich mashups with reusability, security, reliability, and governance, the WSO2 Mashup Server includes features for connecting Web Services to humans through Web pages, gadgets, feeds, instant messages, email and more. The WSO2 Mashup Server offers: Go Cloud-Native WSO2 Mashups as a Service gives you instant self-service provisioning, multi-tenancy and has built-in monitoring and metering capabilities. Increase productivity Reduce cost Gain more control Avoid vendor lock-in The ideal platform for defining composite services for user interfaces and mobile applications. A simple way to deploy services developed in JavaScript. Access to REST and WS-* web services, feeds, and scraped web pages with data scripted together quickly using common Web developer skills, the result being a new service, or a web page, gadget, email or instant message. The ability to secure hosted Mashups. Support for both recurring and longer-running tasks and service lifecycles. Monitoring, configuration of security and quality of service settings such as throttling. With no up-front license agreements or subscription fees, getting started with the WSO2 Mashup Server requires less developer effort, ensuring faster ROI."

"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."

A few weeks back, I wrote a blog entry lamenting the attitude toward IDEs in the Scala community. A few people told me that the tooling situation was better than I'd implied, so I thought I'd spend a bit of time looking at using Scala (and Lift specifically) in Eclipse. I think the situation is still a ways away from the tooling situation for Java, but it is actually quite good, and I wanted to post a quick tutorial for those interested in developing Lift in Eclipse. Prerequisites This post assumes that you already have Scala 2.8 final and Eclipse 3.6 on your system. For Eclipse, I recommend upping the Xmx setting if you haven't already - I had issues when I had multiple Lift projects imported with Xmx set to 386. Also, this tutorial is going to use Maven, not SBT. SBT may be a better build tool for Scala projects, but I'm not sure how well it works with m2eclipse - I'm going to play with that more later. I also assume you know how to install plugins into Eclipse - I will create a more in-depth screencast for doing all of this if there is enough interest.

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.

"m2eclipse provides comprehensive Maven integration for Eclipse. You can use m2eclipse to manage both simple and multi-module Maven projects, execute Maven builds via the Eclipse interface, and interact with Maven repositories. m2eclipse makes development easier by integrating data from a project's Object Model with Eclipse IDE features. With m2eclipse, you can use Maven within Eclipse in a natural and intuitive interface. Installing m2eclipse is straightforward, simply point your Eclipse IDE installation to the Eclipse Update Sites. For instructions, prerequisites, and a demonstration video, go to Installing m2eclipse. Once you've installed m2eclipse, you can watch our m2eclipse videos to learn how to install m2eclipse and create your first Maven project with m2eclipse. For a more complete introduction to m2eclipse, Developing with Eclipse and Maven. Developing with Eclipse and Maven is a free, online book, which provides comprehensive documentation for the m2eclipse Maven integration for Eclipse."

"If you didn't know already, Eclipse allows you to define custom templates for commonly used code snippets. Its a very neat feature for those of us who are memory challenged or don't like typing things twice! I think that Apache Camel users could really benefit from having predefined templates for doing Camel routing. I also hear a lot of requests like "I have this Java DSL route, how do I do this in the Spring XML DSL?" so having both Java and XML templates for the same thing is essential."

Apache Axis is an implementation of the SOAP ("Simple Object Access Protocol") submission to W3C. From the draft W3C specification: SOAP is a lightweight protocol for exchanging structured information in a decentralized, distributed environment. It is an XML based protocol that consists of three parts: an envelope that defines a framework for describing what is in a message and how to process it, a set of encoding rules for expressing instances of application-defined datatypes, and a convention for representing remote procedure calls and responses. This project is a follow-on to the Apache SOAP project. Please see the Reference Library for a list of technical resources that should prove useful.

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).

ECF is a framework for building distributed servers, applications, and tools. It provides a modular implementation of the OSGi 4.2 Remote Services standard, along with support for REST-based and SOAP-based remote services, and asynchronous messaging for remote services. See the ECF Wiki for examples, tutorials, other documentation, as well as plans and efforts currently underway for future releases.

SymmetricDS is web-enabled, database independent, data synchronization/replication software. It uses web and database technologies to replicate tables between relational databases in near real time. The software was designed to scale for a large number of databases, work across low-bandwidth connections, and withstand periods of network outage. By using database triggers, SymmetricDS guarantees that data changes are captured and atomicity is preserved. Support for database vendors is provided through a Database Dialect layer, with implementations for MySQL, Oracle, SQL Server, PostgreSQL, DB2, Firebird, HSQLDB, H2, and Apache Derby included. Synchronization can be configured to push data (trickle-back) or pull data (trickle-poll) at an interval. SymmetricDS allows for synchronization between two or more tiers of nodes, such as the following: A farm of web server nodes fronting an enterprise-class general office database A handful of regional servers for synchronizing from the general office to remote geographical areas 1000(s) of store server nodes using a departmental class database to sync with a regional node 10(s) of Point of Sale (POS) register nodes using an embedded database to sync with a store server Deployment options include the following: Web application archive (WAR) deployed to an application server such as Tomcat, Jetty, or JBoss Standalone service Embedded in an application SymmetricDS is written in Java and licensed as open source software under the GNU Lesser General Public License (LGPL).

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.

t just works - Migrate from any version (incl. an empty database) to the latest version of the schema Automatic migration on startup - Ship migrations together with the application and run them automatically on startup Convention Over Configuration - Classpath Scanning to automatically discover Sql and Java migrations Plain Old Sql - SQL scripts for regular migrations (incl. placeholder replacement). No proprietary XML formats, no lock-in. No limits - Java classes for advanced migrations Highly reliable - Safe for cluster environments (Multiple machines can migrate in parallel) Maven support - Maven plugin for migrating manually Fail fast - Inconsistent database or failed migration prevents app from starting. Schema Clean - Drop all tables, views, triggers, ... from a schema without dropping the schema itself

"Cross platform mobile development toolkit consisting of a DSL for defining mobile apps and code generators for creating native apps for iOS, Android, Windows Phone 7 and Google App Engine. Based on Eclipse and Xtext."

"Apache Tuscany simplifies the task of developing SOA solutions by providing a comprehensive infrastructure for SOA development and management that is based on Service Component Architecture (SCA) standard. With SCA as it's foundation, Tuscany offers solution developers the following advantages: Provides a model for creating composite applications by defining the services in the fabric and their relationships with one another. The services can be implemented in any technology. Enables service developers to create reusable services that only contain business logic. Protocols are pushed out of business logic and are handled through pluggable bindings. This lowers development cost. Applications can easily adapt to infrastructure changes without recoding since protocols are handled via pluggable bindings and quality of services (transaction, security) are handled declaratively. Existing applications can work with new SCA compositions. This allows for incremental growth towards a more flexible architecture, outsourcing or providing services to others. In addition, Tuscany is integrated with various technologies and offers: a wide range of bindings (pluggable protocols) various component types including and not limited to Java, C++, BPEL, Spring and scripting an end to end service and data solution which includes support for Jaxb and SDO a lightweight runtime that works standalone or with other application servers a modular architecture that makes it easy to integrate with different technologies and to extend Integration with web20 technologies Apache Tuscany SCA is implemented in Java and C++ (referred to as Native)"