[Pub] Mule IDE

I published an article about the new Mule IDE in the current issue of the Eclipse Magazin. In the article I give an overview about Mule and how the IDE supports developers to model their Mule applications. The IDE provides the following features:

• Mule project wizard
• Mule runtime configuration (you can define different Mule runtimes)
  
• Graphical Mule Configuration Editor
  
• Start your Mule Server from your IDE

More information about the Mule IDE you can find on the Mule IDE homepage.

[Arch] Application Architecture Guide

The architecture and design of software applications should be technical neutral. The Application Architecture Guide from Microsoft guides developers through the design of applicataions based on the .NET platform. In my opinion, this architecture guide not only focus on the .NET platform and is a really good cookbook for Software Architects. As we present in our Best Practice Project, design patterns, are technical neutral and can be used in any language. The design principles of a Data Access Object or a Proxy are the same in Java as in .NET.

The guide can be used as a reference and provides the following five parts: Fundamentals, Design, Layers, Quality Attributes and Archetypes - Desgin and Patterns.

Fundamentals

The first part focus on fundamental architecture concepts, including application Archetypes, Layers and Tiers and Architectural Styles. On chapter focus on the .NET platform.

Design

The second part is very interesting for software analysts by providing some guidelines to design your application. Here you will find best practice approaches to make decisions about the distribution, select the right application type, choose the right architectural style (component based, message-bus,...). The chapter Architecture and Design is on of the most interesting one, because it provides guidelines to design considerations, architecture frame, persistence, security and some other topics. The last chapter Communication guidelines provides best practice approches to use the right communication between your software components and describes the design impact of choosing a communication technology.

Layers

The layers part focus on the layered architecture and describes each layer in detail, including Presentation, Business, Data Access and Service Layer. The layered architecture is on of the common used architecture styles in software projects.

Quality Attributes
In this part non functional requirements in software projects are described and how these requrements can be achieved by doing the right design. What must be account for to be secure and performant.

Archetypes - Design and Patterns

Don't compare this chapter with Maven Archetypes. The last part of the architecture guide describes different types of applictions, like Mobile Application, RIA or Web Application. This is very interesting because you will find which typical design principles and design patterns are used in such an archetype. For example one of the key patterns in Web Applications are Composite View, Front Controller, the classical MVC, Page Cahge or the page controller.

This architecture acts as Bibel for developers and you fill find less .NET code. In my opinion this guide is realy good and should be checked by every software architect and analyst.

[Misc] Virtualisation for Software-Engineering

The easy accissible virtualisation tools like Virtual Box enable new applications in software engineering. An obvious usage pattern would be, to provide prepared systems for customers to evaluate that would require rather complex installations and setups.

Not so apparent is the usage in automated testing. Tests of higher granularity like integration tests are sometimes difficult to automate as they often require (again), complex installations of several components (database, middleware, legacy components...), setup of these components plus a consistent state of all these components. Virtualisation can facilitate that process significantly. The developers can create a consistent image of the system where all dependent systems are properly installed, configured and fed with data.

This image is used as reference. In the build and test automation one has to get the clean image, start it, install the more "dynamic" modules, i.e. the system under development and test, and execute the (integration) tests in the virtualisation, then collect the test results and shutdown the virtual system again. That procedure allows deterministic test-scenarios on different machines, also (or particularly) on a continuous integration server.

Sounds good, however in practice I am still missing some tools that support that. Linux in the box is of course a good start as everything is easily scriptable. However, if you want to include the virtualisation into the build-automation (e.g. in Maven) and into the continuous integration server, plugins to Maven/Ant... would be useful that allow to control the virtualisation environment, trigger activities there and retrieve data (e.g. the test-results).

In an initial research I did not find much tools in that area, any ideas?

[Misc] Glassfish

I recently informed myself about the (Sun) Glassfish J2EE server. I never took it as a serious competitor in the field, as I had the impression it is just a reference implementation that is from Sun... However, I had to change my opinion. In the recent years it seems, that the Glassfish community worked hard on their baby and currently it seems to be a solid competitor in the field.

The Glassfish univers "not only" contains a J2EE server, but actually a set of Enterprise-tools like as message broker, clustering framework, enterprise service bus (JBI compatible), a library to implement SIP applications and the like. Additionally it is well supported by the Netbeans IDE. The recent (preview) version contains a J2EE runtime that additionally supports scripting languages like Ruby and Groovy and is based on the OSGi framework.

What I do like additionally is the fact, that Glassfish comes with a decent installation tool, provides a solid web-based administration interface and seems to be reasonably well documented. And, of course, the whole stuff is Open Source.

I must say, I am quite impressed so far. Any comments on that one?

[Misc] Mule Developer Blog

There is now a new blog which takes his focus only on Mule, by providing technical tips, comments and breaking news around the Mule product line (ESB, Mule Galaxy,..). Blogger from this blog are only developers from Mule Source and members of the Mule Service Team, which means that you get the information from first hand. There are already posts, e.g. how to write custom transformers in Mule or an introduction to Expression transformers. Another interesting post focus on performance tuning in Mule.

The backround idea behind this blog is to give the Mule community as much information as possible. This is the right way, because there are some issues (e.g. performance issues) where you always end up in the mailing list and search some hours for the right answer. Some posts are emerge from discussion threads in the user mailing list.

[Arch] Archi-Zack!-ture

A few months ago I read a very good article series by Pavlo Baron about Software Architecture in the Java Magazin. Software architecture is an important component in software projects and you will find a lot of resources (books, web sites, blogs) which focus on this topic. He titled the series with Archi-Zack!-ture.

What does a Software Architect do? The role of a software architect in a software product becomes more important the more complex the system is. Software architecture is still a rather young discipline and the value of a software architect in software development is often underrated. As Pavlo describes in the first part, it's hard to seperate the role of a software architect with the role of a software developer. The architect enables developers to develop the software system by providing the necessary environment. The developer on the other side focuses on the fulfillment of the requirements. The motives are the same, but the emphasis differs.

The major part of the series are (Anti-) patterns about the software architecture. I picked up the most important one from my point of view. First I will enumerate the patterns which should be followed:

• Architect also implements
  Each architect should also implement. This is very important, because as a architect you make decisions about performance, scalability and similar stuff. Without any technical backround these issues are very hard to design/answer.
  
• Senior Developer = Software Architect
  It is important the a software architect has experience in software development.
  
• Manages makes the final decision
  One man of the management must make the final decision. The software architect prepares the material which are used for the decision
  

Now some antipatterns

• Ivory-Twoer Architect:
  The purchase to the reality lost
  
• One Man Show:
  The software architect makes everything alone
• Single point of decision:
  The software architect must decide everything, e.g. implementation details.
• Design by Committee:
  On the other side, it makes no sense to make all decisions in the team which ends in a never ending discussion. A good mixture is the answer.
  
• Architecture by implication:
  Architecture is not documented.
  
• Architecture without review:
  
• Meta architecture:
  Software architect remains too abstract
• Customers are idiots:
  The Software architect is not a God!!
  
• No Refactoring:
  The management does not give time for refactoring

Some people believe that software architects are the "kings", and without them software projects don't work. The above mentioned anti patterns are found rather often in projects and architects should keep that in mind. It is not important which title is written on your business card, the content, the attitude to the project and how the project team works toghether, are the keys to the success of the project.

[Arch] RESTful applications with NetKernel

The architectural style REST has gained some popularity and is often brought up against SOAP for interoperable web services. REST stands for Representational State Transfer and has some characteristics that distinct itself from other architectural styles:

• Resources such as a person, an order, or a collection of the ten most recent stock quotes are identified by a (not necessary unique) URL.
• Requests for a resource return a representation of the resource (eg. an html page describing the person) rather than an Object that IS the resource. A resource representation represents the current state of the resource and as such is immutable.
• Representations contain typically links to other resources, so that the application can be discovered interactively.
• There is typically a fixed and rather limited set of actions that can be called upon resources to retrieve or manipulate them. HTTP is the best known example of a RESTful system and defines eg. GET, PUT, POST and DELETE actions.
  

Applications based on REST are typically very extensible, provide good caching support, and can be easily mashed up to bigger applications.

NetKernel

Using the RESTful application pattern in non web based applications is currently not very well supported by programming languages and frameworks. NetKernel is an open source framework designed to provide a simple to use environment to program RESTful applications.

Its architecture is rather simple: Programmers write Modules and register them with the kernel. Each module registers its address space that that states which logical addresses (URIs) the module will handle and which java class, script (Python, JavaScript, Groovy, …), or static resource will act upon the request and return a resource representation. A module can also register rewrite rules that translate from one address to another.

Accessing resources within NetKernel from outside is via Transports. Each module can have Transports that monitor for external system events (eg. JMS events, HTTP requests, CRON events, etc), translate these events into NetKernel requests, and place these requests into the NetKernels infrastructure that will route the request to the appropriate resource.

NetKernel supports a wide range of scripting languages uses resource representation caching to speed things up transparently for the developer. The internal request-response dispatching is done asynchronously so callers can easily state that they do not care for an answer after 10 seconds, are not interested in the response at all, or place several request first and then wait for the responses coming back. REST is most often associated with HTTP – with NetKernel one can apply the REST architecture style also to applications that do not use http; it is completely decoupled from the http stack.

Compared to other REST frameworks such as Restlet, NetKernel is extremely well documented and several large sample applications can be downloaded from their homepage to get started quickly.

Related Links

• http://www.1060.org – the homepage of net kernel.
• A recent article on TheServerSide.com about resource oriented computing with NetKernel that provide a more thorough introduction.
  

Benedikt Eckhard (edited by Alexander Schatten)

[Arch] Mule 2 and Beyond

For anybody who doesn't know the Open Source ESB Mule, I can recommend the presentation from Ross Mason hold on the Java Polis conference. In this presentation Ross gives an overview about Mule, including the component architecture and new features in Mule 2. Other relevant topics are:

• Develop services in Mule
  
• Dealing with web services in Mule
• Exception strategies
  
• Transaction Management
• Scalability
  
• Projects around Mule: Mule HQ and Mule IDE

He also points to the projects on MuleForge, which provides Mule users interesting enhancement modules and connectors, like LDAP or SAP.

[Event] ESEM-Conferences

From October 6th-10th the Experimental Software Engineering International Week (ESEIW) took place in Kaiserslautern, Germany. The ESEIW was organized in four joint events:

• 16th Annual Meeting of International Software Engineering Research Network ISERN, Oct 6th-7th
  
• 6th International Advanced School of Empirical Software Engineering. IASESE, Oct 8th
  
• 3rd International Doctoral Symposium on Empirical Software Engineering IDoESE, Oct 8th
• 2nd International Symposium on Empirical Software Engineering and Measurement. ESEM, Oct 9th-Oct 10th

Major topics of the ISERN Meeting were

• aggregation opportunities from experimental results,
• application of Empirical Software Engineering to Software Architecture
• discussion of an Empirical Research roadmap and associated key task within a time range up to 2010
  
• application opportunities of empirical investigations using simulation.

The ESEM main conference is an established forum for researchers and practitioners to report and discuss recent research results in the area of empirical software engineering and metrics. The conference focuses on topics related to processes, design and structure of empirical studies, and results of specific studies.

Paper Presentation

We gave a short paper presentation in the track "Empirical evidence and Systematic review" titled with "An Empirical Investigation of Scenarios Gained and Lost in Architecture Evaluation Meetings" (D. Winkler, S. Biffl, M. A. Babar) which reports on initial findings on team effects in scenario brainstorming processes for architecture evaluation.

Abstract: Studying the effectiveness of scenario development meetings in the software architecture process is important to improve meeting effectiveness. This paper reports initial findings from analyzing the data collected in a controlled experiment aimed at studying the effectiveness of meetings in terms of gained and lost scenarios of individuals, real and nominal (non-communicating) teams. Our findings question the effectiveness of holding meetings since more important scenarios were lost than gained in these meetings. In the study nominal teams performed better than individuals and real teams.

The slides of our presentation are available for download.

Key Note Talks

Beside presentations and discussions of academic papers, "state of the art" presentations focus on relevant topics for industry and best software engineering practice:

1. Using empirical methods to improve industrial technology transfer. (Harald Hoenninger, Vice President Corporate Research, Robert Bosch GmbH, Germany).
2. Empirical Challenges in Ultra Large Scale Systems (Mary Shaw, Institute for Software Research, Carnegie Mellon University (USA)
   

Abstracts of the key notes are available for download.

Dietmar Winkler (edited by Alexander Schatten)

[Arch] SEDA Model and scalable enterprise applications

Scalability, Performance, Fault Tolerance are classical non functional requirements when building enterprise applications. Setting up the application in a clustered environment is a very popular approach and is often used in practice.

When building process based applications you usually deal with long and short running processes. For example a order process may take one week, whereas a save transaction is a process that takes (should take) only few seconds. Short running processs often implements the backend business logic. In Service Oriented Architectures these short running processes results in a orchestration of provided services from different systems.

Mihai Lucian describes in his article a simple scenario, where different platforms in a backend process are connected by using web service endpoints. One of the platform that is queried has a slow response time. He describes one solution approach to battle to the slow response time by using asynchronous IO in servlet container and the Staged Event Driven Architecture (SEDA) model.

He mentioned that current servlet APIs do not provide methods in order to deliver data to the client in a asynchronous way. AJAX based frameworks currently use one of the modes: Polling, Piggy back and Comet. Apache Tomcat for example provides a implementation to handle asynchronous IO by decouple the requirest and response from the worker thread. So you can prepare your response later.

Now the combination with the SEDA model is very interesting, because you can route your request to the right queue. As Mule is based one the SEDA model, Mihai Lucian illustrates how to implement such a scenario in Mule (see image).

From my point of view the example is very interesting based on the following key points:

• Asynchronous communication in a servlet container
• The most interesting thing is how to correlate the request with the response through different layers
  
• How Mule fits in such a architecture
• Practical example of JMS
• Using Routers in Mule and route the message to the right Queue
• Using Apache CXF in Mule

A full description of the example is provided on the article homepage. At the end of the article he provides some benchmarks in order to provide a clear view of the advanateges using such an architecture.