MDD Case-Study: RCP Code Generation in an Airline Company

I was recently asked to translate into english  the case-study presented by BritAir during MD Day 2010. So, here is a summary.

BritAir, a french airline company, is a subsidiary of Air France which transported about 3,5 millions of passengers last year.

Another activity of BritAir is the training of pilots, commercial staff and maintenance technicians of other companies.

Despite BritAir has no developer, the company wanted to keep the control and the quality of its applications:

• Normalize the user interface of the applications
• Normalize the way the applications are designed
• Improve the development productivity
• Document the applications

To achive these goals, Olivier Corbel, the IS Manager, decided to put in place a new development process based on a Model-Driven approach. This project was conducted with Mia-Software and Sodifrance.

The principle of the BritAir approach is based on two main ideas:

• A model describing the business data (entities, identifiers, attributes, child/parent relationships)
• An automatic generation of graphical interfaces (Eclipse RCP) for classic functions (cread, read, update, delete, search and export to Excel)

In addition, the business logic is also described in the model: a concrete syntax has been defined to declare some rules in french. It allows to declare variables, to set values, to test, to loop, etc.

The model is created with MagicDraw, an UML modeling tool, and translated into code (Eclipse RCP and Hibernate) with Mia-Studio, the model transformation engine developped by Mia-Software.

The generated applications are complete and don't require any additional code (the business rules are also transleted into Java). They are deployed on servers with Tomcat, Xfire and Oracle.

It took 300 days (total effort between march 2008 and july 2009) to setup the process, define the target architecture, adapt the tools and train BritAir's staff. The team was composed of three people of Mia-Software (a project manager, a MDA enginer and a JEE architect) and one architect of BritAir (requirements and validation).

Several applications have been developped in parallel, in order to challenge and test the new process and tools.

Now, each time a specific development starts, it uses this approach. Until now, six applications have been developped:

• small maintenance of aircrafts
• management of aircraft events
• cost accounting
• financial forecasts
• management of passengers
• preparation of flights. 

Olivier Corbel has identified several benefits of this MDD process:

• Industrialization of the development activity: normalization of modeling and coding, and better documentation.
• Independance of the models from the target architecture (neither RCP nor Hibernate concepts in the models).
• Design is mandatory, in order to generate the application.
• Better quality of code, since it has been qualified first and then converted into generation rules
• Better productivity: during its talk, Olivier Corbel said that the development managers have evaluated to 10 the productivity ratio on these projects!
• User experience: the applications are homogeneous and always provide the same ergonomy to the users
• Prototyping: it is easier to provide early versions to users and take their feedback into account to improve the application

For BritAir, the next step now is to bring evolutions to the platform:

• Support authorization management
• Extend the expressiveness of the business rules language
• Improve the integration of new applications with existing ones (generated or COTS)
• Add a new generation target (web client)

JEE, Flex and MDSD in Tunis

Last week I was in Tunis.

The weather was not as sunny as expected, but it was not the reason of my travel. I was there to setup a MDSD (Model-Driven Software Development) process for a tunisian bank.

This bank has planned to redevelop its Core Banking System with new technologies (JEE and Flex). In order to facilitate the development and provide both flexibility and quality to the future system, they have decided to adopt a Model-Driven approach.

My mission consists in helping the IT team to put this approach in place.

Developing a generator for a customer is an activity which I usually decompose in four steps:

Development of a reference application

In every industrialization process, the first step consists in identifying the scope of what can be beindustrialized. In a MDSD process, the better way to define this scope is to manually develop a reference application: a subset of the future application which contains examples of each coding patterns.

During a first stay, few weeks ago, we had specified and started to develop a reference application based on a cash withdrawal scenario. Behind this scenario, we had defined several services to invoke, the corresponding business objects (BO) and data transfer objects (DTO), and the existing Oracle tables and stored procedures which have to be reused. Based on the languages and frameworks selected by the customer (Flex with the CairnGorm framework, JEE with the Spring and Hibernate frameworks), we had designed the reference application and defined the coding patterns to use.

This week, when I began my second stay, the customer had finished the development of the reference application, and it was running.

Identification of the Generation Scope

Once a reference application exists, the second step consists in analysing its source code to identify the variability factor of each line of code:

• What is the minimal information required to be able to produce this line of code?
• Is this information specific to the reference application or generic ?
• Can we produce other lines of code with the same information?
• What is the ratio between the effort to declare this information and the effort to manually produce all the corresponding code?

The answers to these questions, coupled with a discussion with the customer, help defining the generation scope:

• which code can be produced automatically?
• which code needs to be developped manually?

Definition of Modeling Rules

Once the generation scope is identified, then we need to define how the information required to generate the code can be defined within a model. There are three possibilities:

1. Defining a Profile in a UML Modeler
2. Developing a Domain-Specific Modeler
3. Developing a Domain-Specific Concrete Syntax

For my customer in Tunis, I have proposed the first option and defined a UML profile containing a first set of about 20 stereotypes (application, service, bo, vo, dao, table, ...). With this profile I used MagicDraw (which provides very powerful extensibility and customization mechanisms) integrated in Eclipse to create a model of the reference application.

Development of Generation Templates

The fourth step is the easiest: templates can be developped from the reference application by copy/pasting fragments of code. The fragments parts which are generic remain in the templates, while variable parts are replaced by calls to the model (using EMF APIs).

Last week, it tooks me one day to develop the Mia-Studio templates for the presentation layer. From the EMF model of the reference application, the templates have regenerated 6 MXML files and 19 ActionScript files (Commands, Events, Service Delegates, Front Controller, and Value Objects). The MXML files contain the graphical definition of the GUI: they will be generated only once, just to provide a first application which can be executed. Then they will be edited and maintained with a WYSIWYG designer.

The templates for the two other layers (Business and Data) will be developed with a colleague during a third stay in Tunis.

Then our role in the project will be to assist the team in modeling and developing the first application and adapt the MDSD process to integrate the unforseen cases.