Tuesday, July 31, 2007

[Pub] IEEE CEC/EEE Conference: Event Mining Paper

This week I had the opportunity to attend at the IEEE CEC 2007/EEE 2007 conference in Tokyo to present our paper Event Cloud - Searching for correlated business events. This event includes the 9th IEEE Conference on E-Commerce Technology (CEC' 07) and the 4th IEEE Conference on Enterprise Computing, E-Commerce and E-Services (EEE ' 07).
The joint conference will focus on new technologies and methods that enable business processes to smoothly extend in a cross-enterprise environment, including solutions to facilitate business coalition in a flexible and dynamic manner over coming Next Generation Internet which provides ubiquitous, multimedia, and secure communication services.Conference Link
At this point I'm happy to announce that our paper has been chosen for the "Best Paper Award" for EEE '07.

Event Cloud was first introduced by my diploma thesis Efficient Indexing and searching in correlated business event streams and covered a proof of concept for managing and searching for correlated events by applying an indexing approach of events. This work included several architectural iterations with the result that an indexing approach was the most promising concept for such applications. Later on Roland Vecera introduced a full-blown prototype of Event Cloud, including several key features, in his diploma thesis Efficient Indexing, Search and Analysis of Event Streams.
Event Cloud is basically a solution that allows domain experts to search for business events and patterns of business events within a repository for historical events. We consider this repository as a cloud of events, which is used for searching and analysis purposes. Event Cloud processes events, thereby creating an index for events and correlations between events in order to enable an effective event search. It provides a historic view of events with drill-down capabilities to explore and discover different aspects of business processes based on event correlations. Event Cloud allows users to investigate events, such as picking up single events and displaying their content and discovering related events or event patterns.
For further details and related paper downloads please visit Senactive Competence Center.

[Tech] Webapplication "Quickstart"

Creating (Java, what else *g*) Web-Applications with a new framework is not always an easy task. Where to put which config file, which config options, how to make the build process correctly, how to start the application in the servlet container and how to make an eclipse project and the like. Yesterday (thank you Reinhard) I was pointed to a really great resource:

Webtide, the company behind the Jetty Servlet-Server project provides a set of archetypes for Maven to create "hello world" webapplications for a broad range of different Web-frameworks (Wicket, Struts, Tapestry, Spring, Webapp with ActiveMQ...).

What does that mean?

(1) you download the artefact you are interested in, e.g. Wicket, unzip it and call mvn install (to install it in your local repository)

(2) you call for example:

mvn archetype:create -DarchetypeGroupId=com.webtide -DarchetypeArtifactId=maven-archetype-Wicket -DarchetypeVersion=1.0-SNAPSHOT -DgroupId=info.schatten -DartifactId=my-wicket-app

and the archetype creates a simple Wicket (or whatever archetype you selected) webapplication with Maven build settings, including the jetty plugin. So type:

(3) mvn jetty:run and the application start.

This is really a helpful set of artifacts to start from!

Tuesday, July 24, 2007

[Tech] Template Engine Stagnation?

Frank Sommers discusses several new attempts in template-engine design and implementations like String Template, the Rails approach, Velocity and the like. Gert Bevin introduces this article in TheServerside.com with the words:

"Template engines seem to be one of the most stagnant technologies in Java".

Actually this question is quite interesting for me, as I made the same observation over the last years. Maybe the answer is very simple though: The reason might be, because they are actually not often used and hence there is not much demand.

For XML related processing XSLT is a proven and powerful technology; Web-Development apparently moves away from template-based approaches as new frameworks like Wicket or Google Web Toolkit show. Then there are some minor application scenarios where template engines are used in the "backend" like generation of Java code by O/R mappers or generating SQL statements and the like. But most developers use strategies one abstraction layer above. Meaning: you do not put your SQL statements together with Velocity, you might use Hibernate or Cayenne.

[Pub] End of Hibernation

I wrote an article in the current iX magazine (German) about O/R mapping strategies. I hope some of you might read the article and might want to discuss some aspects here.

In short, I am discussing the significant differences between "the world of relations" and "the world of objects" and the strategies O/R frameworks like Hibernate and Castor try to overcome these. What seems simple at the first glance turns out to be very complex in many details. If you do not believe me, check out the size of the (very good) documentation of Hibernate. This is the meanwhile often discussed problem, that using Hibernate & Co requires excellent and detailed skills of that framework and the complexity of the undertaking is often underestimated by development teams.

The specific problem here, however, is that the lack of knowledge is not evident immediately. People think they have the framework under control and know whats happening and the mapping initially also might work fine, but during the runtime of the project it often turns out, that things are not so smooth as initially thought. Unfortunately severe problems and issues then bubble up at the worst of times. Very bad performance, severe memory problems, mapping issues, session problems and the like.

In the article I suggest to have a closer look to alternatives like the Spring jdbc templates or Apache iBatis or even to OO databases like db4o.

The bottom line is, even if some articles might suggest it, there is no single best or "default" solution. A good knowledge of the alternatives is required to choose the best framework for the specific problem.

p.s.: there are several articles in this blog dealing with related aspects, please check out the technology section or search for Hibernate, iBatis, Spring... I am honestly to lazy to link all of them here ;-)

Friday, July 06, 2007

[Tech] We Morons!

Yes, I feel like a moron now... Why? Because I use SVN and generally I like SVN! (actually I am happy that I do not use CVS any more, because this would really make me a dork!)

However, Linus has strong opinions and also likes to express them in his "Google Talk" about his sourcecode management system GIT. Actually Linus makes some good points and presents some impressive features of git, and despite of the facts I think that this video is quite amusing and nice to watch.

(But after all I do hardly dare to say, I think I will continue to like using SVN...)

Thursday, July 05, 2007

[Tech] Layout Management desperation

Creating professional Swing applications can often be very tricky. It depends on developers preferences whether he uses an IDE to create a GUI or doing this by hand. I have found a funny video dealing with coding a GridBag layout manager. This video demonstrates how frustrating it can be, if you program your GUI by hand. At this point it is hard to say which approach is best for you. Take an IDE, for instance JFormDesigner, or Matisse, providing an easy to use user interface. Developers create their GUI by drag & drop components from the toolbar to their form. Behind the IDE generates the associated Java source code for all forms. That's fun. Some tools also provide reversal update, meaning when you change your source code, the GUI design will be also updated.

There are nice frameworks out there, e.g. Spring Rich Client, providing powerful utility classes for layout GUI forms. I developed several Swing projects using JGoodies form layout and some other useful technologies, where I intentionally create the GUI by hand. In my opinion creating GUI code by hand also has several advantages:
  • You learn how to deal with layout managers (Flow layout, Grid Bag, and so on)
  • A GUI creator can't handle everything (e.g. event handling)
  • An IDE created code is often hard to read
  • A developer must not learn an IDE (e.g. Netbeans) to develop Swing applications. I point this because I prefer Eclipse, but Netbeans provide better support for GUI development
Finally it depends on the preferences of a developer how to develop GUIs. Check out this cool video, and remember: "Swing also Rocks without GUI IDE".

Monday, July 02, 2007

[Arch] EDA and SOA in a complex world

In the recent iX magazine (German) Josef and I wrote an article about event-driven architectures (EDA) and the connection to service oriented architectures (SOA).

An idea I personally like in the context of EDA is "Seed, Sense, Amplify" that was introduced in the book "It's Alive, The Coming Convergence of Information, Biology and Business" from Christopher Meyer and Stan Davis. In my understanding the core idea there is, that in a complex world, it becomes more and more difficult to plan ahead and to predict what customers want or more generally spoken, which ideas might work out and which will not. So Meyer and Davis describe strategies, where "natural" variation is brought into business concepts, where offers are slightly changed for different customers, where customers become more freedom in doing what they want (seed).

The idea is to be more agile, but not laissez-faire, so beside the "seeding" step also a properly planned "sensing" step is required. In this step the actual behaviour of the customers is analysed. In the last step: "amplify" the desired behaviour is amplified (and the not desired one diminished.

Now to allow such strategies also the underlying IT architecture has to support this degree of flexibility yet allow the implementation of the sense and amplify steps. "Traditional" heavy weight data management and process management solutions often prove to be too inflexible to deal with such agile concepts alone. Help is needed and as state changes in different IT systems are often technically expressed in events/messages that are sent over message buses they can be processed with respective (complex) event processing middleware. And this is where our research and in that case our article comes into play.

Eventually following the idea of EDA means building a system that is not only analysing events, but that is driven by events (as we also try to explain in the article) and can lead to a sense and respond infrastructure (Roland give some ideas about our strategies to that respect in his diploma thesis). I'd like to illustrate the agility EDA might provide in certain situations on an example we also used in the article:

Let's consider a webshop, where the user orders goods using the web-interface (and the application server). In a "conventional" architecture, even a SOA a controler component (probably in the appserver) might "orchestrate" the order process by calling several services like the credit check, the customer check, the stock-keeping application, eventually initiating the shipping and following up the payment procedure. When implemented in a SOA way the components are de-coupled at least to a certain degree. Still, the whole system is kept together by the controler compoent. Now, how could we model this "EDA-like":
  • First we should use a message oriented middleware (MOM), that supports the publish/subscribe paradigm (e.g., ActiveMQ, Tibco and the like)
  • The next important concept is to omit the controler component by inverting responsibilities, meaning: not the controler decides what service should be invoked, but the components themselves decide what they are interested in (which requires a clear strategy of defining message types)
  • If the customer orders goods, the web-application server sends a "order" message to the MOM. It does not "address" specific other components, just announces that a new order has arrived
  • Now arbitrary components can register for new incoming orders as they need that data to do their job like the credit check component and the stock-keeping component. Both might do their checks and then send new messages into the system like "credit checked" or "stock checked" including a reference to the order message like the order-id
  • Eventually the order processing component might wait for all messages that are required for the next step like order, credit-check and stock-check, then initiate the shipping and send the next message that shipping has been done and so on.
I don't want to elaborate that in detail, but it can be easily seen, that the responsibility has been inverted, which leads to a more decoupled architecture as every component can be easily exchanged or "multiplied" in case of performance problems as no sender actually sends to a specific receiver.

Additionally this style of architecture allows a significant level of agility (to come back to the inital scope of the posting) as new components can be easily introduced into the system (e.g., reporting, statistical analysis, components to connect to contractors to initiate reorders and the like) without the need to continuously rewrite the controler component that then gets more and more complex and intransparent.

O.k. enough for now, furter interesting sources might be the mentioned book, Brenda Michelsons blog and Jack von Hoofs blog. Our article can be found in the recent iX magazine July 2007.