Thursday, December 28, 2006

[About] Old and New Year and Blog Issues

Our SE Blog is now "on the air" since August, nearly half a year, and we have more than 40 articles of good quality as also regular readers confirmed. So I am personally quite happy with the first months of this Blog.

For now, I wish all my colleagues and our readers merry christmas and a happy new year. I hope for more good articles from all contributors in the new year and for a steady growing community of readers.

However, as nothing is perfect, and I try to improve this Blog; so I am happy about comments and suggestions (maybe as a comment to this entry).

Currently (as there is a new version of released) I am reshaping the design of our Blog. The new design is clearer I think, better readable (width is not restricted) and most of all, we use two new features from the new Blogger: the better navigation, that allows to easily check older articles and the new labels to restrict the view to articles of a special category.

Tuesday, December 26, 2006

[Pub] The iBatis Persistence Framework

A Brief History of Persistence

Starting around 2000, (Java) developers figured out, that accessing relational databases using "plain" JDBC is a rather dowdy activity (a pain in the ass, one might call it too); moreover the differences in object-oriented design and relational databases got too obvious. As a matter of fact around that time a significant number of (partly Open Source) projects were founded to deal with that problem in creating frameworks to map between objects and relational databases in a more elegant way (Hibernate, Castor, Cayenne, OJB, Torque, DODS, Toplink, iBatis just to name a few). Interestingly enough, object-oriented databases were at that time already more or less dead (except for some niche-applications) and XML databases were not yet dead and still sounded promising at that time ;-)

All this was and is accompanied by different emerging and disappearing standards (Jürgen Höller got into details here).


However, today it seems, that we are in a settlement phase. At least in the last one or two years persistence in Java was nearly used synonymously with Hibernate, which is actually a pity. Hibernate is a powerful framework, no doubt, but by good reason recently many developers detect that using a full-blown O/R mapping solution like Hibernate is not always the best idea: Some go even so far to claim, that the whole idea is more or less flawed. The critics claim - and it might not be completly wrong - that frameworks like Hibernate let you start rather smooth, but the longer the project runs, the more you are fighting to get Hibernate do what you actually want it to do (performance, functionality). And to do so, you are forced to work on a low level with Hibernate, HQL, SQL, the Caching framework and whatnot, trying to get mappings so that the desired SQL statements are produced or injecting SQL statements into the framework and workarounds like that.

I do not want to go into details here, I just want to recommend the article from Ted Neward here. What I really do not like about this article are the references and comparisons to the Vietnam war, which is rather stupid and mostly unnecessary in my opinion, still, you can easily skip that part and go to the technical part, which is definitly recommended to consider.

...and the Rest of the Crowd?

So, is there a life after or instead of Hibernate? I think yes: first of all there are very interesting alternative persistence technologies like db4o based on direct persistence of object-graphs, which was also presented at our persistence event and I wrote a brief article recently. But also on the "relational side", there are several alternatives, most prominently I want to mention iBatis.

Apache iBatis

iBatis goes a very different way and is actually not an object/relational mapping tool it is better described by saying it is an object/SQL mapping framework. To get a iBatis application running you need the following artifacts:
  • A relational database and a schema (tables, views, stored procedures, constraints ...)
  • iBatis configuration file
  • iBatis SQLMaps
  • recommended: Spring as DAO framework
The configuration is best done using the Spring-Framework SQLMaps support (the iBatis team meanwhile stopped the development of their own DAO project and recommend to use Spring), check out the details there. Then you define mapping from objects to SQL statements like so:

So actually for all operations SQL statements have to be written (typically insert, update, delete). Depeding on the statement iBatis maps the parameter (parameterClass) or the result (resultClass) to objects. This is done automatically (in simple cases) or by creating a mapping declaration, where the mapping can be adjusted in details. In the Java DAO class the statement can be easily executed using the Spring template:

getSqlMapClientTemplate().update("updatePerson", person);

iBatis Learning Curve and Transparency

It is obviously not possible to introduce a framework thoroughly in a BLOG article, but I want to emphasize, that the learning curve for iBatis is a rather easy one plus the documentation is good and the mailing list helpful. For a skilled developer it should be possible to have the first iBatis application running within some hours.

An additional advantage (and disadvantage, depending on the point of view) is the fact, that using iBatis it is practically always clear, what's happing behind the scences (in contrast to full blown O/R mappers like Hibernate). Or as Bruce Tate expressed it:
"iBATIS is a JDBC helper framework that gives you some of the benefits of OR mapping and usage, but without as much risk."
But this reduction to mapping objects to SQL statements might also be a clear drawback, when you wish to gain a "better" abstraction from the relational database.

What now?

Which framework to choose is actually a difficult decision. But one is for sure: taking Hibernate "by default" is most probably not the best decision. Hibernate & Co are powerful but very complex integration frameworks with a high level of abstraction, defining own query languages to be learned; and a lot of mapping and configuration options are offered, which you better want to know in detail. iBatis on the other hand is very straightforward to learn and use and allows to easily use all functionality of the database without using framework "backdoors".

I suggest to have a close look at the options and decide carefully, but one thing is clear: Hibernate should only be used, if a skilled Hibernate (Castor, OJB, ...) expert is available or one person of the development team is willing to spend some amount of time to get one. Otherwise severe issues can be expected, probably at a time close to software delivery.

And not to forget: iBatis is available for Java, .net and Ruby and works with all databases (in the Java context) where a proper JDBC driver is available.

For more information about iBatis I suggest also the following resources:

Wednesday, December 20, 2006

[Tech] db4o License Issues

As a follow up to our "Java and Persistence" event, I received interesting news about a third licensing option for the object-oriented database db4o: Up to now, db4o was only available in a commercial license and in a GPL license. This GPL license has the significant drawback, that a usage of db4o most probably "infects" the own project and forces it to be under GPL license as well.

This is due to the fact, that db4o has a unique API, hence the project that uses db4o is derivative work. This fact obviously is very dangerous for Open Source project that do not intend to use the GPL license.

However since recently there is a third licensing option as can be read in the January Newsletter of db4o:
"db4o has issued a third licensing option for free/open source projects that want to embed db4o but do not want to (or are not able to) license their derivative work under the GPL in its entirety. This initiative aims to proliferate db4o into many more open source projects by providing compatibility for projects licensed under Apache, LGPL, BSD, EPL, and others, as required by our users." (quoted from the newsletter)
From my point of view, I am happy about this decision, as it makes a pretty interesting technology more accessible for a broader community of developers.
Read more about Persistence in the Java Environment, also covering db4o in the report following our "Java and Persistence" event.

Tuesday, December 19, 2006

[Event] Software Engineering for Everday Business - Review of the Third Event

The third Event in the series "Software Engineering for Everyday Business" dealt with modern architecture styles and development best-practices. Marcus Demolsky and I held the presentation. The key concept of this lecture was "patterns". I see patterns as best-practices on different "levels":
  • Software Build (best practices)
  • Testing
  • Enterprise Architecture
    • Coordination
    • Service Oriented Architecture
    • Event Driven Architecture
  • User Interaction Patterns (e.g., "Web 2.0")
  • Enterprise Application Patterns
  • User Interface Development (e.g., MVC)
  • Application Level Design Patterns
Hence we started refreshing the knowledge of design patterns (like Oberver, data access object, facade...), layered architecture, SOA, EDA, aspect oriented development and finally ideas and examples of "Web 2.0".

After this rather theoretical part, we showed some practical examples on frameworks like Spring and Maven. Particularly Maven is very interesting as a manifestation of build-automation best-practices. Eventually I ended with a round up and outlook to the last event in the series dealing with quality assurance and talked about automated testing and profiling using Eclipse TPTP.

Please check out the resources website for a download of all presentations.

I hope to see many of you at the last event in January!

Wednesday, December 06, 2006

[Pub] Testing Event-Driven Business Processes

With new paradigms for software development and software architectures (such as agile software development, service-oriented architectures, IOC containers, etc.) companies are able to respond faster to changes in a business environment. For our sense and respond system SENACTIVE InTime, we developed a testing framework that supports these paradigms by being able to test the correct behavior of event-driven business solutions. With our testing framework we show that software tests can be used to make model assertions for business processes.

We introduce process test specifications, which allow users to define simulation settings, test components, assertions and test scripts in order to make a business process testable. A detailed description can be found in the journal article on testing with event-driven business processes.

In the paper, we also outlined how the proposed concepts can be used for the testing of WS-BPEL processes. Nevertheless, we realized that testing BPEL processes is very hard since it is difficult to intercept process requests and responses. Alone the way BPEL requests and responses are structured (message parts etc.), it requires a great deal of work to handling/integrating this information into a testing framework.

Nevertheless, a BPEL process description includes also some very useful information which can be used for generating realistic input data. In our testing framework, we use a simulator which extracts the control flow of the BPEL process for generating event sequences.

Our testing framework is part of a larger, long-term research effort aiming to making testing an integral part of the management of business processes. Part of this work is the development of a test bed for testing, simulating and benchmarking business process solutions. One of our key ideas to improve our current testing framework is to use a standardized language for the definition of process test specifications.

[Event] Software Engineering for Everday Business- Review of the Second Event

The second presentation of the series “Software Engineering for Everyday Business”, initiated by UBIT of the Wirtschaftskammer Wien took place on November 30th. The content of the presentations focused on modeling and model driven software development.
Modeling was covered by introducing the basics of software modeling, a modeling language, and a modeling method. Model driven software development was covered by an introduction to the concepts, primary approaches, and tools as well as by a case study.

Part 1: Modeling

Understanding the concept of software modeling is simplified by drawing analogies to models as used in everyday life. Models as used by architects are specifically interesting as they play a role similar to software models in requirements elicitation, design, and documentation. Software modeling brings in an additional difficulty as the proper level of abstraction is not always obvious because, in fact, source code can be considered as just another kind of model.

The Unified Modeling Language (UML) is the de-facto standard for object-oriented software modeling. It provides a set of modeling concepts and notation supporting many typical modeling requirements. Despite the advantages of UML it is often beneficial to use additional modeling techniques to cover, e.g., graphical user interfaces and database design.

In classical software processes, it is recommended to use modeling in a rather waterfall-like manner, leading to an overhead of maintaining consistency of models, changing requirements, and system implementation. Agile modeling is an approach to employ modeling within an agile software development process, emphasizing the constructive and communicational aspects of modeling rather than creating documents to be handed off. This way, it better copes with the fact that models are abstractions which are subject to misunderstanding - unless the abstraction process were explicitly specified, which is exactly the subject of model driven software development.

Part 2: Model Driven Software Development

Model driven software development attempts to raise the level of abstraction and consequently the productivity of software development. These improvements are feasible based on the fact that many tasks of software implementation pertain to rather routine activities of handling a complex infrastructure which is often similar for a set of projects. Several approaches to model driven software development have been proposed, Model Driven Architecture (MDA) being the most well known. MDA aims at abstracting from details of specific implementation platforms thus potentially allowing to "model once and build anywhere".

Tool support is crucial for model driven software development. Several tools supporting MDA were presented and analyzed according to a catalogue of criteria. The state of practice is that many different tools exist, each having a different focus and supporting different aspects of UML. Standardization, the original aim of OMG when specifying the MDA, is only partly implemented. Therefore, the decision to base a project on a certain MDA tool is critical as it establishes a very strong dependency between the project and the chosen tool.

A case study, which was conducted using the MDA tool ArcStyler, revealed some of the details that need to be taken care of in an MDA project. These include the tool's support of modeling techniques and target implementation technologies, the time required to understand the tool, the need to work with different levels of abstraction, i.e., model and code, and others. The conclusion was that MDA tools can offer a considerable increase in productivity which, however, is not for free.


Most questions were triggered by agile modeling and by model driven software development. It was discussed how agile modeling and agile methods in general could be implemented in practice. Regarding model driven software development, most questions revolved around practical experiences and available tool support.


To dowload the slides from this presentation as well as from the last event please go to the dedicated download page.

This text was written by Gerhard Kramler and edited by Alexander Schatten

Monday, November 27, 2006

[Event] Java & Persistenz: 23. Nov. 2006 - Report

Before I go into technical details, I want to thank again all speakers at this event. I personally enjoyed it a lot, and learned some new things. My impression was, that also the audience was interested: not only did I get good feedback, but also the fact, that hardly anyone left within more than three ours speaks for itself:

happy audience until the bitter end ;-)

Werner Guttmann and Data Binding

The "Java and Persistence" event on Nov. 23 was opened by the first speech, held by Werner Guttmann. Werneris the project leader of the well-known Castor project and talked about general concepts of data-binding. The problem is generally speaking, how to map between different types of data-representation: typically between objects and relational tables or objects and XML. The Castor project has the advantage to do both bindings within one framework. The XML mapping gained significant importance with the rise of Webservices.

Werner additionally emphasised the importance of separation of concerns. Simply spoken: things that do not belong together should be kept separate. This idea was also supported by the other speakers and brought up an interesting discussion in the end: current trends in Java development practices (e.g., in EJB 3 or Hibernate annotations) suggest to enrich objects with all sorts of metadata. The discussion unfolded the problematic behind this approach, particularly as certain types of metadate apparently break the separation of concerns. E.g., when in an object concrete mapping information (database table name, field names, and the like) is kept in annotations.

On the one hand, this type of annotation clearly supports build-automation in the sense, that from one source file all other artifacts (XML mapping information and database metadata) can be generated (and makes it easier to keep these issues in sync). On the other hand, this mixing up of concerns can reduce the reusability of e.g., the object that is annotated.

Werner additionally suggested, that keeping concerns separated is a very important first step to go towards model driven architectures (MDA). Whereas he is still somewhat sceptical about the applicability of MDA, he also described clear advantages of these approaches (in terms of maintainability, reduced need to manually write repetitive code ...).

Jürgen Höller - Spring ORM

Jürgen Höller, one of the founders of the Spring Framework, held the second speech giving a brief introduction to Spring, then focussing on the O/R support. Spring is a highly modular framework, that allows to pick out the functionality that is needed for the very project. In the "core" it is an inversion of control (dependency injection) container managing the lifecycle and configuration of objects/components. (Martin Fowler wrote a good introduction into this pattern.) A second import feature of Spring is the support for aspect oriented programming (AOP). Jürgen pointed out, that the AOP functionality is important even if the developer does not define "own" aspects for the application: but consistent transaction handling based on declarative transaction management require this feature withing Spring.

However, the main focus of the presentation was on the support of various O/R mapping frameworks within Spring. Here it also got very clear, that Spring can be seen as the glue between various frameworks but does clearly know its limits: Spring does not provide "own" O/R functionality and is not planning to do so, but relies on proven technology and allows the developer to choose the best fitting one. This can be observed in several fields (e.g., remoting, view technologies)

Spring supports the following O/R mapping frameworks in a consistent manner:
  • Hibernate
  • JDO
  • Oracle Toplink
  • iBatis SQL Maps
  • JPA
Besides these external frameworks, Spring offers support for "direct" JDBC usage wich can be appropriate in some scenarios. However, it is important to note, that Spring does not abstract these O/R mappers, but allows the developer to use the full functionality plus the API of the selected framework. Spring helps to integrate the O/R mappers into a consistent component configuaration and lifecycle management, transaction management and exception handling.

Speaking of which, exceptions are an interesting part of the integration story, that many developers might not be aware of: Jürgen stresses the fact, that declared exceptions are part of the object/contract! What does this mean:

Consider a data access object that implements the according DAO interface and connects e.g., to Hibernate. Now: within the data access operations in this DAO implementations exceptions can occur: in the case of a direct use of Hibernate, the exception would be a Hibernate exception. This is ok, as long as the exception can be handled within the DAO. But it is problematic, when the exception has to be escalated to the business logic. This would mean, that the DAO interface would have to declare Hibernate exceptions, thus would be too close coupled to this framework.Spring on the other hand, offers (among others) a consistent exception definition that is not bound to a specific framework.

Jürgen eventually iterates through the supported frameworks and summarises the "history" of O/R mapping and gives some insight into the future development. He sees Hibernate currently beeing the by far most used technology. However Hibernate (Castor, Toplink...) brings a significant piece of complexity into a project, and it might be appropriate to consider alternatives like iBatis in certain project types. Jürgen also discusses the development of the JDO and JPA standard. He actually sees in JPA the successor of JDO; there is actually a new version of the JDO standard (and Spring supports these), however, Jürgen argues that it comes too late and lacks support in industry and open source community.

Yet it is mentioned, that the JPA standard is of considerable complexity. Currently fully featured, it is only supported by the Glassfish application server. Further implementations are on the way. But due to the complexity of the standard it will not be implemented widespread.

Stefan Edlich - db4o

Stefans presentation was rather short, but after all this complexity we had to deal within in the O/R world, the concept of db4o was stunningly easy and straightforward. But also Stefan pointed out, that it is crucial to select the right technology for the right problem. I strongly suggest to follow this up in his slides! I particularly recommend slide 12: Stefan asks two important questions here:
  1. Who owns the data
  2. "Will someone break the barrier"
Meaning: is there a need for an application-neutral representation of the data. According to these two questions he suggests to use RDBM systems when:
  • Data needs to be stored in a neutral way, different views are required
  • OLAP is applied
  • Clustering is necessary
  • additional DB features required
He sees the advantage of systems like db4o:
  • No mapping is needed (no neutreal representation is required)
  • Higher performance
  • Deeper object graphs can be stored easily
  • Scheme changes are supported
  • no administration of the DB required
He additionally shows on own slide how easy the usage of db4o is within an object-oriented language like Java or .net.

(However, in the discussion Jürgen adds, that he sees the strength of RDBM systems in the very mature support of multi-user access and transactions. This might be still a problem for systems like db4o.)

Finally, Stefan discusses the query functionality of object-oriented databases. He actually sees the future in native queries, where query commands are part of the language (comparable to MS-Linq for C# 3.0).


I have drawn several conlcusions from this event. First, I was (again) impressed by the concepts of the Spring Framework. Moreover, I found myself confirmed by the observation, that Hibernate & Co bring a significant level of complexity into a project (it is good to realise, that it is not sheer stupidity on my side). So the application of frameworks like Hibernate can be a very good decision, but a decision that has to be taken carefully. In any case very good knowledge of the underlying O/R framework is required for a successful project, as Jürgen stresses.

As a side note: I for myself was supported that sticking to iBatis can be a good decision for many problems.

Finally, Stefan brought in a very important message in emphazising that there is a broad variety of persistence technologies out there, starting from "monsters" like DB2 and Oracle, over systems like Derby to object databases like db4o and even exotic solutions like prevayler. The concrete decision for a technology should be done early in the project, but not as a dogma without good arguments (as Jürgen pointed out).

Downloads and Comments

The collected presentations are prepared for download:

I want to add the obvious: this report is my subjective understanding of this event. Please contribute with your own ideas and observation by writing comments! This is highly appreciated!

[Misc] Awesome presentation

A really great presentation! Dick Hardt from Sxip Identity presented it at the Identity 2.0 conference. Besides the cool presentation, they have a nice solution too ...

[Event] Software Engineering for Everday Business: Modellierung

This posting is in German as the event is in German too, however, the report will follow in English

Diesen Donnerstag (30. November) findet die zweite Veranstaltung der Reihe "Software Engineering for Everday Business" statt:

Details zur (kostenlosen) Anmeldung und zu den anderen Veranstaltungen finden sich im Ankündigungs-Posting, bitte dort nachlesen.
(nicht-Wirtschaftskammer Mitglieder melden sich bitte über die OCG an!)

Diesmal werden Gerhard Kramler und Manuel Wimmer über moderne Aspekte der Modellierung sprechen. Modellierung, bspw. mit UML 2 wird ein wesentliches Thema sein. Dieser de-facto Standard dient zur zur Unterstützung von Anforderungsfindung, Anforderungsanalyse und Projektmanagement und kann dabei auch die Kommunikation innerhalb des Teams, bzw. mit dem Kunden unterstützen.

Eines der Hauptziele der Weiterentwicklung von UML war eine verbesserte Unterstützung der modellgetriebenen Softwareentwicklung bzw. deren Standardisierung in der MDA. In der modellgetriebenen Softwareentwicklung werden Modelle mittels Codegeneratoren direkt zur Implementierung benutzt. Der Einsatz von Codegeneratoren ist besonders geeignet für die Automatisierung von schematisch gleichen Programmieraufgaben innerhalb eines grösseren Projektes oder über mehrere Projekte hinweg.

Der zweite Teil der Veranstaltung gibt einen Überblick über aktuelle Werkzeuge zur modellgetriebenen Softwareentwicklung und den Einsatz von UML in diesem Bereich.

Wir freuen uns auf rege Beteiligung der Teilnehmer, die vielleicht auch mit eigenen Erfahrungen die Diskussion bereichern können.

(Ankündigungstext stammt von Gerhard Kramler)

Friday, November 24, 2006

[Event] Report from Java & Persistence: 23. Nov. 2006:

So, just a short posting at the moment: I personally enjoyed the event yesterday very much. Each one of the presenters did a great job from my point of view. The fact, that nearly the complete audiece stayed until the bitter end shows me, that there was at least some interest there...

However, I ask you for a little more patience: I will bring some more information about the event soon; I am also waiting for the presentations and will provide the "full package" here.

Please stay tuned (probably subscribe to the RSS/Atom feed from the Blog).

Monday, November 20, 2006

[Event] Java & Persistenz: 23. Nov. 2006 - Update

Diesen Donnerstag findet unser "Java & Persistenz" Event unter Mitwirkung von Jürgen Höller (Springframework), Werner Guttmann (Castor) und Stefan Edlich (db4o) statt.

Details finden sich in diesem Posting.

Wichtiges Update: Die Veranstaltung findet am

Donnerstag den 23. November
von 15-19 Uhr
im TechGate im 3. Stock statt

Eintritt frei, Anmeldung erforderlich (siehe anderes Posting).

Freue mich auf rege Beteiligung auch bei der anschliessenden Podiumsdiskussion!

Thursday, November 16, 2006

[Pub] Eclipse-Plugin for XFire

I'm proud to present my online article in the Eclipse magazin. This article presents the Eclipse-Plugin for the OpenSource SOAP framework XFire, by demonstrating a Step-By-Step sample. My last article in the JavaMagazin describes the conecpts of XFire and how to use XFire with the Spring framework.

Friday, November 10, 2006

[Event] Software Engineering for Everday Business - Review of the First Event

The first presentation of the series “Software Engineering for Everyday Business”, initiated by UBIT of the Wirtschaftskammer Wien took place on October 9th. The content of the three presentations focused on Software Engineering and Software Processes.

Starting with a basic introduction to Software Engineering and corresponding Life-Cycle Phases, a set of selected recent software processes (Vorgehensmodelle) were presented to provide an introduction to modern software engineering practice.

The slides (german) from this event can be downloaded here.

Part 1: Introduction to Software Engineering

The construction of high-quality software products requires professional processes (Software Engineering). Depending on various project criteria (e.g., project type, project size, and application domain) different requirements must be considered at the beginning of each software project. The increasing complexity of projects needs efficient and effective teams with appropriate roles and adequate skills. Examples for a suitable role distribution regarding “small” and “large” projects conclude the first part of the presentation.

Part 2: Life-Cycle Phases

The Life-Cycle-Process affects software projects and products as well. The typical Life-Cycle starts with the first idea, includes analysis, design, implementation and testing, operation and maintenance, and concludes with the retirement of the product. The presentation of this part includes important aspects of all Life-Cycle Phases and pays special attention to the requirements elicitation and analysis phase. Two selected concepts - the V-Model and the incremental model - of basic software processes conclude this part of the presentation.

Part 3: Selected Software Processes

According to a wide range of project requirements, a large number of different software processes came up in industrial practice. The third presentation focus on three selected recent software processes: V-Modell XT, Rational Unified Process and concepts of Agile Software development.

The V-Modell XT - based on the V-Modell 97 – is a mandatory process approach for all common IT-projects in the public area in Germany. An important enhancement focuses on the integration of acquirers within the software engineering process through a specific project type. The basic components of the V-Modell XT support flexibility and adjustment possibilities to individual project requirements: (a) project modules (Vorgehensbausteine) encapsulate products, roles, and activities; (b) project execution strategies (Durchführungsstrategien), and (c) Decision Gates (Entscheidungspunkte) defines the sequence of modules and their dependencies. Tailoring, i.e., individual selection of process modules (mandatory, required and optional modules) according to project type enables a sound adjustment to individual projects. These concepts support the applicability for small and medium enterprises (SME) as well.

Further information about the V-Modell XT framework and (open source) tool support are available at

The Rational Unified Prozess (RUP) is a phase-oriented process model with wide dissemination in industrial practice. The process model consists of four major phases (inception, elaboration, construction, and transition) including 9 workflows / disciplines. The basic concept includes roles (responsibility), artefacts (products) and activities (how to proceed). Workflows (6 engineering workflows and 3 supporting workflows) describe the sequence of steps to construct a product.
Milestones at the end of every phase enable the review / inspection of the constructed artefacts. Based on the decision at the milestones, phases may be repeated (incremental approach) to achieve higher product quality and/or completeness of requirements. RUP is supported by a wide range of software tools.

Agile Software development models, e.g., eXtreme Programming (XP) and SCRUM enable iterative software development in very short time intervals and with tight customer interaction. This tight customer cooperation enables a flexible management of requirements (e.g. changing of customer requirements) and leads to an early delivery of products, e.g., prototypes. Agile software development models came up to improve common (strictly defined) software processes and still grow in their importance.

Further Information:

Coming Up

Next event of this series of presentation: 30.11.2006, 16:00. These presentations will dal with modelling approaches, UML (Unified Modelling Language) and MDA (Model Driven Architecture).

Thursday, November 09, 2006

[Event] The last day at the W-JAX

Today was the last day at the W-JAX.

Beginning with the session concentrated on ESB - Enterprise Service Bus. The speaker (Wolfgang Frank, Michael Kloss) discussed about the concepts and usage scenarios of an ESB. They also mentioned that many people think that ESB is SOA. That's wrong, ESB is not SOA. An ESB provides a central communication plattform for components, by providing entry points, different transport protocolls and more. After providing an overview of an ESB the speaker explained the concept of JBI (Java Business Integration). JBI provides a PlugIn mechanismus by defining:
  • Interface
  • Communication ways
  • Messaging
  • Management
  • Deployment
This session closed with a live demo of the OpenSource ESB ServiceMix.

As architecture is one of my main interests I attended the session about How to avoid the architecture breakup in projects. It is distinguished between a structural and technical architecture in software systems:
  • Structural architecture, describes how the software system is structured (components, interfacs,..)
  • Technical architecture, describes with which technology the architecture is build
Many software systems know the Big Ball of Mud Pattern. To avoid such a breakup it is necessary to expose your code to daylight, by using:
  • Code Reading
  • Defining Rules (naming conventions, exception handling)
  • Define metrics
Current software projects often miss the architecture layer. Special architecture tools help to create this absence layer. In order to manage the architecture, these tools need an abstract architecture (subsystems and their interfaces, rules) . He also mentioned that the layered architecture is the most common style. The plain layered architecture is often not sufficient in real projects. Therefore combinations of layeres are used:
  • Process and library layered model
  • Vertical slices
  • A layer is further refined into layers
Then the speaker discussed classical architecture smells:
  • Cycles
  • Duplicated code
  • Size of the code modules
  • Coupling
  • Unused code artifacts
  • and more
To avoid such smells it is necessary to introduce an architecture management. But many companies (management) do not attach importance to this area. Tools for architecture management support:
  • Architecture Analysis
  • Understand code basis
  • Reengineering Support
This session shows that architecture management is an important process in current and future software projects.

Spring, Hibernate, JSF or Maven are defacto standard technologies in current software projects. The session Architecture Magic with Maven, Spring & Co illustrates how to built the technical archicture with proved technologies. He mentioned that many companies do not know their architecture, when you ask for it. The only thing is: "Hmm, we use Spring, JSF and Hibernate, is it not the architecture?". Technology is not architecture! Technology can be used as MetaData for the architecture. Then said something about Enterprise Java Next Generation (EJNG):
  • Lightweight Container
  • Ajax
  • J2EE without EJB
  • Testing, Continuoius Integration
Technologies are often difficult to integrate in a suitable way. Often developers must set up bridges to integrate two or more frameworks. The session ends with a little live demo, showing how to make a technical architecture with Maven & Co. Therefore Maven is an ideal canditat to manage:
  • Dependencies and their scopes
  • Deployment of artifacts
And Spring is a good choice to integrate the components at runtime, by using Dependency Injection and the like.

The last session Patterns for asynchronous messaging gives me an overview about messaging with JMS. Adam Bien illustrates problems when using messaging (Point-To-Point, Pub/Sub). The most difficult thing with messaging is the exception handling and recovering. Here he pointed to the "Dead Lacking Queue" where messages are saved which are not arrived their destination. It is important to know, that JMS is not suitable for every software system. Software Architecture must make a trade off between decoupling and performance. Also the test of a system using messaging becomes more difficult. Adam presented the following patterns:
  • Fire and Get
  • Broadcaster
  • AP (Asynchron Reply Response)
  • Observer - Observable
  • Pseudo - Observeable
  • Pseudo Synchronous
  • Thread Imulator
  • Concurrency Control
Adam Bien was my favourite speaker on the W-JAX, because he presented at a high level of competence.

Wednesday, November 08, 2006

[Pub] XFire an alternative to Axis

I am pleased to announce my article about XFire in the actual issue of the german JavaMagazin. This german article gives an overview about XFire and how integrate this technology in a Spring application in order to expose Spring beans as web services. I also demonstrate the usage of Web Service annotations.

[Event] Second day on W-JAX

Today was the second day of the main conference at the W-JAX.

As a Spring fan I was forced to attend the sessions about Architecture with Spring and Spring and AspectJ. Eberhard presented why Spring is a unique technology, because it concentrates on simple objects and enclose these simple objects with:
  • Dependency Injection to compose applications
  • AOP to manage Cross Cutting Concerns (Security, Logging, Transaction)
  • Portable Service Abstraction in order to provide an easy access to available technologies (Hibernate, JDBC,..)
He also illustrated Best Practices of Spring and how architectures can be built by using Spring. A typical Spring application is based on the layered architecture:
  • Service objects/Business Facade
  • Data Access Layer, seperated in a DAO interface and DAO implementation layer
Why is Spring a good choice in the Data Access Layer?
  • The test of the DAO layer becomes easier, by using Mock objects
  • More technologies can be used, like Hibernate, JPA, iBATIS or JDBC
  • Spring provides a consistent Exception hierarchy
He also responsived to the advantages of Spring in the Service layer, like declarative transaction management by using AOP. Beside the above advantages, he illustrated how to organize the layers in the code. Therefore he pointed to the following approaches:
  • Configure each layer in an isolated configuration file and import these configurations to the application context
  • Create an application context for each layer (dao, service, gui)
  • OSGi
  • Packaging and Spring 2.0 AOP pointcuts
  • @Repository annotation
A very interesting technology is AspectJ, where you can define rules for the code. For example it is possible to say, that a DAO implementation can not use a class of the service layer. These rules are defined through aspects. In my opinion these two sessions where convincing to use Spring as base technology and framework in future projects.

At present there is a lot ruble around Ruby on Rails. But what is the problem? It is not Java. Therefore the Java community awake the Grails project providing the possibility to develop web applications in a fast way. The session Grails - Rapid Web Application Development gives me the chance to get a first impression about Grails. And it rocks! Grails is a classical MVC framework based on the following key components:
  • Groovy
  • Spring (IoC, Spring MVC, Spring Web Flow)
  • Hibernate (Persistence)
  • Site Mesh (Layout Framework
  • Quartz
An application is build by using groovy commands with parameters, like application name, domain objects and the like. With this metadata, Grails can produce a sekeletal structure of the application. The speaker went through the MVC pattern in Grails, by explaining how the Model, View and Controller in Grails are implemented. An interesting thing in Grails, is that the produced skeleton already provides CRUD functionality. I believe that this framework could become a serious technology in near future, because the following key features are provides:
  • Auto Reloading (agile development)
  • Spring integration
  • Hibernate integration
  • AJAX support by integrate some toolkits, like DOJO.
The last session I attented this day concentrates on Architecturemanagement, where the speaker illustrates actual problems of complex software projects. The predefined software architecture often changes during the development. In order to ensure a stable software architecture during the software development process it is necessary to define some metrics that helps to identify architecture failures. Beside the metrics he illustrated the steps to make a logical architecture:
  1. Define horizontal layers (Data, Business, Presentation)
  2. Define vertical slices, illustrate the business
  3. Define rules
With this logical architecture the subsystems can be identified. He also mentioned that Spring is in his opinion the best framework to structure an application.

Tuesday, November 07, 2006

[Event] First day on W-JAX

Today, was the first day of the main conference at the W-JAX.

It started with an excellent keynote holding by Tim Bray, one of the most important people in the Java Community. His presentation focus on the future of the Java platform. Beginning with the essential step of Java into the Open Source community. Thereby he lists the main advantages coming with the community integration. He also mentioned, that in few years are many different implementations on Java will be available. But each implementation going public must accomplish the requirements given by Sun, to ensure that programs based on Java are portable on different runtimes.

In near future, Java is not the only dominant language running on a JVM. Tim provides a chart where Java, Phyton, Groovy and many more, are placed on the language sector. The new script languages do not replace Java, but provides interesting enhancements. Focused on Ruby, he shows the popular short video of Ruby On Rails, where a simple blog protoype is developed in a very short time. I come to the conclusion, that Java is further the most important language in the Web sector and languages like PHP and Ruby provide interesting concepts for Java.

The second keynote concentrated on SOA governance. This keynote clarified again, that SOA is a long-term project. Operate on SOA governance implies to know the organisation. It is important to communicate between the different departments in an organisation. Hit questions of SOA governance are:
  • Artifact Use
  • What is the impoact of a service change
  • Are services operated according to policies and metrics
  • SOA lifecycle
The SOA governance also concentrates on defining metrics, e.g. complexity of services, development efficiency. The main message of this session was, that SOA Governance bridging the gap between business and IT.

As AJAX is big hype, I attend the session about AJAX frameworks. This session gives an overview on current ajax frameworks both open source and commercial. Rico, DWR or Google Web Tookkit are current frameworks in the open source sector. Each presented framework was associated to a defined AJAX layer (snippets, widgets, client-side engine and Ajax framework). Also major advantages and disadvantages of each framework were discussed.

The second session about BPEL schon einsetzbar ("BPEL ready for primetime") focused on the technical perspective, where the speakers presented current BPEL engines, including Active BPEL, BEA AquaLogic or Oracle BPEL. Ending with a live demo by implementing a little demo process using the Oracle BPEL designer the conculsion is, that BPEL is an additional layer in an architecture, which reduces the performance. Therefore it is necessary to plan the service orchestration carefully and keep in mind, that BPEL is not suitable for every use case (e.g. transfer large data).

Current application are already designed with architectural pattern, like factories, proxies or adapters. But many applications missing an important aspect: Security. Bruce Sams, presented interesting security patterns which enable software developers to develop secure applications. At present there is no official pattern catalog for security patterns. Bruce presented first approaches:
  • Audit Interceptor pattern
  • Secure Transfer Object pattern
  • Secure Logger pattern
  • Authentication enforcer pattern
  • Secure Service proxy pattern
He pointed to use a layered approach to securing applications. Layers are based whether data is:
  1. in transit
  2. in process
  3. at rest
The last session gives me an insight view of the popular Spring framework. Jürgen Höller gave an overview on Spring and how the framework is managed.

On this occasion we want to mention again our event on Nov 23. where Jürgen Höller is also present as a speaker and will talk about Spring and Java persistence strategies.

Monday, November 06, 2006

[Tech] Jon Udell's Podcast: "Conversation with..."

Jon Udell and Slow XML ;-)

Markus, thanks to your first report from the W-Jax conference. However, your posting about SOA and "slow" XML brought two things to my attention:

  1. I should recommend the excellent Podcast from Jon Udell, can be found in iTunes or here.
  2. I should mention Podcast: "Conversation with John Schneider about Efficient XML"
Schneider has a company dealing with libraries for "binary XML" and he apparently tries to get according standards to W3C. The idea is, as far as I understand from the Interview, to generate a more efficient "binary" XML layer. This framework is uses a binary representation of the text-based XML format and uses Schema-based optimisation techniques. However, the applications (XML Parser, SOAP libraries...) should be able to use the new libraries without change in the application logic by just exchanging the underlying parser using technologies like JAXP.

Schneiders Company currently develops libraries for Java and .net; open implementations are not yet available (a good project idea, btw...!).

However, Schneider claims, that performance is dramatically better and bandwith-consumpution far lower with their binary-XML technology and refers to customers in automotive and aircraft manufacturers.

I would be very interested in concrete experiences using these new concepts, anyone...?!

[Event] SOA Day at W-JAX

I am in Muenchen, Arabella Sheraton Hotel, where the first day of the W-JAX conference takes place. This conference is one of the biggest conferences in the german area. The SOA management day, as the name implies, concentrates on Service Oriented Architecture.

The session "BPEL schon einsetzbar?" focused on current problems with the different notations used for business processes. One of the most used notation in the past was the EPK ("Ereignisgesteuerte Prozesskette"). This notation is the simplest approach to model business processes. From the technical point, the EPK is not the best choice, because it contains no technical information. Here, the new BPM notation (swimlanes, loop constructs) provides a better way to model technical aspects. A process model based on the BPMN can be transformed in a BPEL process, because the BPMN has all necessary constructs to develop BPEL. This session also shows that companies often rape BPEL, because they use BPEL for wrong processes. BPEL should be used to model the business process and nothing else.

SOA, currently a hype issue, solves all problems, as it is written in books, magazines, presented on conferences. A critial and interesting session was the one of Dr. Gernot Starke. He discuesses the following problems on SOA projects:

  • SOA projects are big projects
  • Different stakeholders (IT and Faculty)
  • No or less experience
  • Many Risks (time pressure, new technologies)
Beside the problems, he lists the following pitfalls:
  • There are too many standards
  • Loosely coupling is not realy realized (Point-To-Point communication between Web Services)
  • XML is everywhere (Slow performance)
There were also sessions regarding to the new Service Component Architecture (SCA) and the importance of the governece in SOA.

As my previous blog announced, SOA is not a technology. SOA is a business first approach: The management must know their business processes and how to deal with them. And more imporant is, the governance, which must be planed in an accurate way.

Monday, October 30, 2006

[Event] Software Engineering for Everyday Business

This article is in German, as the language of the announced event is German as well. However, we will report from the event in English, so stay tuned
Veranstaltungsreihe des Ubit, Wirtschaftskammer Wien

Initiiert von der Wirtschaftskammer Wien (Ubit) und mit Unterstützung der Österreichischen Computer Gesellschaft (OCG) veranstalte ich eine Vortagsreihe zum Thema "Software Engineering for Everyday Business". Die Vorträge werden von Experten des jeweiligen Bereiches der TU Wien (ISIS) gehalten.


Im Umfang von vier Veranstaltungen decken wir folgende Themenbereiche ab:
  • Software Engineering und SE Prozesse (9.11.2006): Dietmar Winkler, Michael Pernkopf
  • Modellierung, UML und Modellgetriebene Architekturen (30.11.2006): Gerhard Kramler, Manuel Wimmer
  • Software Engineering Best-Practices (14.12.2006): Alexander Schatten, Markus Demolsky
  • Methoden der Qualitätssicherung (18.1.2007): Dietmar Winkler, Denis Frast
Das Zielpublikum sind im wesentlichen Klein- und Mittelbetriebe, die sich über Trends und Best-Practices im Software Engineering informieren wollen.

Anmeldung & weitere Informationen

Eine Anmeldung für Mitglieder der Wirtschafstkammer Wien, ist über diesen Link des Ubit, für nicht-Mitglieder ist eine Anmeldung über die OCG (Frau Haas) möglich.

Wir werden über die Veranstaltungen natürlich noch in mehr Details berichten!

Friday, October 27, 2006

[Arch] SOA is not a technology

Currently working in a SOA project I often discuss with people who associate SOA with Web Services. Please keep in mind that Service Oriented Architecture is an architectural style or architecture pattern. And more important, SOA is independent of any technology. Web Services are one possible solution to realize SOA.

The best definition about Service Oriented Architecture I found in "Enterprise SOA - Best Practices" written by Dirk Krafzig. He defines a Service-Oriented-Architecture as a software architecture that based on the key concepts of an application frontend, service, service repository, and service bus.

The idea of SOA is not realy new! Thinking about component based development, developers try to develop reused components. The reuse is also the main focus of SOA. Instead of components, in a SOA, everything is a service. This could be a component, a business process, an activity of a business process and something else.
The organizational turntable is the service repository, where all services of an organazation will be published and later reuesed by other services and processes . Services can be called directly or over a service bus, often called Enterprise Service Bus (ESB). The repository is used by a wide range of users, including developers and business analysts. It provides a structural deposition and different levels of descriptions of services. With a good structure and service description it should be easy to find and understand the services provided by an organization.

At this point it becomes clear that SOA is not a technical challenge but an organizational task. An organization which will realize a Service Oriented Architecture must be capable to identify and understand their services and how to organize them. This is the key point when develop a Service Oriented Architecture and not the used technology.

Tuesday, October 24, 2006

[Event] Java & Persistenz: 23. Nov. 2006

This BLOG Entry is in German, as the Event: "Java and Persistence" will be hold in German, hence it will be not particularly interesting for non-German audience. However, we will report after the event in English.
Der Open Source Arbeitskreis der OCG plant ein Event zum Thema
Persistenz im Java Umfeld.


Diesen Donnerstag findet unser "Persistenz-Event" im Tech-Gate im 3. Stock statt. Es ist uns gelungen, eine Gruppe von hochkarätigen Vortragenden zum Thema zusammenzubringen und wir freuen uns auf:
Moderiert wird die Veranstaltung von Alexander Schatten (IFS/TU-Wien).

Inhalt der Vortäge

Jürgen Höller: Die Entwicklung von Spring ORM, von Hibernate bis JPA
  • Jürgens Vortrag ist geplant als eine anektotische Reise durch Spring ORM im Kontext der Entwicklungen im Java Persistentbereich. Ziel ist es
    • einereseits die historische Entstehung von Spring ORM zu dokumentieren
    • andererseits das Produkt in Bezug zu anderen Persistenz APIs zu setzen, e.g. EJB 2.0, Hibernate, JDO, and more recently JPA (EJB 3.0)
  • Von besonderem Interesse sind natürlich die Mechanismen, welche auf Spring ORM einwirken, e.g. die Integration von persistence frameworks wie Hibernate, JDO, die Entwicklug von JPA, eine eventuelle Beurteilung von JPA, etc.
  • Was sind die Mechanismen zur Integration eines Persistenz-Frameworks?
Werner Guttmann: Data Binding, Persistenz, Aspekte der Modellierung
  • Werners Vortrag ist geplant als thematische Annäherung zum eigentlichen Thema (Begriffsbildung, Einordnung nach oben/unten/zur Seite) und als Versuch, Persistenz als gleichwertiger (Modellierungs)Aspekt verstanden zu wissen.
  • Darstellung der Problematik, Auflistung typischer Aspekte (persistence, XML data binding, ...)
  • Historische Beleuchtung der persistence side of things (JDBC, intrusiveness, standards)
  • Kurze historische Beleuchtung der XML data binding side of things (frameworks, JAXB)
  • Abhandlung des Begriffes "Aspekt" --> Bezüge zur Modellierung, Implementierung, separation of concerns
Stefan Edlich: db4o, objektorientierte Datenbanken
  • OODBMS Historie und neue Chancen
  • Der Open Source Ansatz von
  • db4o Advanced
  • Neue Abfragesprachen: Native Queries und LINQ
  • "db4o in the real world"

Im Anschluss gibt es eine Podiumsdiskussion, moderiert von Alexander Schatten.

Ort und Zeit

Do., 23. November 15:00 – 19:00
TechGate Wien 3. Stock

Die Teilnahme ist kostenlos; Anmeldung bitte per Email an
Frau Haas (OCG).


Der Event wird unterstützt von der OCG, Indoqa (Reinhard Pötz), Interface 21, Anecon und dem IFS/TU-Wien. Vielen Dank an alle Beteiligten!

Tuesday, October 17, 2006

[Tech] High Performance Queries with Apache Lucene

"Full-Text" Search? High Performance Queries!

Apache Lucene is one of the leading full-text indexing frameworks. Actually, from my point of view, the term full-text index/search is somewhat misleading. At least from the "marketing" point of view. For the application developer, Lucene is a framework providing a powerful and very performant query API. For certain, indexing is the technical basis for that, and Lucene allows to index hugh amounts of data: Data is organised in chunks called "documents" and a document can have several fields (name/value pairs). But most appealing for developers, Lucene provides a variety of query options like:
  • Search for keywords ("Java")
  • Search with wildcards ("Java*" )
  • Fuzzy search ("Java~" finds also "Lava")
  • Search of terms located close together ("Java Applicationserver~4" both terms within four words)
  • Range queries ("500-700")
And additionally these queries can be applied to various fields plus used in combination, i.e. a query like this would be feasible: "Find all Books from Author name is approximiately X where the word Y is in the title, published by publisher C or D and that was published between 1998 and 2003".

Besides the Query API the Lucene framework also offers a query parser, that can be used for user interfaces: The parser eventually uses the abovementioned query API.

Lucenes main application "the usual suspects" are problems like: indexing web-sites, indexing PDF, Office documents on a file server, indexing Wikis (Wikipedia) and so on. Yet, regarding these powerful query options, Lucene is recently used in some projects replacing traditional databases. This can be a good idea, when large amounts of data have to be accessed efficiently, access is mostly read only (few changes/writes) and transactions are not important. Objects could be serialised, e.g., in XML and stored on disk and added to the Lucene index. This can be an easier procedure then using databases. There are drawbacks, of course, like the fact, that data is not as highly structured as in relational databases.

Szabolcs wrote more about this topic in his diploma thesis (see below) and will probably add some thoughts here in the BLOG soon.

Lucene "Multilingual"

The success of the Lucene project, that originated as Java project in the Apache Software pool, is meanwhile followed by ports to other languages like: Perl, Python, C++, Ruby and .net. However, it should be noted, that not all port yet show the same quality as the Java version.

Some Experiences

In our work, we used and still use Lucene in several projects with great success. E.g., Franz Inselkammer used Lucene for his diploma thesis "Question based Knowledge Management in a Groupware Environment". Szabolcs Rozsnyai's diploma thesis "Efficient indexing and searching in correlated business event streams" was the foundation for our ongoing research in Event-Mining strategies.


One additional tip for work with Lucene is Luke:

Luke is a very handy tool, that allows to inspect Lucene indices. As they are stored in binary form, they are hardly accessible with other editors. And in developing Lucene applications, Luke is very helpful in checking, whether the index really looks as expected.

Learning Lucene

Unfortunately the documentation of the Lucene project is weak. Particularly the material for new users. This is unfortunate, because the project is excellent and this lack of documentation might give a wrong impression. However, there is a good book, that is recommended for every serious Lucene user: Lucene in Action from Otis Gospodnetic and Erik Hatcher. On the website of the book, also two chapters and some examples can be downloaded.

Remark: Sorry for my previous mistake: First I forgot to mention one of the two authors, and then I wrote the name of the other one wrong...

I wrote a brief introduction to Lucene in the current magazine (german/swiss).

Thursday, October 12, 2006

[Arch] Exception-handling best practices and patterns

"Poor exception-handling implementations can thwart even the best design"
Rebecca J. Wirfs-Brock

Exception Handling Strategies

In the recent issue of IEEE Software, Rebecca J. Wirfs-Brock discusses the influence of exception handling strategies on the quality of software architecture (PDF can be found here). In the article she expresses some design-guidelines
  • Coding Errors should not be handled by exception, but treated by proper testing strategies (e.g., unit-tests)
  • The number of "own" exception classes should be very limited
  • Naming of these exception classes should reflect what happened, not where the exception was raised
  • Recasting exceptions has to be done with care: just repeatedly rethrow exceptions is typically not a good idea (also from the performance point of view); on the other hand, throwing exceptions too deep in the hierarchy can leak implementation details (and confuse users)
  • Hence exception should be enriched with context information (from the classes that know the context) but thrown at a position, where the user is provided with useful information
Exception Patterns and Anti-Patterns

She suggests the development of exception patterns and anti-patterns (comparably to the well-known software patterns). Some attempts can be found at the Exception Pattern Wiki, and at this article, dealing with exception anti-patterns.

Monday, October 09, 2006

[Tech] Human Computation

I've found a very interesting and very funny video from one of Google's Tech Talks and it concerns a problem which was discussed earlier in this blog: is it a problem to use the labor of internet users or consumers without compensation? Well, Luis von Ahn has found clearly a way to compensate humans for computation and the currency is: fun. He invented the theory of symmetrical and asymmetrical verification games and designed until now three games to use human computation cycles for work which is nearly impossible to be solved by computers. The first one, ESP, is used to label images correctly. The second one, Peekaboom, is used to find the correct areas inside an image where specific features which are asked by their notion. The last one, Verbosity, targets the problem to find syntactically and semantically connections for terms. What is really fascinating is, the people like to be part of the game! They use hours and hours of time to play this games and get score points. They all know about the concept of the game, but that does not matter. So the technique that Luis von Ahn and his colleagues invented is a really unique and genius way to use humans as part of an program to solve the really tough problems.
So is it a problem to use people as processing units if they have fun? At least in the Matrix, they were also very happy ...
And by the way, the style of the presentation is simple admirable (even compared what I've seen at JAOO).

powered by performancing firefox

Sunday, October 08, 2006

[Event] Personal impressions of JAOO 2006

JAOO is known as one of the best conferences about Software Development and this is definitely true. Nearly all speakers are on a very high level and the audience is from the smarter kind of developers. The interesting part is, that there is no kind of separation between the attendees of the conference: speakers like Gregor Hohpe or Werner Vogels are listening the same speeches you do and they are sitting next to you! JAOO also is perfectly organized, starting from the registration up to sozial events such as the party on the first evening and the IT-Run, also the catering was very impressive, you never left lunch hungry. The most impressive speakers were Kevlin Henney and Alistair Cockburn. Both are very charismatic and especially Kevlin is very literated and knows how to tell stories. A lot of things weren't really new, but it makes a difference how they were presented.
What is also common to most the crowed: all really love beer ... and the JAOO provides a lot if it, even on the panels.
Aarhus itself is a nice little town and as a lot of pubs and restaurants so it is really worth to leave your hotel in the evening.
So what is left to say? If you can visit the JAOO, go! I will certainly visit JAOO 2007 if it is possible, now with the knowledge this is not a “normal” conference, it is unique in its own way.
Finally, trust your digital cam: if there is no enough light, it is mostly true ...

powered by performancing firefox

[Event] JAOO Tutorial Day 2

Patterns & Practices of Building Sustainable Software Architectures (Frank Buschmann)

Frank wants to bring the message that architecture in software really matters. If you do not know your primary attributes of your project and build and sufficient architecture you never will have a useful piece of software. He selected four themes which are often overlook in concern of architecture: Performance,Scalability, Availability and Flexibility. For each part, he shows up the problems and presented some solutions in kind of patterns or best practices. The final message was simple: architecture matters and if not executed carefully, it will hurt. Architecture is also not about platforms and technology, it is about what it is right to achieve your primary quality attributes.

powered by performancing firefox

[Event] JAOO Tutorial Day 1

ATAM - The Architecture Trade Off Analysis Method (Len Bass)

ATAM is a analysis tool for consultants to quickly detect architectural risks in projects. The main parts are: presenting the business model, extract the quality attributes, the architecture is presented and the evaluator checks if the quality attributes are matched by architectural tactics. Additional possible quality attribute are found via Brainstorming afterwards. The risks, if an quality attribute is not covered by the architecture, are expressed as scenarios, which are prioritized afterwards. This highly risky features are than reported to all stakeholders and provide a good guideline to improve the architecture so the project will meet most of the business needs.

EJB 3 Persistence with OpenJPA (Patrick Linskey & David Ezzio)

JPA is part of the spec of EJB3 and can stand completely alone from the rest of the spec. It is modeled after Hibernate and it seems that finally the persistence in JEE now is use able. OpenJPA is an Open Source Implementation of BEAs Kodo and under Apache License. The main advantage now is that JPA is an usable API which is standardized and implemented by various projects.
Finally the old Entity Beans are gone!

powered by performancing firefox

[Event] JAOO Conference Day 3

Hot Old Ideas - Experiences Of An Old Country Programmer (“Pragmatic” Dave Thomas)

Nice track introduction and an overview which concepts of programming models and languages he has encountered in his life. The reason to know about the history of computer science is, that a lot of ideas were there before but are sometimes forgotten. So sometimes you have to look back to know what could be right today ...

The History of Scheme (Guy L. Steele Jr.)

Introduction to Lisp and its concept of lists and where it was flawed. He then continues to present how Scheme (which original name was Schemer, but the files on his machine only had 6 characters ...) was born and how he discovered that Lamda Functions are functional equivalent to the actor based messaging concept.

Functional Programming And Monads (Erik Meijer)

Haskell is back and with Eric it made a lot of sense once more. For him, because he has a small brain, Haskell was the ultimate language because it represents the ultimate DRY language. He also explained why an experienced Haskell developer never ever writes recursive functions (as I did in the university course long time ago), you can always write folding functions and Lamda functions which work directly on the lists. His advice was, because we have already stolen the work from the mathematicians of the last 2000 years, the best thing to do is to train new ones because otherwise we will run out of ideas ...

Are We There Yet? (Rod Johnson)

Rod told the story how Spring come to life because the JEE concept was totally flawed 2003. Spring was the answer of the community and it fixed completely what IBM, Sun, BEA and others nether got right (because the smart people where never build real applications). The next big thing for Enterprise Java is to focus on the domain model, which should once again really be object oriented and not a dump structure which is only used for state management and as transfer structure between the DAO and the service layer. He has also a wonderful example why the interceptors in EJB3 are totally crap and showed that with Spring 2.0 and AspectJ it is a lot more elegant to inject aspects in the domain model.

Five Considerations for Software Architecture (Kevlin Henney)

Kevlin told something about five considerations for good and elegant architecture, which, as every fundamental truth, was discovered with the help of beer. He explains all five with a lot of anecdotes, but basically the idea is that if the architecture is flawed you never get a project right, independent from tools, languages or platforms you use.

How Will We Be Programming In 2016? (Dave Thomas, Guy L. Steele Jr., Erik Meijer, Kevlin Henney, Ole Lehrmann Madsen, Steve Vinoski)

Because the panel was stopped after the beer was gone, it lasts only for an hour. But all of them agreed in the following points: Concurrency and Distributions of programs will largely increase and had to be supported by tools and language features, programs and the problems they solve will get more complex and we need more tools for analyzing, deploy, test and monitoring them, DSLs will evolve but not everyone is a good language designer so most of them will be rubbish, development is language agnostic, so it doesn't matter in which language you solve the business driven problem.

powered by performancing firefox

[Event] JAOO Conference Day 2

The Soul of a New Programming Language (Guy L. Steele Jr.)

Guy presents Fortress, the planned successor for Fortran and a language which is targeted to the scientific computation community. Fortress is much more convenient for mathematicians to express already existing algorithms and it will also encapsulate by its compiler (or VM) the parallelism of the execution in multi-core or multi-node computer systems. A lot of concepts come from Haskell and Scheme but it will also integrate a lot of features which also have worked for Java. It is planned for 2010, so only the spec is in progress these days, no interpreter is officially available.

Typical Pitfalls in Agile Development (Jutta Eckstein)

Jutta told the audience about a lot of problems she encountered as consultant on large agile teams and opens the track.

DSLs Best Practices illustrated with Eclipse Tools (Markus Völter)

Markus shows how well Model-Driven development could work if you are using sufficient tools on the modeling level and you do not make the mistake to modify generated code. On thing you always should do is to use the strength of model-model transformations. As example, if you build your domain model and finally you want to generate some DOA objects for already existing domain entities, you have sometimes to enrich your model automatically because one or more generated artifacts will be referenced inside the model. So to be consistent and to use constraints on the model level, you have to extend the model itself on the first place. Finally you have to transform it only once to your target artifacts.

DSL implementation at compile-time via syntax extension (Laurence Tratt)

Laurence presented the way how easily DSLs can be build with his own system and platform, Converge, which works basically by the way of statically typed macros. He also mentioned that Converge is actually used by an Indian company so the stuff was not completely academic.

Scrum Tuning: How to Make Good Scrum Implementations Better! (Jeff Sutherland)

Jeff presents a lot of surprising finding from companies which already use SCRUM. One was very interesting, because the team there was large but located in India and the US. So SCRUM was executed in parallel but the team managed to be as successful as a collocated team. He also explains how it is possible to use SCRUM for the whole company (SCRUM C).

Domain Annotations (Michael L Royle & Erik Dörnenburg)

Short presentation how to use attributes as navigation handles to traverse in an domain model then no direct path exists between the entities.

If I was going to Glasgow, I wouldn't start from here (Alistair Cockburn)

The old joke was the start for Alistair to encourage the audience to tell why agile development was not possible to them (the sub context was, someone told him that Scandinavians do not need Agile development because they already do it for their whole life). Surprisingly, one third of the audience delivers working software more than once a month, most deliver at least once in free months. The obstacles which prohibit the deployment for the rest of the projects where basically reasonable, such as a fixed change cycle of the infrastructure, contracts (such as from the government) which forbid agile development (although not internally) or the software was part of embedded systems.

powered by performancing firefox

[Event] JAOO Conference Day 1

The Technology Platform: Building Blocks for Innovation (Werner Vogels)

Werner explains how strong is build as platform on services and why their solutions was the only possible way to scale well. Scaling is fundamental for them because the basic block in their business model is growth. He also mentions that their SAO architecture is not based on a specific vendor or technology (as SOAP/ESB), they use every technology which helps to solve a specific problem. Small teams develop these services and they are full responsible for deployment and the life cycle of the service.

Abstractions for Concurrency (Erik Meijer)

Eric presents the concurrency concept of Comega which helps to solve a lot of nasty problems you have to solve with Monitor usage. Because Comega is a language extension to C#, there is also a library version of the concepts which is based on delegates and can be used in every CLR 2.0 language.

REA (Resources, Events, Agents) (Pavel Hruby)

Pavel explains how business processes can once more be modeled in a way in which the economy normally really works: Goods are resources which are constantly exchanged, if the exchange takes place a business event happens and someone is participant of this transfer.
So instead of to model domain models in the typical technical way as entities and business value methods they can also be modeled in a more reality aligned way.
He builds this concept for the framework which is used in Navision.

Concurrency and the Composition of Frameworks (Joe Duffy)

Joe shows some concepts how to encapsulate concurrency if you build up frameworks and how you can define an API which helps the user to discover what your intention really was and why and how he has to use your code in concurrent situations.

Seaside: A Radical Web Framework (Glenn Vanderburg)

Glenn presented Seaside as working Demo, which he was changing all along the talk. Seaside is based on Smalltalk and makes heavy usage of continuations, so problems like the nasty state transfer if the user use the back button in the browser or “forks” the web page flow with opening a new window could be simply solved. Because it is Smalltalk, you can change the code rather easily on the fly so this talk was a real life demo. The downside is, that Seaside continuations are not serializable, so this can be a great obstacle if you want to scale your web site.

Conversations between Loosely Coupled Services (Gregor Hohpe)

Gregor presents some of his patterns which he is collecting for his new book about patterns for service oriented architectures. Most of the patterns are best practice for complex and simple conversation style between services.

SOA What's left to say? (Steve Vinoski & Gregor Hohpe & Beat Schwegler & Ivo Totev)

The panel discuss what is open for SOA and basically it should be now time to implement architectures based on services and never forget that the implementation is driven by business and not the other way round.

Methodologists are Blue-Green Algae and Methodologies as Swimsuits (Alistair Cockburn)

Alistair explains the audience why methodologists are a very low life form but which is useful because they can transform flawed systems (algae also consume CO2 and produce O, very useful for us). On the other side, methodologies have all different size and shape, so there is no “one fits it all”. His metaphor for this are swimsuits, because if they are used by divers, they have to be really heavy and if they used by girls, well, they can be very lean ...

powered by performancing firefox

Wednesday, October 04, 2006

[Event] First Day of JAOO 2006

Welcome to the First Review of the JAOO 2006. Monday was the first Conference day and there have been several interesting talks the whole day.

First of course we visited the Key Note from Werner Vogel the CTO of Amazon. His talk was about the business model from Amazon and how the infrastructure they have build the last years fit into it. The Infrastructure is totally service oriented and it was realy interesting to see that they don’t only use services but also invent abstraction layers for Services.

After the Key note there have been several Tracks available to choose talks from:

  • Abstractions for Concurrency
  • Emerging Web Technologies
  • Modeling and Designing Enterprise Applications
  • Relational Databases
  • SOA - What's Left to Say?
  • Solution Track I

The first talk we heard was in the “Abstraction for Concurrency” Track from Erik Meijer (Microsoft). It was realy interesting to see that just one Track of the whole Conference was dedicated to Concurrency. As soon as even simple PC’s or Laptops are equipped with multi cores or processors we see a much higher possibility to adapt our programs to use more threads depending on the architecture of our system running the software. Everybody that has developed Multi Threaded Applications knows that it is not that easy with our current tools and languages. The Monitor concept that is used in the common languages like Java and C# is not that powerful to deal with requirements that rise as soon as we want to use the possibilities described above. For this reason Comega supports new Features for Concurrency. As Comega is still a research project they came out wit a little useful Library for C# called Joins library that gives you a interesting possibility to capsulate all the locking stuff. Check it out at

The Second Track we where really interested was SOA. We visited the talk from Gregor Hophe (CTO from Amazon) who was talking about several Patterns for Communication in Loosely Coupled Systems. If you are interesting in try out this webpage.

Fore those of you who are doing Web development or are interested in Web frameworks I advise to take a look to Seaside. The Framework is not new but interrestingly much more interesting is that it is build in Smalltalk J. The main advantage of Seaside is that it supports Continuations and is really easy to write (at least if you know Smalltalk).

The Party Keynote was given by Alistair Cockburn which was the highlight of the whole day. I can just say if you have ever the Chance to hear him live even if it is 1000km away it is worth it.

So this was it from the first day of JAOO 2006 of course there have been much much more.