Software Factories:
Better, more efficient and agile development via automation

The demand for software grows much more rapidly than the efficiency, quality and agility of software development. Similar situations in other fields have triggered the change from individual production to automated production techniques long ago.

Does this show a promising example for trends in software development? Yes, wherever applications are developed, which fulfil different functions, but share similarities in the domain-oriented and technical architecture.

In other words: cases where they represent a software family. The development of similarities can be automated with the help of model-driven techniques based on UML. This is precisely the idea behind software factories in objectiF.

Characteristic of software factories based on Model-Driven Development (MDD) is the clear separation of domain-orientation and technology. The developer designs the domain-oriented architecture for an application. The technical architecture and a large amount of the code are then automatically created through model transformations.

If the domain-oriented requirements change, the developer merely makes the changes in the domain-oriented model. The software factory will update the relating technical model and code through model transformation.

objectiF as a software factory – here’s what you get:

• The model types of the domain-oriented architecture
• The model and file types of the technical architecture
• A workspace with project structures
• Ready-to-use model transformations for the automatic implementation of the domain-oriented in the technical architecture, including code generation
• The possibility to develop user-specific model transformations
• Sample systems and tutorials to support you from the beginning

objectiF as Software Factory for SOA Applications in Java

objectiF offers continuous support, from business-process modeling in BPMN, to the domain-oriented and technical software design with UML, to the code. But objectiF is much more than just a classic UML tool. objectiF enables you to standardize your software development for a Software Factory and automate it extensively. Automation is based on the concepts of Model-Driven Development (MDD), and can be adjusted and extended, according to your needs.

Here, you get to know objectiF as a Software Factory for SOA applications.

The objectiF SOA Factory at Work

The core of every service-oriented application is an automated business process. It describes the chronological progression of domain-oriented activities. The activities do not run any essential processes themselves: they do not record, process or save anything. For these tasks, you need the services. Here, this always means Web services, which are either provided by the firm itself, or made available by partner businesses. The objectiF SOA Factory is specialized for the development of precisely this type of application for the resulting target technology: the business process should be implemented in WS-BPEL, in order to run it directly on a BPEL engine. Its own Web services are built with EJB 3.0. The user interface, via which the process can be activated, is a Web application, which is realized with JavaServer Faces.

Laying Out the Domain-Oriented Architecture

The first step when developing a service-oriented application with objectiF SOA Factory, is to design a Platform Independent Model. One of the services the factory provides is the definition of a method to describe the domain-oriented architecture. The method denotes which contents need to be specified, which description medium is most appropriate for this, and which relationships exist between the architectural elements. The domain-oriented performance of an SOA is fully specified with four, coordinated model types, according to the method. The model types are:

• Presentation Model: the presentation model describes the Page Flow of the user-interface Websites. UML State Diagrams are used as the description medium. Their states represent Websites, the state transitions show page changes, which are triggered by application events. A state transition can trigger actions relating to the activities of a business service,
• Service Model: in service models, services are specified in UML Class Diagrams. The objectiF SOA Factory provides the following conventions: a service model describes services and their messages as classes with the stereotypes «BusinessService» and «BusinessMessage». Class methods with the stereotype «BusinessService» illustrate the service operations. They have the stereotype «BusinessOperation». BusinessOperations use BusinessMessages as the parameters. The advantage of this illustration technique: with the help of service models, a business process's activities can be orchestrated with service operations on a graphic level. If there is a description for a service in the Web Service Description Language (WSDL), then a corresponding service model can be automatically created with objectiF through WSDL Reverse Engineering.
• Process Model: in the process model, business processes are described via the business process diagram in Business Process Modeling Notation (BPMN), an OMG standard since 2006. BPMN diagrams are implemented directly in WS-BPEL Code. Every business process is itself a service, which is additionally described with UML classes, as in the service model. Thus, it can be used for the orchestration of a higher business process. Using this convention, objectiF SOA Factory supports the recursive aggregation model for services, which represents and important design medium for service-oriented architecture.
• Entity Model: specifies the persistent business data used by service operations. Models are presented, once again, as UML class diagrams, and have business classes with the stereotype «BusinessEntity».

The domain-oriented architecture of a SOA application - conceptual…

…and as a UML package diagram for a sample application in objectiF

Automatic Transformation of the Domain-Oriented Model into the Technical Model

The objectiF SOA Factory offers you transformations which turn domain-oriented models into technical ones, whilst at the same time generating a large part of the source code. Model transformation is easily achieved via the context-menu function.

Automatic transformation of the domain-oriented model into the technical model of a SOA application

objectiF SOA Factory comes with four model transformations for the automatic transformation of the domain-oriented into the technical model: one for each automatic transfer:

• the presentation model in JavaServer Faces artefacts,
• the process model in WS BPEL and WSDL code,
• the service model in EJB 3.0 SessionBeans with UML presentation as class diagrams
• the entity model in EntityBeans with annotations for the persistent versioning with EJB 3.0, also with UML presentation as class diagrams

Apart from the layout of Java ServerPages, there is essentially only one thing that cannot be generated in this process: a service operation. With SessionBean code created by a model transformation, the implementation of service operations must be manually extended. This is done in Round Trip Engineering with Eclipse, directly from the generated UML presentation of the SessionBeans.

The model transformation creates relationships between the domain-oriented and technical elements of an application. They are continually maintained by objectiF and used for comfortable navigation between models.

The technical architecture of a SOA application, again, as a concept…

…and as an example in objectiF: the comparison with the package diagram of the domain-oriented architecture clearly demonstrates the extent of the model transformations, and therefore the labor save

Iterative Transformation

objectiF SOA Factory supports Iterative Development Strategies. This means it's possible to change, extend and re-transform the domain-oriented model again and again, without affecting the manually implemented parts. Thus, the relationships between the domain-oriented and technical model elements remain persistent and navigable. And, the development has long-lasting transparency. All elements of the domain-oriented and technical model, and the code, can be brought together again and again. This means a complete, consistent overall model of the service-oriented application for further development, is always available.

Flexible and Adaptable

The model transformations in the objectiF SOA Factory can be modified, extended and adapted to other target technologies at any time. objectiF offers support for the development of user-specific model transformations.

Copyright © 2001 - 2010 microTOOL GmbH, Berlin. All rights reserved. Last Change: 24 July 2007