Tuesday, August 29, 2006

[Tech] Spring on the Client

The ulterior motive when companies use Java as development language is the strength in the web area of the language. But Java can also be used to develop rich client applications. On the web you will find a lot of web frameworks, like JSF, Spring MVC and many others. However, there are also some interesting technologies for rich client development, including the Spring Rich Client Project.
The Spring RCP is based on the popular Spring framework and uses some provided features of Spring, like dependency injection or resource management. Principles of the Spring framework (programming to interfaces, OO design, testing) will be also find in the Rich Client. Spring RCP enhance Spring by providing an abstract layer for GUI development. Spring RCP don't reinvent the wheel new, therefore Spring RCP provides integrations for proved existing rich-client-related projects, like JGoodies-Forms, JGoodies-Looks or TableLayout.
The key features of the Spring RCP are:
  • Mature command framework
  • Data Binding and Validation Framework
  • Multiple Window Support
  • Factories for common GUI controls complying GUI standards (Wizards, Dialogs,...)
Chris Parasons gives a short journey through the spring rich client. There can also be find a step by step tutorial for the master/detail component written by me.

[Pub] State of the Art in Java Enterprise Web Application Development

With the rise of object-oriented thinking, frameworks became more popular than never before. A framework is an approach of software reuse and enables developers to establish software systems on an abstract layer. This diploma thesis focuses on the layered architecture where each layer has a predefined task which can be implemented together with a provided framework. This diploma thesis covers the following key points:

  • Introduction to Software Architecture
  • Relevant patterns for J2EE, like MVC, DAO, ORM, Lazy Load or Dependency Injection
  • Architecture of object oriented frameworks
  • Technologies: Hibernate, Spring, Spring Web Flow, Struts, JSF and OpenLaszlo
Special attention will be given to the integration possibilities among the described technologies in this thesis. Read more about the frameworks and their integration possibilities in my diploma thesis. The poster illustrates the 5-layered architecture with an associated technology.

Sunday, August 27, 2006

[Pub] Probing and Monitoring of WSBPEL Processes with Web Services

At CEC conference in San Francisco we (Heinz Roth, Josef Schiefer, Alexander Schatten) presented our paper: Probing and Monitoring of WSBPEL Processes with Web Services.

In this paper, we deal with monitoring/auditing of WS-BPEL processes. Generally, trying to audit BPEL processes, one faces several problems:
  • The BPEL standard provides no auditing capabilities
  • In BPEL engines, auditing is (if available at all) implemented in different ways
  • Auditing over multiple BPEL engines (e.g., integrating various partners) is hardly feasible
In our paper we suggest a new way to transform a standard BPEL process to an auditable BPEL process (which also conforms BPEL standard). This auditable process sends audit information to a dedicated webservice.

Read more about our ideas in our paper.

Saturday, August 26, 2006

[Tech] Current Approaches in Build Autmation: Apache Ant and Maven 2

Until recently, Apache Ant was seen as the default mechanism to do build-automation in Java projects. Since the Apache Maven project released Version 2 of their tool, it appears, that Maven has finally outrun Ant in popularity. This can be seen e.g, by observing other Apache projects, like Cocoon, that actually changed recently from Ant to Maven like many others. In this BLOG article I want to give some impressions of Maven 2 in comparison to Ant; and focus a little more in detail on dependency management.


Generally the concept between Apache Ant and Maven is significantly different. Ant can be seen rather like a toolbox, that offers a set of tools that can be used for developing a build process. This has advantages but also serious disadvantages.

The advantage of this concept is most probably it's flexibility. Many things can be done; the user is definitly not limited to "typical" development/build processes. I used e.g., Ant for some time to generate websites (offline) using XML and XSLT. Additionally as Ant was the dominating tool for the last years, it has substential tool support (e.g., Netbeans uses Ant build-files as default project file).

However, in todays complex problems, the Ant approach has several drawbacks. What immediately comes to my mind:
  • New users are often confuses what "best practices" should be used for a build process
  • Reuse of Buildfiles is typically "Cut and Paste"; meaning: if you once spent a lot of time in fine-tuning a build file for a project it is difficult to use the same approach on a new project.
  • As a consequence: different developers often have different approaches in writing build-files.
  • Handling of libraries is awkward; we will come to that point later again.

Apache Maven actually has a very different approach towards the Software Build process. It is by definition not a toolbox, but follows the idea "Convention over Configuration". This means, that Maven is not only a build tool, but actually Build-Best-Practices implemented in Software.

Hence a complete build process including unit-testing can be started with one command and only minimal configuration in the so-called project object model XML file. But even a simple default project can be generated with one Maven command.

The consequences are clear: the beginner is not confused by many options and possibilities, but instead gets a clear route how to start; including directory and config filename defaults. This also has the positive consequence, that many Maven projects look very similar in structure, hence new developers have an easy time in getting into a new project.

Maven includes no only "build" jobs, but also performs unit-tests, code-quality checks and creates project documentation. If functionality is needed, that is not delivered "out-of-the-box" by Maven, additional plug-ins can be installed into the system.

Library (Dependency) Management

Maybe one of the most interesting functions in Maven is the management of dependencies. Up to now, managing dependencies typically meant to drop all required jars into a lib directory and add it to the classpath using Ant. However, after some time (and usage of systems like Hibernate) the lib directory was filled up with jars, and hardly anyone knew which of those are really needed in in which version!

Maven approaches this problem very differently: within the Project Object Model, the developer declares on which other systems this applications is dependent on including the version! E.g., coming back to Hibernate: In Maven you would declare a dependency to Hibernate Version 2.1.0 and Maven would figure out which additional dependencies exist (e.g., Hibernate might need dom4j and log4j and ...). This makes things much more transparent. Additionally Maven stores all libraries in on single directory (ordered by system, version, ...) and not within the project itself, which saves a lot of storage space, when multiple projects are developed on one system.


From my point of view, Maven 2 is the next step in build-automation and will replace in the near future Ant in many if not most projects. It is true, that there are still some issues reported in larger projects using Maven 2, but these really appear not to be fundamental design flaws, but rather issues, that will be resolved with next minor versions.

However, my tip is to start a new Java project with Apache Maven 2; usage of Ant in new projects should have very well defined reasons. And unfamiliarity of developers with Maven is not a particularly good reason ;-)


I recently wrote a more comprehensive comparison between Apache Ant and Maven in infoweek.ch (german article).

Besides that, a lot of good information is meanwhile out in the Internet helping to get Maven 2 up and running: A good start is the Getting Started Guide from the Maven website. A more thorough coverage of Maven 2 can be found in the free Book from Mergere: Better builds with Maven.

Friday, August 25, 2006

Best-Practices Software Engineering - A new BLOG

This BLOG is dedicated to new trends in Software Engineering:

Who we are?

Members of this BLOG are from

At the moment the following colleagues plan to post articles:
  • Alexander Schatten (IFS, TU Wien; Austrian Computer Society, Working Group: Open Source Software)
  • Stefan Biffl (IFS, TU Wien; Austrian Computer Society, Working Group: Software Engineering)
  • Markus Demolsky (PhD)
  • Dietmar Winkler (IFS, TU Wien)
  • Josef Schiefer (Senactive)
  • Rupert Meinl (Senactive)
  • Gerd Saurer (Senactive)
  • Heinz Roth (PhD IFS, Senactive)
  • Szabolcs Rozsnyai (PhD)
  • and more yet to come...
We want to point out though, that the articles express the experiences and opinion of the very author not the "official" position of IFS, TU Wien or Senactive or any other associated organisation.

What we do?

We are providing lectures in the field of Software Engineering, Software Processes and Value Based Software Engineering. This BLOG is intended to publish our ideas in this fields, make references to research publications, comment new developments in research and technology.

One of our key research areas is the development of event-driven systems which includes the areas of event stream processing (ESP), complex event processing (CEP), event-driven architectures (EAPs), and real-time analytics.

Additionally, we hope, that this BLOG helps students from our lectures, project partners and colleagues from research projects to stay updated and connected to our group.

What is the focus of this BLOG?

In this BLOG we will focus mainly on these aspects:
  • Trends in Software Engineering (e.g., aspect oriented programming, trends in middleware, service-oriented architectures, attribute oriented programming)
  • Software Processes (traditional, agile, VM-XT, ...)
  • Open Source Software and Software Engineering best-practices
  • Quality aspects in Software Engineering
  • Software Testing
  • Java best-practices
  • .net best-practices
  • Short reports and impressions from conferences we attended
  • Reviews of interesting articles and books we read
  • Applications of Software Engineering in E-Commerce
Updates, Access, Comments ...

We plan to update this BLOG regularly, at least once a week. References to other articles and material will be part of BLOG entries.

To stay updated, please subscibe to the Atom news feed provided for this log!

We also would appreciate to stay in touch with our readers, so do not hesitate to write comments to our articles!

We hope, you will enjoy this BLOG!

the SE team!