Fred Madiot

Eclipse Demo Camp in Nantes

2011-06-28T14:52:00.000-07:00

Thursday 30/06 in Nantes, AtlanMod, Obeo and Mia-Software will organize an Eclipse Demo Camp.

The program is rich with the presentation of seven projects coming with the Indigo Simultaneous Release.

Four of these projects are developped in Nantes!

MoDisco (Model-Driven Modernization)
ATL (Model to Model transformation)
EMF Facet (Non-intrusive metamodel extensibility)
EEF (Model extended editors)

The three other projects which will be presented are

Memory Analyzer
Tycho (Building Eclipseplug-ins with Maven)
EGit (Eclipse plug-in for Git)

The Demo Camp will start at 6:00 PM at Ecole des Mines de Nantes.

Step in Toulouse

2011-06-20T00:52:00.000-07:00

This week, I'll be in Toulouse, the aerospace city.

Wednesday (June 22), we will start the Obeo Designer Roadshow, a serie of six steps in six different cities (Toulouse, Brest, Nantes, Paris, Niort and Lille).

Each step of this roadshow will be organized in two parts: the morning will be dedicated to a presentation of the version 5.0 of Obeo Designer, presentations of case-studies by users and a panel to discuss about graphical DSLs.

The afternoon will be more technical with Hands-On sessions: we have asked to each person to come with a case, and we will help them to implement their own graphical designer during the afternoon.

In Toulouse, the case-studies will be presented by Pascal Roques of PRFC and Tristan Faure of Atos Origin.

Thursday (June 23), I will attend Eclipse Party (the Indigo Demo Camp) and give a talk about JavaEE code generation with EEF and Acceleo.

This Demo Camp, will be very intensive with two tracks and a lot of interesting talks (Topcased, Koneki, Closure, Birt, RCP, eGit, SWTBot, e4, etc).

There will also be a specific session about feedback from EclipseCon 2011 (XText, Orion, CDT, Tycho).

Finally, it will end with a panel about Eclipse and its ecosystem, animated by Gaël Blondelle of Obeo.

How to follow Obeo at EclipseOn 2011?

2011-03-16T01:35:00.000-07:00

EclipseCon 2011 starts in less than one week from now.

This year, Obeo will be well represented with five of us going to Santa-Clara:
- Etienne Juliot, Vice-president and co-founder of Obeo, member of the Eclipse Foundation Board
- Cédric Brun, CTO of Obeo, member of the Architecture and Planning council, leading several Eclipse/Modeling projects
- Mariot Chauvin, committer on Acceleo, GMF and SWTBot
- Mikaël Barbero, EMFPath project leader
- and me ;-)

The program will be very intensive for us, with seven talks to give:

We are also in competion with five Eclipse Community Awards finalists:

Laurent Goubet (Acceleo committer) for Top Committer
Cedric Brun for Top Newcomer Evangelist
Modeling Amalgamation (lead by Cédric) for Most Open Project
EEF (lead by Goulwen Le Fur) for Most Innovative New Feature or Eclipse Project
ObeoDesigner for Best Modeling Tool

However, we don't forget the most important thing at EclipseCon: sharing ideas (and beers) with other Eclipse fans!

Using viewpoints to edit complex models

2011-03-02T08:46:00.000-08:00

Based on GMF, Obeo Designer adds several viewpoint mechanisms which facilitate the edition of complex models.

One of the main difficulties with graphical representation of complex models is the number of nodes and edges visible on a same diagram.

Obeo Designer comes with the concept of layer which allows to select the types of graphical elements to display. Inspired from image manipulation tools, several layers can be defined on a diagram and optionally selected or unselected, depending on what the user wants to see from his model.

Based on the simple Family scenario (detailed in my previous post), this demo shows how to define layers for parental and brotherhood relationships.

Another way to reduce the models complexity, is to use tabular representations. With Obeo Designer it is possible to define custom tables representing elements of the model. The lines and the columns are fully customizable depending on the objects and which properties have to be displayed.

This demo, shows how to define a table representing members of a family. Columns contain the names of the parents and other columns contain the numbers of sons, daughters, brothers and sisters.

Creation of a graphical designer in 5 minutes

2011-02-21T10:41:00.000-08:00

After one month at Obeo, the serious things have started for me ;-)

I have spent the last two weeks discovering Obeo Designer 5.0 and working on the videos which will be available on the new website (www.obeodesigner.com). This new version is going to be officially released in ten days, so each minute counts!

Obeo Designer is a tool which allows to create specific modelers in Eclipse. It is based on EMF, GMF and Acceleo.

I have been very impressed by the ease and rapidity for creating my first designer. Of course I'm familiar with Eclipse and EMF, but I had never developped with GMF before. In one day, starting from scratch, I have been able to create my first designer, with several layers (to optionally show or hide some kinds of relations) and a table (to represent my model with lines).

For the demos, we have volontarily chosen a very simple example to illustrate the Obeo Designer approach. With this example, the concept of Family (men and women related by parental relationships), each Obeo Designer functionality can be easily described.

I have posted the first video today. It is a first overview which explains, in five minutes, how to create a first modeler with zero code and zero deployment.

Other videos will come soon to demonstrate the other functionnalities. Stay tuned!

A new start

2011-01-16T13:41:00.000-08:00

Friday was my last day at Mia-Software.

I started working at the Sodifrance group fifteen years ago already. And it has been a very exciting experience!

In 1995, I was working in Paris and I was looking for a new job. As I was hesitated between two propositions, I decided to call Jean Bezivin, who taught me Object-Oriented technologies three years before at Nantes. He asked me "Why don't you come back to Nantes? Yves Lennon, a good friend of mine, is developping software engineering tools in Smalltalk there. He is looking for developers like you". I immediately called Yves, we met, and he hired me.

My first project at Sodifrance was for MMA, an insurance company. This project, called SIGMMA, was a very ambitious re-development of the products and contracts management system in Smalltalk. I worked for three years on this project. I was responsible for designing the database schema and its mapping with the business objects implemented in Smalltalk. As these business objects was defined in Rational Rose with the Booch notation (UML was not existing yet), I developped lots of tools to exploit these models and generate Smalltalk code and Oracle queries.

When I left the project, I had the idea to develop a template-based code generator which could facilitate the development of specific code generators. I proposed this idea to Yves Lennon who said "Go!". In the same time, Java was taking off, with tools like VisualAge. I decide to use Java to develop my new tool which I called Scriptor. Thanks to internal projects which experimented the tool and helped me to improve it, Scriptor was selected in 1999 by Transpac, a France Telecom subsidiary, to generate VB code. It was the first one of a long list of other customers (Thales, Banque Populaire, BNP-Paribas, MAAF, Crédit du Nord, SNCF, etc).

In 2004, we created Mia-Software, as a Sodifrance subsidiary, to structure the R&D and to give a better visibility to the product. I took the CTO position. We renamed Scriptor to Mia-Generation. We added two other modules (Mia-Transformation, for model-to-model transformations and Mia-Documentation for documentation generation) and group these tools in a suite called Mia-Studio. We created also a new tool suite called Mia-Insight to package and distribute tools already developped by Sodifrance for application portfolio management and application mining.

In the same time, Sodifrance, which is the french leader in Software Modernization, has developped a new expertise in Software Migration by using Mia-Insight and Mia-Studio. Based on Model-Driven Engineering, the principle is to extract models from existing systems, to transform these models into models of the new system and to regenerate code from these new models. This approach has been used on lots of projects, for example to migrate VB6 code to C#, or Oracle Forms to JEE.

In 2006, we started a new research project called Modelplex, funded by the European Community. One of the partners was AtlanMod, the research lab leaded by Jean Bezivin. He had just created MoDisco, a new Eclipse project dedicated to the extraction of models from legacy systems. I proposed to Yves Lennon to take the opportunity of the Modelplex project to start developping open-source components and to contribute them to MoDisco. The objective was to develop a reference platform for software modernization projects based on Eclipse and OMG standards. Once again, Yves said "Go!".

Last year, MoDisco 0.8 has been released with Helios. We have presented the project to several Eclipse conferences already, and we know that many users are using its components (such as the Model Browser and the Java Discoverer). The Mia-Software team working on this project (Gabriel Barbier, Nicolas Bros, Grégoire Dupé, Fabien Giquel and Nicolas Guyomar) is very motivated, and Sodifrance has started to provide feedback from real modernization projects (for example to refactor JEE source code).

But after all these years working at Sodifrance and Mia-Software, I felt that I needed a new challenge.

That's why I accepted the Obeo proposition to be their Product Manager. I will mainly focus on Obeo-Designer and Obeo-Agility.

It was not an easy decision to take, but it has been well understood at Mia-Software. The transition went very well, and I'm confident that the products (Mia-Studio, Mia-Insight and Mia-Quality) and the Eclipse projects (MoDisco and EMF facet) are in good hands!

Now, I'm ready to take a new start!

Traceability between an EMF Java model and the corresponding source code

2010-12-17T00:47:00.000-08:00

MoDisco 0.9M4 has been released this week with Eclipse Indigo M4.

One of the new interesting features is the traceability between an EMF model created from the reverse-engineering of a Java application and the corresponding source code.

It allows to directly navigate from elements of the Java model in the MoDisco Model Browser to the corresponding code fragment in a Java editor.

This feature is provided by a new Java discoverer which can be executed with the MoDisco menu "Discover Java and Inventory model from Java source code" available on a Java project.

This discoverer automatically creates three EMF models:

a Java model describing the content of the source code: it is the model created by the basic Java discoverer.
a KDM Inventory model describing the structure of the Java project (all the files and folders).
a traceability model containing relations between the Java model elements and source code fragments

If you need to know more about these models, you can read the documentation of the discoverer.

When you launch the discoverer on a java project, the traceability model is automatically opened in the MoDisco model browser.

To activate the synchronization with the Java source code editor, you need to activate the "Synchronize with source code option".

Now, when you click on a model element in the model browser, the corresponding source code is automatically highlighted in the Java source code editor (otherwise, the double-click on an element opens the property view).

Spy On Your Models - Part 4

2010-12-15T03:27:00.000-08:00

In this sequence of posts, I explain how to use the Model Browser provided by MoDisco to inspect an EMF model.

In the first three posts, I have described how to directly access to instances of a given type, how to navigate through the model elements and how to customize the browser.

In this last post, I will now describe how to create and execute queries on model elements directly from the browser.

The features presented in the previous posts, allow you to navigate through the elements of your model by traversing the links. You can also highlight some characteristics of specific elements by defining a customization which dynamically change their rendering (icon, label, font, color, etc).

But in some situations, you would like to calculate values from model elements. These values could be of basic types (numbers or strings) or could be other model elements.

MoDisco provides a mechanism to execute queries interactively on model elements selected in the Model Browser. First, I will explain how to execute queries, and we will see later in this post how to declare and implement them.

There are two possibilities to execute a query.

The first one consists in selecting model elements in the browser and clicking on the menu "Execute Query ...". It opens the "Query Execution" view which contains two main parts:

The elements on which to execute the query. It is filled with the elements you have selected, but you can also remove elements from this list or drag&drop new elements from the browser.
The registered queries which can be executed on the selected elements

When you click on "Execute" the selected query is executed on each model element and the result is displayed in a table (more possibilities will be provided with future versions).

The table displays each returned value on a line. If the result is a basic type, the table contains only one column. But if the result is a model element, the table contains several columns:

A colum "Label" which contains the calculated label of the object.
A column "Metaclass" which contains the type of the object
A column "/eContainer" which contains the parent of the object
A column "Query Context" which contains the object for which the query has returned the object
A column for each attribute of the corresponding metaclass
A column for each reference of the corresponding metaclass (for nary references, the tablel displays the number of related objects).

On each line, it is possible to re-execute a query or to browse the selected element with the model browser.

To execute a query from the browser, the second possibility consists in adding the query to a model element in the browser by clicking on the menu "Dispaly Queries on Selected Element":

A dialog is opened with all the applicable queries:

The selected query is added to the model element. When you click on this query, it is executed and the result is displayed under the query:

Now, to create your own query, the first step consists in creating a QuerySet in a MoDisco project: right-click on the project, select the menu "New>Other" and select "MoDisco / QuerySet model":

Give a name to your new QuerySet and MoDisco creates it in the project:

A QuerySet is a model which contains the declaration of the queries. The new QuerySet is empty. So, to start declaring the queries, just double-click on the QuerySet to open it with the dedicated editor:

Now, you need to associate the QuerySet to a metamodel: all the queries will apply on model elements of the corresponding models.

Let's say we want to declare queries for UML model elements. This association is done in two steps:

Load the ECore definition of the metamodel: right click on the ModelQuerySet instance, select the menu "Load meta-model ressource" and select the right ECore definition.

Associate this metamodel to the QuerySet: double-click on the ModelQuerySet instance to open its property view, click on the button in the "Associated Metamodels" property field, and select the metamodel.

Now, you can start declaring the queries: right-click on the ModelQuerySet instance and click on the "New Child" menu. You can declare queries of three kinds: Java, OCL or XPath.

For each query, you have to declare its name, its scope (on which elements the query is applicable), its return type and its multiplicity (lower and upper bounds). Implementing the body of the query depends on the kind of query:

OCL: enter an OCL expression in the "Query" property
XPath: enter an XPath expression in the "Query" property
Java: enter the name of a Java class which implements the query

To know more about how to declare a Query, you can read the reference documentation of the MoDisco QueryManager.

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

2010-12-13T06:01:00.000-08:00

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)

MD Day 2010

2010-12-01T05:44:00.000-08:00

Like every year, the french modeling community has met during the MD Day last week in Paris.

It was the fourth edition, with a format which makes the success of this event: each partner (11 this year) must come with one of its customers who presents a real-life project where model-driven engineering has been used. Once again, despite optimistic forecasts, we still ran out of place, and we have been forced to close the registrations three weeks before the event ! Finally there have been 275 attendees (234 last year).

This year, the conference started with Steve Cook's keynote "UML: Past, Present and Future".

Stevecook uml mdday2010

I already knew the past: I've worked a while with Booch notation in the 90' (remember these little clouds...) ;-)

What I found really interesting was the part about the UML dilemnas:

What is the real value proposition of UML ? There is often a misandurstanding about why to create UML models.
Should DSLs be based on UML ? UML should be more reusable.
Is UML appropriate to describe non software domains ? It was not the initial intention of this metamodel.
Can UML be a pivot to model semantics ? New versions of OO languages integrate concepts which are not supported by UML.

Regarding the future of UML, Steve presented the main initiatives:

UML is too complex: it is going to be simplified, in order to facilitate its modularization and isolate the parts which are really used.
MOF is going to disapear: UML will be defined by itself, in order to facilitate the manipulation of metamodels with any UML compliant tool.
UML Diagrams are going to be formally defined: a Diagram Definition initiative has started

These problems are real, but as Eclipse Modeling Project already proposes solutions to solve this kind of problems, I hope that UML team is not going to reinvent the wheel.

After the keynote, the conference continued in two tracks, with partners and users talks.

At Mia-Software we had invited Olivier Corbel, the IS manager of BritAir, an airline company, who presented its model-driven development process.

Britair mdday2010

BritAir uses MagicDraw to create very simple UML class diagrams which represent the domain model of each new application (entities and relations).

This UML model is used to fully generate RCP applications which allow to manipulate the data (CRUD). The generation rules are defined and executed with Mia-Studio.

When some business logic is required, it is defined with a textual DSL (business rules in french) and then automatically translated into Java.

This approach and the corresponding tools are now used each time BritAir has to develop a specific application. The code is 100% generated. For 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 said that the development managers have evaluated to 10 the productivity ratio on these projects!

After this presentation, I had decided to talk (in french again) about Model-Driven Development and how to reconcile developers with Model-Driven engineering.

Mia-Software at MD Day 2010

In the first part of my presentation I constated that, in 2010, Model-Driven Engineering adoption continues to increase:

A lot of successful projects have already proven the benefit of Model-Driven Development. In many domains (bank, insurance, defence, aeronautics, transportation, etc) and for various technologies (Java, C#, Flex, Smalltalk, Ada, C, Cobol, etc).
Model-Driven Engineering is not only dedicated to the development of new applications. It is also used to maintain the existing ones and facilitate their modernization. The MoDisco project is an example of such initiative.
The offer is very rich! Just have a look at the Eclipse Modeling Project: during the last nine months, there have been 14M lines of code committed on 45 active projects, by 113 committers of 20 different companies ! In addition, standards such as UML2 (even if the specification could be simplified) is now supported by a lot of mature tools.
The MD Day reflects this adoption with a continuous augmentation (since 2007) of both partners and attendees.

Despite this fact, we must also admit that Model-Driven Engineering still faces strong resistance.

It is easy to challenge the most current arguments:

Complexity of UML? UML is complex (even OMG admitted it by launching the UML Specification Simplification RFP), but 20% of UML (class diagram) is sufficient for 80% of needs. Do you really think that a class diagram is more complex than all the web technologies (WSDL/SOAP, Hibernate, Spring, etc) that most developers are familiar with ? And if it's still too complex, you can use a DSL with only your vocabulary: Model-Driven Engineering is not only UML!
Too much abstractness? MDD implies that the model should be more abstract than the code to develop (this is what makes the model more sustainable than only the source code). But the level of abstraction is free: it's up to you to define the good level of abstraction depending on the maturity of the team.
Complicated Process? MDD implies two new activities (the production of the model and the generation). But these activities can be integrated to any kind of process (from agile to waterfall). And modeling usually corresponds to the design of the application. For those who still think that design is not compatible with agility, just read principle #9 of Agile Manifesto: "Continuous attention to technical excellence and good design enhances agility".

Nevertheless, one argument againts MDD is a real one: the difficulty to keep in sync the model and the code. If you loose the synchronization, you loose the benefit of MDD. But if you put all the energy of your team in maintaining this synchronization, you loose in agility.

Hopefully there are solutions to avoid this pitfall:

Model at runtime: the model is not transformed into code, it is directlty deployed and interpreted by a runtime engine. This approach is similar to declarative languages based on XML, for example to describe GUIs (XUL, XAML, etc). The drawback is that you need to implement a runtime engine.
Model compilation: the model is transformed into a complete source code, where no additional coding is required (this is the solution adopted by BritAir). This approach is similar to the compilation of a 3GL language (Java, C++, C#, etc) into C or byte code. The drawback is that you need to create comprehensive models and develop complex generators where all the cases must be supported.

But in most cases, you can't describe all your system with a model. Then the generated code has to be completed manually. In this situation, to avoid the desynchronization between the model and the code, a solution consists in applying the Agile principles to modeling and code generation (we can call this approach Agile MDD).

Agile Modeling consists in:

Useful modeling: only model what is really helpful for the understanding of the system, and what will be exploited by the generator. Avoid modeling any information which is redundant with the code (it would rapidely be out of sync).
Simple modeling: if the system is complex, the model can be complex, but it should always be more simple than the code.
Viewpoints modeling: decompose the model into submodels describing viewpoints on the system
Incremental modeling: the model should be continuously challenged by other people on the project and/or by the generator.

Scott Ambler has defined several other core principles that you can read on http://www.agilemodeling.com/principles.htm

To produce code, these principles should be combined with other Agile principles related to generation. The objective of these Agile Generation is to reduce the gap between the model and the code:

Targeted generation: you must be able to select only what you need to (re)generate, depending on what has changed (in the model, or in the generator). If each re-generation is global and takes too much time, you may want to delay the modification in the model and directly modify the code.
Incremental generation: if the generated code has to be completed manually, these modifications must be protected by the next generations (now, all the generators have this functionality with protected areas).
Traceability: the generator should keep the trace between the model and the code to allow to easily navigate from a file to the corresponding model element.
Impact analysis: each time you click on the "generate" button, you must be informed of what exactly happened. Which are the new generated files ? Which parts of the existing files have been modified ?
Assisted coding: after a generation, you should have a direct access to the parts of the code which have to be manually completed.
Adaptability: the generated code reflects architectural and coding choices which can evolve during the project. Templates engine already allow to easily modify the generator. But to facilitate the modification of the right template, traceability mechanisms should give a direct access from the generated code to the corresponding template definition.

Of course, these Agile MDD principles are not exclusive: they should be combined, when it is possible, with Model at Runtime and Model Compilation approaches.

To illustrate Agile MDD, I ended my talk with a presentation of the Mia-Studio tool suite which supports these Agile Generation principles.

Then Tony Rostren shown a short demonstration of the tool:

Modeling of the cinematic of an application in UML with MagicDraw
Generation of an executable application based on Struts
Edition of the generated code in Eclipse
Navigation from Java source code editor to corresponding element in MagicDraw
Modification of the model and regeneration of the corresponding code
Access to a template from a selected fragment of generated code

The full demonstration is available here:

http://www.mia-software.com/html/miaStudio/download/demo/mdday2010.htm

I spent the rest of the conference talking with customers and partners and demonstrating our tools. I could only attend one other presentation. It was the Sodius one, with Yann Lebeaupin talking with EADS about tools interoperability to support system engineering.

You can find all the other presentations on slideshare: http://www.slideshare.net/MDDAY/presentations

An Eclipse Modeling Week

2010-11-09T00:45:00.000-08:00

Last week, I participated to Eclipse Summit Europe 2010 in Germany.

I started tuesday with a talk at the Eclipse Modeling Symposium (you can read my previous post: Using EMF to represent Eclipse 3.x plug-ins , and a complete summary of the symposium on Ed Merks' blog).

Then thursday, with Grégoire Dupé, I presented EMF Facet, the new Eclipse/Modeling project we have created to allow dynamic extensions of existing EMF models.

EMF Facet at ESE 2010

We have finished the week friday, at Eclipse Day Paris, by a presentation of MoDisco, the Eclipse/Modeling project dedicated to Model-Driven Software Modernization.

MoDisco at Eclipse Day Paris 2010

Now, we can come back to a normal activity ... until MD Day 2010, the 25th of November in Paris.

Using EMF to represent Eclipse 3.x plug-ins

2010-11-03T01:23:00.000-07:00

Yesterday was the first day of Eclipse Europe Summit 2010 in Ludwigsburg. The afternoon, I participated to the Eclipse Modeling Symposium organized by Ed Merks and Sven Efftinge.

The room was crowded: I evaluated more than 150 attendees to this 4 hours session. It has been a very good opportunity to get an overview of how dynamic is the modeling world in Eclipse. There have been 15 presentations about models migration, graphical modelers (even in 3D !), models testing, code generation, documentation generation, new features for textual DSLs, and many other topics… (you can find a summary on the Mäd Meiers' blog).

I really appreciated the Papyrus presentation, especially when Remi Schnekenburger of CEA explained how they have integrated MoDisco to provide customizable navigation through the models ;-)

I also got the chance to give a presentation during this session. This presentation was about using EMF to describe existing plug-ins developed for Eclipse 3.x. The idea is to create models from the main artifacts which compose an existing plug-in:

An inventory model (using KDM Source) for the organization of the plugin (folders and files)
A comprehensive Java model (using MoDisco) from the Java source code
A specific model to describe the MANIFEST.MF file
Several XML models (using MoDisco) for the .classpath, .project and plugin.xml files
Two KDM models for the content of the plugin.properties and build.properties

These models are referenced by a last model which describes the whole plug-in.

Here, the main benefit of the approach is not to raise the level of abstraction (the classical benefit of Model-Driven Engineering), but to go from an heterogeneous world (with various file formats) to an homogeneous world (EMF models) where you can manipulate all the information by using EMF APIs (and then any EMF compliant tool).

Then, I presented three examples of how this kind of model can be used:

Quality Analysis: by introspecting the model of the plug-in to check development rules, we can create a model of violations and inject this model into the Eclipse Problem View.

Refactoring: by transforming the model of the plug-in and then regenerate it, we can adapt an existing Eclipse 3.x plug-in to fit with the E4 compatibility layer.

Release Engineering: by extracting additional models from the content of update sites, we are experimenting constraints solver to calculate and evaluate possible build configurations and initialize B3 models.

The slides of my presentation are available on Slideshare.

Mia-Software at Eclipse Modeling Symposium 2010

View more presentations from fmadiot.

Today I will try to combine official sessions (to discover what is coming from other projects) and side discussions with persons who are interested in our work (several meetings are already planned about MoDisco and EMF Facet).

ESE is definitely too short :-(

Spy On Your Models - Part 3

2010-10-28T14:54:00.000-07:00

In this sequence of posts, I explain how to use the Model Browser provided by MoDisco to inspect an EMF model.

In the first two posts, I have described how to directly access to instances of a given type, and how to navigate through the model elements. In this third post, I will now describe how to customize the browser.

When your model contains a large number of model elements, you need help to identify the nature of the objects your are looking for. A good idea is to define a graphical extension to associate a specific graphical rendering (icon, label, color, etc). It can be achieved with the EMF.Edit framework by developing content and label provider classes. You can develop and deploy a new plug-in, and once this plug-in is installed, the customization is applied systematically.

But in some situations, you need a more flexible customization. A customization which presents the model according to a given viewpoint. A customizations that you apply temporarily, depending on a working situation.
This is what you can do by creating a UICustom model.

A UICustom model defines graphical properties for elements of a metamodel (a ECore model). These properties can be loaded dynamically by the Model Browser and applied to the model elements.
First, you have to create a new MoDisco project:

Then, create a UICustom model in this project:

The UICustom creation wizard asks which is the metamodel to be customized. It proposes all the ECore models registered in your Eclipse:

Once created, you can edit the UICustom model with the editor provided by MoDisco:

Now you can select a metaclass and edit its graphical properties (label, bold, italic, font, color, icon, visible, etc). You can also customize the attributes and the references of the metaclass.

Each graphical property can be set with a static value (for example, define a new icon for all the instances of Class) or a dynamic value, computed by a Query (for example, the label of an instance of Class can be italic if its "isAbstract" value is true).

To understand how to define a customization, you can read the user manual in the MoDisco wiki.

Once saved, a UICustom is applicable. Click on the "Load Customization" button in the toolbar :

Your UICustom model appears with all the other registered UICustom models. You can select it to apply it on the current model loaded in the Model Browser.

In the next post, I will describe how to create and execute queries on model elements directly from the Model Browser.

Spy On Your Models - Part 2

2010-10-18T13:18:00.001-07:00

In this sequence of posts, I explain how to use the Model Browser provided by MoDisco to inspect an EMF model.

In the first post, I have described the Types panel which allows to directly access to all the EMF instances of a given EClass. In this second post, I will now describe the Instances panel which allows to inspect an EMF object and navigate to all the other connected EMF objects.

This panel is a tree containing all the instances of the type selected in the Type panel. If you open a model element, you can see all its properties: the attributes and the references declared by the type (the metaclass) in the corresponding ECore model (the metamodel).

The attributes are displayed with a green bullet and the value of the selected instance. The references are displayed with an icon inspired by UML associations: containment references have a diamond (like UML compositions), references with no opposite are terminated by an arrow (like UML navigable roles). Derived properties are prefixed by "/".

On each reference, you can right-click and select the "Add child" menu to add new EMF objects.

If you want to hide empty and derived references, unselect the buttons "Show Empty Links" and "Show Derived Links". Then the tree will only display setable references which have at least one connected object.

When you open a reference, you can see all the objects connected through this reference. This is very helpful to know how the objects are connected to each other. Especially when the current type declares several references of the same type: in this case, you see precisely the connected objects under each reference.

This instance tree proposes several other interesting options.

Let's see some of these options:

Show Multiplicity: This option displays the upper and lower bounds (between square brackets) of each structural feature as they are defined in the corresponding ECore model.

Show Ordering: This option displays the index (between square brackets) of each element under a reference which has the "ordered" ECore property set to true. It is useful if you have already selected the "Sort instances" option which displays the elements in an alphabetical order. See below the instances of Property sorted by name under the ownedAttribute reference: they are suffixed by the index within the list of attributes of the current class.

Show Opposite Links: this option indicates the name of the opposite links (if there is one defined in the ECore model). This option helps to know which reference allows to go back to a given object. Below, you can see that the owner reference can be used to go from an instance of Comment back to the class CollectInformation.

Show Container: When there is no opposite link defined, this option helps you to go back to the container (the objects which holds the current object with a "containment" reference). The eContainer reference is part of the EMF framework.

Show Types of Links: This option indicates the Type declared for each reference. It is useful to know what kind of objects you can find under a reference. Below, you can see that the packagedElement reference accepts instances of PackageableElement. It explains why you find instances of Class and Association which both inherit from PackageableElement.

In the next post, I will explain how this browser can be dynamically extended and customized.

Spy On Your Models - Part 1

2010-10-14T13:26:00.000-07:00

Have you ever been stuck with an EMF model, trying to find what was going wrong? Which relation is broken or missing ? Where is that model element which should be there, related to that other one ? How many instances this EClass has in the model ?

Of course, you can use the EMF reflexive editor. It is suitable for small models, but when your model contains a lot of model elements it is hard to find your way (you must start from the roots elements, you don't see the name of the relations between the objects, the tree doesn't show the objects pointed by non-containment relations, etc).

So, if you really need this kind of information (and if you are not an expert in reading XMI files in plain text), the model browser provided by MoDisco is a solution for you.

To allow inspecting the details of large and complex EMF models, MoDisco (the Eclipse/modeling project dedicated to Software Modernization) provides an editor with lots of interesting features.

After MoDisco installation, you can right-click on any EMF resource and open the browser by selecting the menu "Open with > MoDisco Browser".

In this suite of posts, I will describe the main features of this tool.

The first feature is a panel, on the left-side of the browser, displaying the classes (metaclasses) of the corresponding ECore definition (the metamodel). The selection of a type displays all its instances in the right-side panel. Each type is suffixed by the number of its instances. By default, only the types with at least one instance are listed, but if you click on the "(0)" button, the empty metaclasses are also listed.

Sometimes, it can be helpful to see also the instances of the subtypes too. For example, in a UML model, if you consider the DataType metaclass you may need to access also to the Enumeration and PrimitiveType instances. It is possible by clicking on the button "Display Instances of Submetaclasses".

By clicking on the button "Show Derivation Tree", you can also display these types in a tree, organized according to the "eSuperTypes" relation.

Four other options are available: to sort the types alphabetically, to sort them by the number of their instances, to group them by package and to show their full qualified name.

Of course, standard features provided by EMF on EClass are still available. For example to get the references to a metaclass, the menu "Show References" opens the view "EClass References".

Another important feature provided by the browser is the management of large models. If a type as more than 1000 instances, they are displayed by groups of 1000 instances.

In a next post, I will describe the features related to the Instances panel which allows to view the properties of each instance and to navigate through its references to other instances.

Using EMF to detect loops within a JSP

2010-10-01T02:49:00.002-07:00

After my post explaining how to create EMF models from JSP pages, someone posted a comment on TheServerSide to know if the EMF model could be used to detect loops in the JSP (http://www.theserverside.com/news/thread.tss?thread_id=60980).

In fact, you can integrate loops in a JSP with several ways. The EMF model will represent these ways differently.

If you write a scriptlet containing a loop in Java (for, while, ...):

the EMF model created from this JSP will contain a JSPScriptlet object which contains the text of the scriptlet.

The discoverer currently provided by MoDisco does not parse the content of the scriptlet. It will be provided in a future version (after Indigo) by using the Java metamodel to represent the Java fragments contained in a scriptlet.

Another way for looping in a JSP can be achieved by using the "forEach" tag:

In this case, the EMF model will contain a JSPAction object whith the name of the tag ("c:forEach" here):

This EMF object contains children which are the attributes of the tag (var, items, varStatus, ...) and the sub elements of the tag (a JSPAction "c:choose" and an Element "tr"):

How to create EMF models from JSP pages ?

2010-09-27T04:33:00.001-07:00

The next release of MoDisco (version 0.9) is under development and is planned to be released with Indigo. This release will come with new components for creating EMF models from the source code of JEE applications.

The current version (version 0.8) already provides components for creating EMF models from java source code (see this older post). In next version, new components will be dedicated to JSP reverse-engineering. They have been developped by Fabien Giquel and Nicolas Guyomar of Mia-Software.

They are composed of:

a metamodel for describing a JSP
a discoverer for creating a model from a set of JSP pages
a generator for generating JSP pages from a model

The JSP metamodel (defined with Ecore) is an extention of the XML metamodel (also provided by MoDisco) which contains types such as Page, JSPScriptlet, JSPExpression, JSPTagLib, etc.

The discoverer, is a component which analyzes JSP pages and creates an EMF model conforming to the JSP metamodel.

It can be launched from a project, or directly from JSP pages.

The result is an EMF model which can be opened with the MoDisco Model Browser.

The generator allows regenerating JSP files from an EMF model (conforming to the JSP metamodel). While it still needs to be improved to support a better formatting, yet it can already be used to produce JSP files.

With these new components, you can reverse-enginer JSP files and use EMF APIs in order to control coding norms, detect patterns, document existing pages or refactor them by applying transformation at the model level (and then use the generator to get a new version of your JSPs).

EMF Facet project has been created

2010-09-23T09:55:00.001-07:00

EMF Facet is a new Eclipse/Modeling project which will provide solutions to extend existing metamodels without changing them. It has been provisioned recently in EMFT by Greg Dupé of Mia-Software, the co-leader of the project.

With EMF Facet, it will be more easy to dynamically extend and customize a tool based on EMF.

The idea is to allow defining new attributes, new relations and new types in a non-intrusive way (you can read this older post about EMF Facet).

This mechanism has already been developped in the MoDisco project (the Eclipse/Modeling project dedicated to Software Modernization). It is completed by a QueryManager component which allow executing queries on a EMF model independently from the query technology (bridges for OCL, Java and XPath are already available). As it is independent from Software Modernization purposes, the corresponding code is going to move to this new EMF Facet project.

After some refactoring, it will be enriched with other components (such as customizable widgets to display extended EMF models). First version is planned to be ready in June 2011 for Indigo, the next Eclipse release. Before this date, early versions will be available with intermediate Indigo milestones.

To know more about this project, don't miss the talk EMF Facet: a Non-Intrusive Metamodel Extension Tooling, Thursday, the 4th of November during Eclipse Summit Europe 2010, in Germany.

Eclipse DemoCamp in Nantes

2010-06-29T23:55:00.000-07:00

An Eclipse DemoCamp will be organized in Nantes the 8th of July.

http://wiki.eclipse.org/Eclipse_DemoCamps_Helios_2010/Nantes

It is a good opportunity to discover what's new in Helios and to meet teams directly involved in the development of the platform.

Here are the projects which will be highlighted:

- Glassfish, the JEE Application Server

- STP, the SOA Tools Platform

- MoDisco, the Model-Driven Software Modernization platform

- Acceleo, the Model-to-Text project

- ATL, the Model-to-Model project

Each project will be presented by one of their commiters (from SERLI, Mia-Software, Obeo and INRIA).

It's free and only two hours from Paris!

Getting feedback from adopters

2010-06-24T09:32:00.000-07:00

The OMG Technical meeting at Minneapolis is over, I will come back to Nantes tomorrow.

This kind of event is a very good opportunity to meet users of the tools we have developped for Eclipse. As anybody can download these tools, it is difficult to know precisely how they are used, and by who.

For example, this week I discovered that Nicolas Rouquette from the NASA, was using the MoDisco Model Browser to inspect complex XML documents! This browser has not been developped for this purpose. But, as MoDisco comes with an automatic transformation of XML files into EMF models, you can load any XML file directly into the browser, and benefit from all its navigation, filtering and customization capabilities!

Just click on an XML document, select the menu "Open with > Other..." and pick the "MoDisco Model Browser".

We really appreciate all these kinds of feedback: they are of great help while defining our roadmap :-))

If you have adopted (or are going to adopt) MoDisco , feel free to post your feedback (good or bad, it helps in both cases) on this blog, or on the MoDisco forum .

Helios is out. Now, let's take the Indigo train!

How to install MoDisco with Helios?

2010-06-24T01:26:00.000-07:00

This year, for the Helios release, the Modeling Package offers a very simple way to install the Modeling components.

The Modeling Package is one of the Eclipse pre-packaged distributions available from the download page (http://www.eclipse.org/downloads/).

Once you have downloaded and launched this package, just click on the "Install Modeling Components" button from the toolbar.

This button opens a window displaying all the available Helios Modeling components. Select MoDisco and click on the Finish button.

A wizard appears to display all the MoDisco components which will be installed.

Click on Next, then click on the "I accept the terms of the licence agreement" to finish the installation.

Restart Eclipse and it's done! You have now access to the features provided by MoDisco 0.8.

Some of these features are directly available to manipulate or create EMF models, without having to write a line of code:

In addition, as a platform for Software Modernization projects, MoDisco also provides a lot of components to help you in the development of model-driven reverse-engineering tools.

Enjoy!

Using EMF to control Eclipse plugins development rules

2010-06-22T11:01:00.001-07:00

This week I am in Minneapolis to attend an OMG Technical Meeting.

Today I participated to the 2nd Eclipse & OMG Symposium where I talked about MoDisco and how we support the specifications defined by ADM, the OMG task force working on Software Modernization. I presented an example where we use KDM (Knowledge Discovery Metamodel) and SMM (Structured Metrics Metamodel) to control the quality of Eclipse plugins.

We wanted to check automatically some rules which are mandatory by the yearly synchroneous release:

Version number ends with « qualifier »
Source code must use ICU4J classes
The project must contain an « about.html » file
Packages name should start with the plug-in Id
Plug-in must not contain JARs files
Plug-in should contain only one « message.properties » and « Message.java » files

We also wanted to check some rules that we had defined internally at Mia-Software:

“PLUGIN_ID” variable of “Activator.java” should be initialized with the plug-in Id
Plug-in Id and Project name should be equal
«Bundle-Vendor» property value of « MANIFEST.MF » should be « %providerName »
« plugin.properties » should declare a « providerName » property
«Bundle-Name» property value of « MANIFEST.MF » should be « %pluginName »
« plugin.properties » should declare a « pluginName » property

Of course, we could have implemented these rules by using the APIs provided by the plugins already provided by Eclipse (org.eclipse.core, org.eclipse.pde, org.eclipse.pde, etc). But all these APIs are not homogeneous, and it is not always easy to find the right API to use. That's why we decided to experiment an other approach.

Our idea is to use these APIs only to create EMF models of the plugin. Then, once the models are created, we can implement the rules by using only EMF APIs.

In our case, we have used MoDisco to create seven EMF models:

A KDMSource model describing the organization of the plugin project (files and directories)

A Java model describing the Java source code of the plugin
A Manifest model to describe the content of the MANIFEST.MF file
Two XML models to describe the content of the .project and .classpath files
Two KDMCode models to describe the content of the plugin.properties and the build.properties files

These models contain all the information required to check the rules listed below.

Rather than directly displaying the violations found in an Eclipse plug-in into the Eclipse Problems View, we use an SMM model to represent the result of the analysis. Then, we have developped a generic tool which displays each rule violation contained in this SMM model into the Eclipse Problems View.

The benefit of this approach is that you just have to know EMF APIs to implement the rules, or use any EMF-compliant tool (such as OCL, ATL or QVT). Another benefit is that the result (the SMM model) is independent from how you want to deliver it to the user. Here we have injected the violations into the Eclipse Problem View, but we could have generated an Excel file or populated a tool such as Sonar.

I have still some little things to improve in this plugin, and I'll try to to commit it this summer as a use-case in MoDisco.

Meanwhile, the complete presentation is available on slideshare.

MoDisco Eclipse-OMG Symp 2010

New MoDisco homepage

2010-06-03T08:20:00.001-07:00

The MoDisco homepage is now based on the new template provided by Heiko Behrens from XText team.

Some modifications have been done in the CSS to avoid the blinking effect on quick links. This CSS is available here : http://www.eclipse.org/MoDisco/style.css

We still have to integrate a screencast, but it's already a good improvement.

Many thanks to Heiko !

MoDisco is ready for Helios

2010-05-31T02:16:00.000-07:00

MoDisco 0.8 RC2 has been released last week. It contains all the features which will be shipped with the final Eclipse Helios release (available June 23, 2010).

Here are the main features added since MoDisco 0.8 M5:

Edition of models

MoDisco provides a browser to inspect complex EMF models. Now it is possible to use the ModelBrowser to edit and modify the instances of the loaded EMF model:

Edit attributes through the Properties view
Create new children elements
Delete a model element (with all its references)
Cut/Copy/Paste a model element
Undo/Redo modifications
Save and Save As the model

In addition, when the model is externally modified, the browser is automatically refreshed.

Collapse Link option

One of the main differences between the MoDisco ModelBrowser and the default EMF Reflective Editor is the way the children elements are displayed.

In the Reflective Editor, all the children model elements are placed directly under the parent model element: you don't see how the children are connected to the parent.

In the MoDisco ModelBrowser, the children are grouped under an intermediate node corresponding to the link defined in the metamodel.

This feature is very useful when instances of the same type can be associated through several different links: you can know precisely how the children are connected to the parent.

But in some cases this option is not convenient (for example when each children of a given type can only been attached with one relation).

That's why we have added a new option to the Customization model and corresponding editor: you can now collapse a link to hide this link in the browser and display the corresponding children directly under the parent.

Reusable Model TreeView

The TreeView developped for the ModelBrowser is now compliant with CNF (Common Navigator Framework).

This TreeView displays the model elements properties and allows accessing to related objects by navigating through relations defined in the metamodel.

Now this TreeView can be reused and integrated to any component compliant with CNF, and then benefit from the customization and extensibity mechanisms to dynamically configure which properties and relations are visible, add derived attributes and relations, and change how the model elements are displayed (label, color, icon, ...).

For example, the TreeView can easily be integrated into the Project Explorer to inspect the content of any EMF model:

The TreeView has already been adopted by the Papyrus team to replace the default treeview in the Package Explorer.

Java Model Query creation wizard

MoDisco provides a QueryManager to allow executing model queries independently of any technology. Drivers for Java, OCL and JXPath are provided to execute queries written with these technologies.

Since MoDisco 0.8 M6, a wizard facilitates the creation of queries written in Java:

The wizard generates the corresponding Java class stub, with the correct imports and generic parameters instantiation.

EMF Facet, a new project for model customization and extensibility

2010-04-26T05:33:00.000-07:00

How to dynamically extend and combine existing Ecore definitions without having to modify them?

EMF Facet, a new project we have proposed to create under EMFT, will propose dynamic extension mechanisms for all EMF-based tools exposing a view on a model:

Navigation tools (browser, navigator, etc);
Graphical modeling tools;
Code or documentation generation (M2T) tools;
Model-to-model transformation (M2M) tools.

Our proposition provides a solution to introduce new viewpoints (or "facets") on existing models:

Extending an existing metamodel (Ecore model) in a non-intrusive way by adding new types, attributes, operations and relations. New relations could be used to compose several models by linking their elements.
Computing an extension by executing queries against an existing model; queries will be implemented by making use of existing query mechanisms (e.g. considering Java, ATL, EMFQuery, Xpath, etc)

The Query "subClassifiers" visible as a "virtual" relation on Class

Some of these mechanisms have already been developped in the MoDisco project. But, as they could be reused by tools not related to software modernization (the scope of the MoDisco project), we have decided to contribute the corresponding components to EMF Facet.

In a previous post, I have presented these components (Facet Manager and Query Manager).

In another post, I have also illustrated how Facets can be used to extend the Java metamodel to highlight JUnit concepts.

Architecture-Driven Modernization Case-Studies

2010-04-21T23:47:00.000-07:00

William Ulrich and Philip Newcomb have recently published "Information Systems Transformation, Architecture-Driven Modernization Case-Studies", a reference book on Software Modernization.

This book has been written by two of the most active members of the Architecture-Driven Modernization task force, the OMG initiative which aims at defining standard specifications for the modernization of existing software systems. They first introduce Architecture-Driven Modernization technologies, standards and approaches. Then they have compiled ten detailled case-studies on real modernization projects on various business domains (bank, administration, tourism, air-trafic management, combat system) and technologies (COBOL, VB6, Powerbuilder, ...).

With Gabriel Barbier (Mia-Software), Yves Lennon (Sodifrance/SoftMaint) , Hugo Brunelière and Frédéric Jouault (INRIA/AtlanMod) we have written one of these case-studies.

In this chapter we first describe the modernization process and tools used by Sodifrance to migrate Software Systems. The approach has been imagined and protyped thanks to a collaboration established in 1993 bewteen Sodifrance and Jean Bezivin, from University of Nantes, who was working on the representation of existing software systems with a technology based on sNets, a first generation of model engineering platform.

The sNets technology was immediately used by Sodifrance to develop a semantic discovery tool, named Semantor, to analyse any COBOL program and provide a fine-grained level of information about its internal structure and data. This tool is still evolving and has been renamed Mia-Mining.

In parallel, at the end of 1998, based on the experience gained in the rebuilding of an insurance company’s contract management system, where modelling and tailored code-generators were successfully used, Sodifrance started developing its own model transformation technology. From this work, in association with Jean Bezivin who brought his knowledge about early work at OMG on MOF, was born Mia-Studio, a model transformation tool to develop and run model-to-model transformation rules and model-to-text generation templates.

With these tools, Sodifrance has progressively built a chain which can be used on architecture migration projects, to transform existing applications from client-server to n-tiers and SOA architectures.

This chain is composed of three main steps:

Extraction of a comprehensive model (the initial model) of the existing application from its assets (source code, configuration files, development repositories, etc).
Transformation of the model of the existing application into a comprehensive model of the target application (the target model).
Generation of the source code of the target application from the model of the target application.

To illustrate how this chain can be used, the chapter describes a project conducted by Sodifrance to migrate an application from VB6 to JEE for Amadeus Hospitality the leader in IT solutions provided for the tourism and travel industry.

The initial application, named RMS (Revenue Management System), was developed in VB6, and was performing queries on an Oracle database. It was composed of 300 screens, 200 of them displaying charts (pie charts, bar charts or line graphs). The VB6 code was composed of 306,000 source lines of code, VB6 code in 216 classes and 261 modules.

The migration project was completed by Sodifrance in 1,600 man-days with ten engineers over a year. The transformation of all the VB6 code (access to data, business rules and interface) was 80% automated, while the definition of the screens (Forms) was only 50% automated, due to the necessity to redesign them for a web mode. The new version of RMS is now composed of about 300,000 lines of code in 1,000 Java classes and 310 Jsp (Java Server Pages).

In the last part of the chapter, we present MoDisco, the Eclipse project dedicated to software modernization. This project has been created by AtlanMod during Modelplex, a research project funded by the European Community.

Because of the widely different nature and technological heterogeneity of legacy systems, there are several different ways to extract models from such systems. MoDisco proposes a generic and extensible metamodel-driven approach to model discovery. A basic framework, including implementations of OMG standards such as KDM or SMM, and a set of guidelines are provided to the Eclipse contributors to bring their own solutions to discover models in a variety of legacy systems.

One of the first industrial use cases using MoDisco has been the understanding of a Large Scale Data Intensive Geological system for WesternGeco, a geophysical services company

JEE, Flex and MDSD in Tunis

2010-04-10T01:45:00.000-07:00

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:

Defining a Profile in a UML Modeler
Developing a Domain-Specific Modeler
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.

Eclipse & OMG Symposium

2010-04-01T13:54:00.000-07:00

After Ottawa in 2008, the 2nd biannual symposium on Eclipse & OMG will held in June at Minneapolis. This symposium will be introduced by Kenn Hussey, the leader of the Eclipse MDT project which provides implementations and tools for standard metamodels. It is the opportunity to discuss about how OMG standards can be implemented on Eclipse, and how Eclipse can influence the definition of new standards.

With Hugo Bruneliere and Jordi Cabot of INRIA/AtlanMod team, I will present the Eclipse implementation of SMM (Structured Metrics Metamodel), one of the OMG standards supported by the MoDisco project. We will explain how this metamodel can be used to represent metrics computed from Java source code. And how it can help while developing Eclipse components, by measuring their compliance to Eclipse development best practices.

You can read three of my posts on this topic :

Talks on other standards will be given by people from University of Madrid, NASA (JPL), IBM, CEA, Model Driven Solutions, Ericsson, Intalio, RedHat, Obeo and Thales.

Back from EclipseCon 2010

2010-03-27T11:18:00.000-07:00

I came back to home today, after one week at Santa-Clara, near San-Francisco, attending my second EclipseCon.

Last year, I only presented a poster. But this year I gave a talk about MoDisco and I participated to the Modeling Project runway organized by Kenn Hussey. Gabriel Barbier, my colleague from Mia-Software, had also a talk with Henrik Lindberg about B3 and the possibility to use MoDisco to extract build information from source code .

Once again, I really enjoyed the conference and its organization: lots of interesting talks, very good keynotes (Steve Harris show was THE event of the week), but most of all it is the best way to share ideas, to meet people and to show what we working on.

This year, we spent a lot of time explaining a project we propose to create. The EMF Facet project will provide mechanisms to dynamically extend ECore models: adding properties, references, operations without changing the initial ECore model. These mechanisms have already been developped as part of the MoDisco project. We propose to externalize them to make them more reusable by other projects. We received very good feedback on this project from all the Modeling Project members to whom we presented our ideas and the existing components. We will first submit the proposal to the Modeling PMC next week.

Reverse-engineering of JUnit tests

2010-03-23T22:58:00.001-07:00

Tuesday I presented MoDisco during two EclipseCon sessions at Santa-Clara:

the Eclipse Modeling Project Runway, a five minutes commented screencast with nine other modeling project committers
the talk How to Deal With Your IT Legacy with Hugo Brunelière of INRIA-AtlanMod.

We decided this year to illustrate MoDisco with a example based on JUnit :

reverse-engineering of source code containing JUnit tests (we took draw2d as a sample)
creation of a fine-grained EMF model describing the source code
definition of an extension (Facet) to find the JUnit Test suites, Test cases and Tests contained within the code

colorization (UICustom) of the packages, classes and methods to be tested, depending on how many tests are defined for them

transformation of the EMF model and regeneration of the source code to migrate from JUnit3 to JUnit4

The slides are available here.

I will blog soon to give more details about this JUnit use-case.

MoDisco 0.8M5 available for download

2010-02-02T07:17:00.000-08:00

Version 0.8M5 of MoDisco, has been released yesterday : http://www.eclipse.org/gmt/modisco/downloads/

It already embeds the components which will be available in the final 0.8 version running with Helios.

Today I would like to focus on two new components (Query Manager and Facet Manager) and how they are used by the new version of the Model Browser to allow defining custom (and dynamic) viewpoints on your EMF models.

These mechanisms have been developped to support understanding of complex models automatically created from legacy source code. But you can also use it on "classic" EMF models created manually with graphical tool such as Papyrus.

Query Manager (new)

This is a new component providing a facade to evaluate queries against an EMF model independently from the query mechanism. Implementations are provided to call queries written in Java, EMFQuery, OCL and XPath.

A QuerySet containing OCL and Java queries

See : http://wiki.eclipse.org/MoDisco/Components/QueryManager

Facet Manager (new)

This new component provides a mechanism to dynamically extend EMF model elements by adding "virtual" attributes and relations computed by queries.

See : http://wiki.eclipse.org/MoDisco/Components/FacetManager

ModelBrowser

The look & feel has been reviewed to be more compliant with Eclipse UI checklist.

With the new version it is possible to dynamically customize how the EMF model elements are displayed. Any customizable feature (label, color, icon, police, ...) can be set statically, or dynamically using a Query executed on each element to display.

Wizard to customize the Browser for a given metamodel

You can also execute a Query against a model element directly from the browser

Selection of a model element from the Browser

Selection of Query to execute on the selected element

Result of the Query displayed in a table

If you want the Query to be always executed on each element of the same type, you can define a Facet to see the Query as a virtual type, attribute or relation in the browser.

The Query "subClassifiers" visible as a "virtual" relation on Class

See : http://wiki.eclipse.org/MoDisco/Components/ModelBrowser

How to create an EMF model from a Java application ?

2010-01-29T02:28:00.000-08:00

Is it possible to reuse EMF-based tools with Java source code ? Yes if you have your Java source code translated into an EMF model.

This is the aim of the Java component provided by MoDisco. This component is composed of a ECore definition of a java application and a discoverer which creates EMF models from an EClipse project containing Java source code.

The ECore definition declares all the concepts of the Java language : Package, ClassDeclaration, MethodDeclaration, Parameters, VariableDeclaration, IfStatement, Assignment, CastExpression, LineComment, ...

To create an EMF model using this metamodel, select your project and right-click on the menu "MoDisco>Discover Java model from Java project...". A wizard appears to select the analysis options :

You can extend the analysis to dependencies (the JAR used by the project).
You can use an incremental mode if you need to optimize the memory usage
You can limit the analysis to declaration members if you don't need a model of the instructions contained within the methods
You can use a filter to exclude Java classes during the analysis

The result is an EMF model which can be opened with the EMF reflexive editor or with the MoDisco generic browser. This browser allows accessing directly to instances of a specific class (for example all the MethodDeclarations) and navigating through all the references (composed or not).

This model can be used with other EMF-based tools to check architectural or coding norms, to generate other models (UML or Domain-Specific) or to regenerate an other application (if you modify the Java model, MoDisco provides templates to regenerate Java source code).

EMF and SMM to export code metrics to Sonar and Squale

2009-11-30T01:21:00.000-08:00

How to facilitate the integration between code quality measurement tools and code quality reporting tools ?

This is the problem we are faced with at Mia-Software: to address modernization projects, we have developped a lot of parsers creating models of code from which we can compute quality metrics (from COBOL, Natural or VB6 to Smalltalk, C# or Java). But as our customers are interested in getting these metrics in the quality report tool of their choice, we don't want to multiply the development of adhoc bridges (one for each couple "metrics calculator" <-> "report tool")

To reduce the cost of bridging the tools, we chose SMM (Structured Metrics Metamodel) as a pivot. SMM is the OMG/ADM standard for defining metrics related to software and for representing their measurement on existing systems. Its reference EMF implementation can be found in MoDisco, the Eclipse Modeling project focused on discovering models from software assets.

The main classes defined by SMM are quite simple :
- Measure : the definition of an indicator (nb lines of code, cyclomatic complexity, …)
- Scope : the kind of elements on which the indicator can be measured
- Measurand : an element on which an indicator has been measured
- Measurement : the measured value of an indicator
- Observation : who ? how ? when ?
Then, for each measurement tool that we need to integrate with a report tool, we just have to create a SMM model describing the kind of metrics to exchange (instances of Measure and Scope) and a connector to translate the specific export format of the measurement tool to a SMM model containing the measured values (instances of Measurement, Measurand and Scope).

In parallel, we create one generator for each report tool to integrate with. This generator takes the SMM model defining the measures and generates :

• the files declaring the metrics within the report tool
• the files configuring the report tool to integrate the new kind of metrics
• the source code of the component which will import SMM models containing the measurements
At this time we have experimented this approach to import COBOL and VB6 metrics (calculated by Mia-Insight) into the quality report tools Sonar and Squale.

Screenshots : COBOL -> Sonar

Screenshots : COBOL -> Squale

Our conclusion is that SMM fits the need of integration between these kind of tools.

The next step will be the integration of XRadar (suggestions of other report tools are welcome ;-) ).

We also have to solve the problem of metrics aggregation. There are three possibilities :
- aggregation at measurement time
- aggregation in SMM model
- aggregation in report tool
We have already identified pros and cons for each alternative. Depending on the kind of aggregation to perform, experimentation will probabely give an answer !

Eclipse Summit Europe 2009

2009-10-31T05:41:00.001-07:00

This year was my first attending ESE, and it was worth it !

The talks on modeling were very interesting (Xtext, EMFQuery, Papyrus, ...) and it was nice to meet the guys directly involved in the projects we are interested in.

The Cloudsmith team, for example, to discuss how we could use MoDisco on the B3 project to analyse plugins and create models of builds. Or André Dietisheim about our tests with CDO to manage models of large Java applications created with MoDisco. Nice also to talk with Kenn, Ed, Ralph and many others.

I had the chance to talk during both the Modeling Symposium (Tuesday) and a session dedicated to MoDisco (Thursday).

With my colleague Gabriel Barbier of Mia-Software, who presented the demo Thursday, we shown how to create fine-grained models from Java source code (based on a Java.ecore metamodel), and how to navigate through this model with the model browser we have developped. We put the focus on the customization and the extensibility of this browser by using queries.

You can dynamically change the icon, color, font ... of the instances of your models (by defining a UICustomization, stored in a EMF model), or add "virtual" types (not originally defined in your Ecore metamodel) with "virtual" properties and references (by defining a RoleSet, also stored in a EMF model). The query mechanism that we provide is generic : it allows integrating queries written in Java, EMFQuery, OCL, XPath or ATL.

We presented the 0.8 version which is still under development (planned for the end of 2009). But thanks to Nicolas Bros who have put the releng in place, it is possible to download an integration build.

The demos are online :
- Demo during the Modeling Symposium
- Demo during the MoDisco short talk