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.