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 – a Software Factory for Java Web Applications

objectiF offers continuous support from business process modeling in BPMN, domain-oriented and technical software design with UML to the code. However, objectiF is more than just your usual UML tool.

objectiF used as a software factory, allows you to standardize and, for the most part, automate your software development. Automation is based on the concepts of Model-Driven Development (in short: MDD), and can be adjusted and extended, according to your needs.

Get to know objectiF in the form of a software factory for Web applications.

The objectiF Web Factory at Work

The starting point for every Web-application development with objectiF is the requirements model. This consists of use case diagrams, structured texts or activity diagrams. The latter are used to describe use cases and domain-oriented classes. Based on this foundation, the domain-oriented architecture is designed by the developer, and automatically transformed into a technical architecture. EJB 3.0 and JavaServer Faces provide the technical basis.

Creating the Domain-Oriented Architecture

One of the many services objectiF Web factory offers, is the defining of a method for describing the domain-oriented architecture. The method denotes which content needs to be specified, which description methods are best suited for that and the kind of relationships that exist between the architectural elements. Following the method, a Web application with three, coordinated model types is fully specified. The model types are:

• Presentation Model: specifies the page flow of the applications' Web pages. UML-state diagrams are used for the description of presentation models: their states represent Web pages, state transitions show page changes, which are triggered by user events. A state transition can trigger actions, which correspond to the business operations of a business service. This brings us to the second model type:
• Service Model: the domain-oriented functionality of the application is specified in the form of service models. Service models are presented as UML-class diagrams. The objectiF Web factory offers the following conventions: a service model describes application services as classes with the stereotype «BusinessService». Methods of these classes receive the stereotype «BusinessOperation».
• Entity Model: specifies the persistent business data used by business operations. Models are presented, once again, as UML-class diagrams, and have business classes with the stereotype «BusinessEntity».

The domain-oriented architecture of a Web application in the objectiF Web factory consisting of presentation, service and entity layer

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

The objectiF Web factory offers you transformations, which turn domain-oriented models into technical ones, while at the same time generating a large part of the source code. Model transformation is simply triggered via the context-menu function.

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

The objectiF Web factory comes with three model transformations for automatically turning a domain-oriented model into a technical model: one each for the automatic conversions of

• the presentation model into JavaServer Faces artifacts,
• the domain-oriented entity model into EJB 3.0 EntityBeans with annotations. objectiF marks all beans with the stereotype «EntityBean». The technical types used in the attributes of the domain-oriented model are replaced by standard Java types. All attributes are assigned the stereotype «PersistentAttribute». objectiF generates access methods in each bean. objectiF creates a relationship attribute in relevant beans for the technical illustration of the modeled relationship between entity model classes. objectiF also creates the appropriate access methods for relationship attributes,
• the domain-oriented service model in EJB 3.0 SessionBeans. objectiF generates an appropriate remote interface for every bean, and a service locator. A method is created in the SessionBean from each business operation. It is marked with the stereotype «BeanMethod». All domain-oriented types are replaced by technical Java types.

The technical architecture of a Web application in the objectiF Web factory - automatically generated via model transformation

Except for the layout of JavaServer Pages, there is essentially only one thing that cannot be generated in this process: the logic of bean methods. With code created by a model transformation, its implementation must be manually extended. This is done with Round Trip Engineering with Eclipse, directly from the generated UML diagrams 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.

Iterative Transformation

objectiF Web factory supports iterative development strategies. This means it's possible to change, extend and transform the domain-oriented model again and again, without affecting the manually implemented parts. Thus, the manifold 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 as well as the code can be converged 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 transformation in the objectiF Web 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