• the new file wizard with the option to initialize it with an existing file content

• the search & replace smart completion to quickly transform the example to a real template we can apply on a model

• the "for" closing brace completion auto-magically find a coherent place

• "Refactor > Extract As Template..." to create a new template with the selected text

• "Source > As Protected Area..." to define a protected area where we can regenerate target files without losing any modification

• "Quickfix" when an operation call doesn't compile, you can create a new template or a new query that make the compilation work

• An Acceleo 2.6 module will become an Acceleo 3.0 project

• An Acceleo 2.6 template will become an Acceleo 3.0 module file

• An Acceleo 2.6 script will become an Acceleo 3.0 template block

Long time not posting here. I've had a lot of work and nothing really interesting to post. I just inform you that I will make a speech about Wisss during the Acceleo Day in Nantes, at L'école des Mines, next friday at 2:30 pm. More information at : http://2009.rmll.info/Eclipse-Acceleo-Day-Presentation,938.html http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay:Program

Currently I've not much time to work on Wisss :-( However, I will make a tiny dsl and generator to have a virtualhost file generated (independent from Wisss, which already generate a vhost). I've already done this with a shell script but it will be more powerful and easy to ...

• Acceleo Code Generation : Let's start with an Android example
• EEF you want sexy properties for EMF... [made with Acceleo 3.0]
• Diff, Merge and Patch your Models with Helios
• Eclipse SOA TLP: Lock, Stock and Barrel
• Painless (?) Metamodel Evolution
• GMF showcases for embedded, web and engineering designers
  

I'll be happy to see you there...

As you may know, we are working hard to publish the first EEF release.

Goulwen has already said that we are using the new Athena Common Build Infrastructure to build EEF.

That is almost done ( see the green balls ? ), but i achieve today the promotion of the nightly builds into the EMFT pages !



So know you can reach the last builds from here.

Thanks to the build team for the help !

UPDATE : You can now have access to the nightly update site here

Last week, we have delivered a prototype of an enterprise repository for a big french insurance company.

What's an enterprise repository?

An enterprise repository can create a multi-dimensionnal space involving all components of an information system. The implementation of such a tool is part of a governance policy on a large scale information system.

The figure above illustrates how a repository is used to align the IT vision on the Business dimension. This tool aggregates all the foundations of the Information System and can easily navigate to this logical view in order to study changes impacts, and define transformations and modernization plans, ...

In our case most of the information already existed, so we decided to create connectors to feed the repository. Existing information are generally collected from :

• Existing tools : in fact several tools are used to manage information system, but each tools are isolate. In example we have develop a connector to extract the content of MEGA Repository and add the capability to reference this content with other contents.
• Legacy systems : Database schemas, existing application (Cobol, Natural, Java,...)

Technically, we use the Eclipse Modeling technologies:

• EMF: to define metamodels
• CDO: to store and share our big model
• EEF: to provide editor and sexy properties views

So, A great opportunity for the Obeo Guys to contribute to the CDO project!

In fact, with Gonzague we developed a new feature, the "push mode" aka the local transaction support. We have carried out in collaboration with Eike, our CDO mentor

Some details about this feature:

In CDO, the publishing workflow in the repository is:

1. Open CDO editor
2. Add some changes
3. Save your editor
4. CDO sends changes in the repository

Our contribution introduces the concept of Local Transaction. It adds a step to this worflow:

1. Open CDO editor
2. Add some changes
3. Save your editor
4. CDO store all deltas in a local binary file
5. When the user invokes the "Push" action, CDO sends all changes in the repository.

With this feature, we can also restart eclipse, and restore your local changes later on a new session.

Special thanks for Gonzague and Eike for their works! (#298055,#298178,#298568,#297967,#298334)

The next step, is use GMF with Obeo Designer facilities to provide dedicated viewpoints for each kind of actors.

Obeo Agility is a proprietary product edited by Obeo. It's used for code migration. It parses legacy code into a model used for generating code for the targeted technology. We already parse and migrate millions of code lines from many languages (Cobol, Ada, PL1, ...). We finished a project for parsing 5 millions of code lines written in Natural. The goal for this project was not migrating the code, but automating code review. Reports are generated using... Acceleo.

This is the title of the tutorial I have just submitted for Eclipse Con 2010

Here is the description of the tutorial :

Acceleo is a pragmatic implementation of the OMG* standard for code generation called MTL*. Still in incubation state, we plan to have Acceleo graduate for the next Eclipse simultaneous release (Helios).

Being an expert at code generation or Acceleo is not necessary to get started on your first code generator : using the Acceleo editor and the powerful features it exposes (completion, syntax highlighting, on-the-fly compilation, quick outline, ...), it is very easy to get started once you understand the most basic principles.

This tutorial presents both the MTL language and the Acceleo Development Toolkit which is provided in the M2T project. Beginners will learn what code generation, M2T, and Acceleo are, as well as how to use them on a concrete case-study. Acceleo addicts will discover the new standard syntax, new functionalities and techniques. We will give you enough of the basics to create your own code generation for a specific target system. We have chosen the Android platform as a target to show that we can also use Acceleo for mobile software.

Here is the tutorial agenda :
- Acceleo : What's that new code generation engine?
- Create an Android prototype and its corresponding model
- Initialize your code generation project from the prototype
- Editing your code generation file to make the Android prototype run
- Launching your code generation on another model example
- Packaging as an eclipse plug-in and for standalone usage
- Create new Android applications in few clicks
- How to override a specific behavior in the target environment
- On the developper side : How to make your own extensions with Acceleo?

We'll end the tutorial with other complex code generation examples made with Acceleo : EEF, UML to Java, Ecore to python, Migrating from a language to another...

*OMG : Object Management Group
*MTL : Model to Text Language

Remember my previous Tip ?


Again, this one is about differences between OCL and Java.

This one is about the fix that will permit to use the string.index(string). service.

According to https://bugs.eclipse.org/bugs/show_bug.cgi?id=296486, this service will use the OCL mechanism in the next version.

So if you used that service, don't forget to migrate your templates !

I am now developing on the Eclipse Acceleo project. To get started I bring a feature form the old Acceleo project. I write a profiler for the new Acceleo. It's very similar to the old profiler.

As you can see the screen shot show many statistics about the module execution. By double clicking on an element you can open its definition.

In Eclipse world, each project has its own page describing some important informations for commiters or developers.

Take a look to the EMF summary page :
http://www.eclipse.org/projects/project_summary.php?projectid=modeling.emf

For EEF, this page is this one.

You can find here various links to help you to download the latest builds, download the PSF file, to know who are the commiters, and access to the web and wiki pages.

Next week, November 17th, come in Paris to see Eclipse Community and news of Eclipse projects.
I co-organise this event with Cedric Vidal , a very nice guy with lots of cool ideas on model driven and EMF, and we want to promote talks with live demos and few slides (I hate "slideware talks").
We success

Some very nice talks will be propose on Birt, XText, UI (with XWT and Wazaabi) and a "guess star" with an introduction of Mike Milinkovich (Executive Director of the Eclipse Fondation).


Jonathan Musset will talk about the new features of Eclipse Acceleo project. This demo has been shown at Eclipse Summit Europe and was very impressive by the quality of the template editor which is perhaps the best editor of Eclipse platform, just after JDT.




We will also make some demo of Obeo Designer, our Eclipse Modeling distribution with a new exciting tooling to create GMF designers without any Java code (during our demo, we will create from scratch a new nice designer).




Info on the Eclipse wiki page:
http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Paris

Register on http://eclipsedemocampparis09.eventbrite.com/
or directly with this form:

Hi all,

goulwen is just coming back from ESE and we are moving EEF forward :)

In response to David, i created a page in the wiki to explain briefly were to get the sources, using this PSF

We started a cvs branch to add some new functionality to EEF, too.
The current stable version resides in the v0.7.1_BRANCH.

We try and constantly improve the Acceleo template editor as much as we can so as to make it as intuitive as possible. I haven't posted anything here about the template editing, here is a brief recapitulation of the features we're supporting (apart from the basic functions inherited from the text editor such as search, incremental search, ...). Including the latests and in no particular order :

• Syntax highlighting

A classic for any self-respecting code editor, Acceleo provides highlighting for all module elements, though highlighting is minimal for OCL elements.

• Error detection

Once again, a classic for any editor which contents are compiled, interpreted, or in any way error-prone.

• Quick fix (ctrl+shift+1)

Not much accessible in terms of quick fixes yet, Acceleo only provides the possibility to create templates or queries corresponding to "not found" compilation errors.

• Completion (ctrl+space)

• Open declaration (ctrl+click ; F3)

Sorry, no fancy screenshot on this one, as I don't know how to make a meaningful one :p. Anyone familiar with Eclispe's Java editor knows this one; it basically allows you to find the declaration of any variable, type, operation, ... by a single click on its usage within the code. This allows navigation to and from other Acceleo templates, and to the metamodel when calling it on a metatype.

• Quick outline (ctrl+o)

This allows users to quickly assess the size of a given module, find a query or template defined in it and navigate to it through a few clicks. Note that this doesn't show as much information as the regular outline view, since it is only designed to outline the module's architecture.

• Search references (ctrl+shift+g)

Still needs some polishing to only find references in the accurate scope, yet this already allows users to find references to the selected variable or template.

• Code folding

Granted, a screenshot is somewhat cryptic for this feature if you do not already know what code folding is. Basically, blocks of code (in Acceleo, comments, templates and queries) can be folded so that they only take two lines. If you look carefully at the screenshot below, you'll notice the "+" on the left edge right to the line numbers "4" and "8" ... as well as the fact we're missing lines 5 and 9; well, those two templates are folded :p.

More features will be included in the editor as there's a bunch of cool features that can be added to simplify template editing; next are the refactoring facilities \o/.

today is a great day, the EEF project has been created !

You can see the proposal here : EEF

Another thing is that i am now with my colleagues ( goulwen, nathalie and patrick ) official commiter on eclipse !

i just need some time to do the paperwork :)

Hi all,

Welcome for everyone who follows planet eclipse.

Here you can find some informations about EEF, Acceleo and other related tools.

Up until now, Acceleo allowed you to define the encoding in which the module itself should be read in the form of a comment at the very beginning of the module :However, this only affects how Acceleo reads your template file; it will not affect how Acceleo generates files from this module. So if you want to generate an XML file, and this XML file needs be encoded in a specific encoding which is not you system's default, you're stuck :p. Or at least that was true until M2.

Let's take this basic module as an example :This simple module is entirely composed of static text; its only purpose is to generate an ant file that creates a zip from a directory in a directory named "échantillons"... yes, that's an "é". If This file is generated under windows, no problem : the default windows encoding is the same as ISO-8859-1 as far as the "é" is concerned. What if this file is generated by one of your coworker who happens to be working under linux? Here's what would be generated :
And that'd could be a tragedy if the error isn't seen before someone tries and run this ant build... and sees that you generated under something else that windows! Imagine all the chocolate needed to atone for that blasphemy! Acceleo now proposes a way to define once and for all the encoding that must be used to generate a given file, and all you need is a single parameter for the file block :Take note that this is not a behaviour described by the OMG MOFM2T specification (that sadly left all encoding issues aside). As suche this feature might change form in the future, monitor the related OMG issue if you're interested by this field.

Hi all,

Well, after some vacations, the EEF team is ready ! We have worked these last days to publish the first release of EEF, and we are close to the end !

More news soon :)

After a quick meal at the restaurant of the university and many discuss about Acceleo, it was time to start the second set of talks for this Acceleo Day.

The presentations in the afternoon were mostly dedicated to describe the work of the Acceleo team. However, the first talk was a feed back of Cedric Vidal from ProxiAD that showed how he coupled Acceleo and development of dedicated tooling to really improve the JEE development and in the same time keep simplicity in the generation modules. The simplicity of the module was garantee by adding the good part of data in the model. In the same time, the editing tools for the model muse be appropriated to keep the model creation easy for the users.

After the presentation of Cedric came François Gaudin from Makina Corpus which introduce the work he make for WISSS, the module that he lead in the Acceleo Module Farm. His talk describe the need and the goal of its module and he gave his point of view on the distribution of the informations between the generation module and the models.

This presentations finished, we made the second coffee break of the day.


The last part of the day was dedicated to the new version of Acceleo that we call Eclipse Acceleo. This version is the future of Acceleo so we had to introduce it during this day.
First, Cédric Brun (from Obeo) came to present the Eclipse Acceleo project, the history, the need and the goals. A description of the MTL standard and a point on the status of the project currently was made during this talk.



The last talk of the day was mine about the use of Eclipse Acceleo for the EEF project. But this, is another story that I will tell you in another post.

After my talk, Etienne gathered the people that made a presentation plus some people of the Acceleo Team. We made a general discussion about Acceleo and try to reply to question that are ofter made to the Acceleo team.



This discussion finished the First Eclipse Acceleo Day. This day was very interesting and exciting, the feedback of the community was very awesome and will hope that this event can be make the next year.

Thanks to all for this day, especially the main organizer of this event Freddy ...

The "Libre" Software Meeting (LSM/RMLL) took place last week in Nantes. The Wednesday, It was possible to assist to the first Eclipse Acceleo Day during this event.

For the first time, most of the Acceleo users where gathered to discuss about their experience and what do they expect for the next versions.

The morning was dedicated to the talk describing the use of Acceleo in industrials projects. After an introduction of the Acceleo Project (its history, its goals) by Etienne, the first talk was done by Erle Le gac from CapGemini.

He made a feedback on a software factory that he and his team built using Acceleo and Obeo Designer. He use this product to create a complete modeling/generating chain dedicated to improve the JEE development within CapGemini. He wanted to made a demonstration of this software factory but the demo effect associated with a live practical experiment of the murphy's law prevent him to finish his example.


Then it was the perfect moment for a coffee break :)

Once the quota of caffeine back to the normal. The next feedback could be done. There was Vincent Fady from Atos Origin who described the use of Acceleo in some projects of Atos and the deployement of them, Olivier Leal from Bull who explained the strategy of Bull to industrialize their development with Acceleo. Finally, Samuel Liard from the Orange Labs came to give a feedback of Orange in the use of MDA and the the way they integrate tools like Acceleo in their development process.




This introduction and these 4 talks done, it was time to feed our starving stomachs !

Je suis très heureux d'annonçer la sortie imminente de la nouvelle édition de "Spring par la pratique". La parution en librairie est prévu pour le 9 Juillet 2009 et la version ebook est d'ores et déjà disponible.

Un grand bravo à Thierry Templier, Arnaud Cogoluègnes et Julien Dubois qui ont fait un travail de titan sur cette nouvelle version. Vous y trouverez toutes les nouveautés de Spring 2.5 et Spring 3.0 ainsi que des nouveaux chapitres sur Spring Batch ou encore Spring DM.

J'ai eu l'occasion de participer modestement à cette aventure et de contribuer une annexe traitant de l'industrialisation des développements Spring dans Eclipse. Vous devez vous doutez que cette industrialisation est basée sur une approche dirigée par les modèles et utilise le générateur Acceleo

Cette nouvelle version atteignant pas moins de 680 pages, les annexes ne seront pas inclus dans l'édition. Mais elles seront bientôt disponibles pour tous en téléchargement sur le site dédié créé pour l'occasion : http://www.springparlapratique.org. La listes des annexes :

• Annexe A : SpringIDE
• Annexe B : Développement OSGi dans Eclipse
• Annexe C : Industrialisation des développements Spring dans Eclipse

Aussi, je profite de ce billet pour relayer l'annonçe de Freddy sur un événement à ne pas manquer "Eclipse Acceleo Day". La communauté Acceleo se retrouvera le 10 Juillet 2009 à Nantes. Cette événement se déroulera pendant les 10ème RMLL. Vous trouverez toutes les informations ainsi que le programme complet ici.

Inscrivez-vous vite, il ne reste que peu de temps avant la clôture des inscriptions !

Hi all,

In July, 7th to 11th 2009 will take place the 10th Libre Software Meeting in Nantes website.

During this major event, Goulwen will talk about how we use Acceleo for EEF. This talk will be performed during the first Acceleo Day, and will provide the first feedback of using Acceleo in a major project.

If you are interested in, please see the program here, and even come to Nantes to say hello !

[UPDATE] : The workshop is free but with mandatory registration (for organisation purposes). will take place on July 10, 2009. Registration details are available here: http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay


Cheers,

The first Eclipse Acceleo workshop will take place on July 10, 2009 in Nantes. More information available here: http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay
The complete program is now available with a lot of interesting talks dealing with Eclipse, MDE, DSM and of course Acceleo ;-)

Hour	Title	Presenter	Affiliation	Language
09:00	Introduction	Etienne Juliot	OBEO	English
09:30	Presentation of a DSM-oriented design and generation environment	Erlé Le Gac	Capgemini	French
10:00	MDA & Acceleo deployment feedbacks	Vincent Fady	Atos Origin	French
10:30	Coffee break
11:00	Acceleo, contribution to the industrialization of developments: Feedback from Bull-Centre de Services Paris	Olivier Leal	Bull	French
11:45	An Open-source Model Driven software development toolset - Lesson learned from Orange Labs	Samuel Liard	Orange Labs	French
12:15	Lunch
14:00	MDSD Scaffolding and Acceleo	Cédric Vidal	Proxiad	English
14:30	Presentation of WISSS (Webapp Is Simple, Stupid and Secure)	François Gaudin	Makina Corpus	English
15:00	Acceleo MTL: a standard alternative for code generation	Cédric Brun	OBEO	English
15:45	Coffee break
16:15	EEF powered by Acceleo MTL - Acceleo MTL ... and punishment!	Goulwen Le Fur	OBEO	English
17:00	Panel

This workshop is free but with mandatory registration (for organisation purposes). Registration details are available here: http://www.acceleo.org/wiki/index.php/EclipseAcceleoDay

Hope to see you there :-)

Eclipse Acceleo Day will take place on July 10, 2009 in Nantes. This workshop is dedicated to Acceleo and associated technologies. All information for attending and participating are available here: Eclipse Acceleo Day.

The workshop fees have been lowed to their minimum: this is a free workshop ;), but mandatory registration (for organisation purposes). This workshop is co-located with the 10th Libre Software Meeting (http://2009.rmll.info/?lang=en).

The workshop will be an occasion for some members of Acceleo community to meet and to exchange ideas. This meeting will also be an opportunity to present some of the planned extensions to this tool and discuss MDE related subjects.

If you want to participate and/or attend, don't hesitate to contact me by email.

Scope

Acceleo (http://www.acceleo.org) is an Eclipse-based toolkit for code generation, with a model based approach. Code generation is the technique of using or writing programs that write source code. Code generators are tools built to serve engineers in the automatic creation of applications. Acceleo is a free software, its development is totally open.

Topics of Interest

• New Eclipse Acceleo project (http://www.eclipse.org/modeling/m2t/?project=acceleo)
• MOF-to-Text Language
• Validation with Acceleo
• Documentation generation
• Scripting generation (PHP, Python, Ruby, ...)
• Link with M2M transformations (ATL and others)
• Comparison with other generative engines
• Integration of Acceleo in a industrial tool chain
• Presentation of existing modules ("ready-to-use" generators)

Talks

Most of the talks will be 20-30 minutes long. Participants are welcome to propose a short talk presenting their project of their experience with Acceleo. Working languages are english and french. All slides and documents will be in english. Demos would be greatly appreciated :-)

Important Dates

• Registration: July 3rd, 2009 (Even if attendance is free, registration is mandatory for organisation purposes)
• Workshop Date : July 10th, 2009

Last month I explained how to tune Acceleo standalone engine threading. But services were still running in mutual exclusion because historically services didn't need to be thread safe. The result was a performance loss.
Services of a given service class couldn't run in parallel by default. It means threads will have to wait for other threads to run services. I noticed that a lot of service classes are thread safe, they don't use field or static references.

But as I can't decide if a service class is thread safe or not for you, I added an interface that bypass the mutual exclusion zone for a given service class. It allows multi threads to run services of a service class. This interface is IThreadSafeService. It declares nothing, so you just have to add the implements clause as following:

public MyServices implements IThreadSafeService {
...
}

But be aware, if you use this interface and your service class is not thread safe it can lead to random boggus behavior. And it can be difficult to find out what is the root cause of your troubles.

As you may know, EEF uses the Acceleo as generator engine.

if you look at the org.eclipse.emf.eef.codegen plugin, you will see the templates used to generate the source code.

For the first tip on Acceleo, i will just point something about the difference between OCL ( used by Acceleo ) and Java.

If you would like to use the substring(int, int) service, you must know that in OCL, the first character is located at position 1, rather than in position 0 in Java.

So, if you would like to get the first char in Acceleo, you must use that code :
string.substring(1,1).

This morning, i receive this email :
"

Stephane Bouchet,
This automatically generated message welcomes you to full Committer status
on the modeling.eef project!
"

So, this is now official, i am a new Eclipse commiter.
Very soon, we will post the first shot of EEF sourcecode in the source repository, and begin the first builds !

One of the main features of the standalone Acceleo engine is to provide multi-thread support. This allows us to divide the code generation time according to the count of available processors, effectively cutting the generation in half on some machines. To share the work between threads, the input model is divided into groups of objects; each group is then queued till a thread can process it.

There are two parameters to tweak the multi-threaded generation. The first one is the number of threads to run simultaneously, the default value being the number of available processors plus one. This allows us to use all available processors, the one supplementary thread used to cover synchronization waiting time. While some threads are waiting for another one, one processor is free to run the thread which was waiting for an idle processor.

The second parameter is the number of objects per group, the default being 20 objects per group. This parameter is very important since its allows you to find the optimum between load sharing and thread management overhead. Your objects groups will not be processed using the same amount of time. So Imaging you divided your model into two groups by setting number of objects in the model divided by 2. The group which runs faster will have to wait for the slower group at the end of the generation. In this case you are losing time. On the oposite you can put a single object per group. This way you minimize the loss of time at the genretation end. But threads will spend more time peeking groups in the queue since there are much more groups.

To set thoses parameters have a look at :
- Extension.setThreadsNumber(int)
- Extension.setEObjectsPerThread(int)

We arrived with Cedric Friday night in Silicon Valley. Flight trip was an opportunity to try SWTBot and look at current GEF Support.

Saturday morning we decided to see the Googleplex. It was not as easy to find as we originally thought, I mean without looking on google maps or taking the address before :P

At least we found one of their office



as well as their own street



and their famous google cars



On the afternoon we went to San Francisco downtown to enjoy the city and do some shopping. Apple store was an occasion to admire their laptops and ask a seller some facts to convince our Boss that our productivity will increase with them :)

On Sunday we went to Berkeley university, where we met sociable squirrels !



First day of EclipseCon was a lot of fun. There seems to be less people than last year but people are still friendly and enthusiasts.

At morning I attended Ketan great SWTBot tutorial, which was successful as room was filled to the brim.

At the end of afternoon Acceleo "Best Open Source Eclipse-Based Developer Tool" award was the pleasantly surprise. Thanks for the community for this great recognition of our work at Obeo !

Despite economic crisis, Google renews its awesome summer of code program in 2009.



Cédric and Ian already blogged about it, but it is now official for Eclipse , we have been accepted as mentoring organization.

Students, Eclipse is a great open-source organization with various projects, have a look at the current ideas page !

I will present more in detail "Acceleo and ATL combine" proposal.

Eclipse Acceleo (previously named MTL) project provides an implementation and a development toolkit for the OMG MOF Model to Text Language.

Eclipse ATL project provides an implementation and a development toolkit for the ATLAS Transformation language.

Project idea is to work on combination of this 2 powerful technologies. On Acceleo side, it means being able in a template to call a model-to-model (m2m) transformation, for instance to improve readeability of a template. On ATL side, it means being able in a transformation to "serialize" model information, for instance to do some reporting.

Implementation should be made without high coupling between ATL and Acceleo as far as possible, in order to support in future other m2m languages, such as OMG QVT.

Hope you will find it interesting !

There is a new feature in Acceleo 2.5. This feature allows users to profile the generation process of Acceleo. To activate the profiling you should check the profiling checkbox in the launch configuration of the chain.

The result of the profiling session is saved as a model, it's very useful for performance comparison (using EMF Compare) or report creation in batch environment (using Acceleo :) ).

Basicaly the model is the execution tree of Acceleo, each node being a step of the generation process. Those nodes give statistics like the time spent in the node and its subtree, the percentage of time it represents, and the number of times the element have been run by Acceleo. You can also find the list of EObjects for each node in the outline.

The model can be sorted by chronogical order or by the time spent as shown on the screenshot. It can help in the understanding of the generation process and finding the hotspot(s). Once this hotspot is found you can open the template editor on this element by double clicking it.

I am sure this will help to optimize your Acceleo templates.

This blog will be dedicated to my development works at Obeo. My aim is to provide useful information on products and features I am working on. This information can be technical tricks for developers or general purpose information.

Coming soon, the ability of profiling the text generation process of Acceleo...

Acceleo project has been nominated for the Eclipse Award in the category "Best Open Source Eclipse-Based Developer Tool".
I really think Acceleo can win because it proposes some nice Eclipse tooling, but also because it proves a real community of users and contributors with an open development process.

Last year, it was EclEmma which won.

Papyrus, one of the best OpenSource UML modeleur on the Eclipse platform has been released.

http://www.papyrusuml.org/

Papyrus includes a new killer feature : Java code generation from UML models.

And which generative engine does they choose ? Yeah ! Acceleo.

Obeo has joigned Papyrus community to help them to create this Java generator.
Of course, this generator is under EPL license.

Acceleo 2.0RC2 has been used, with some specific integration plugins like this one (for the Run... menu) :

OMG has defined the MDA term.

But now, what a jungle !
Let's see some very simple definitions.

MDE
- Model Driven Engineering
- definition : all the process of creating softwares with a model driven approach.
- examples : it includes some metamodel based analysis, how to manage teams with MDA,
which steps are required to create a real model based software factory, ...

MDA
- Model Driven Architecture
- definition : the technical choice of tool and metamodel for all the creation of a new software
- examples : transformation models engines, separation and links between PIM/CIM/and others

MDSD
- Model Driven Software Development (also call MDD : Model Driven Development)
- definition : metamodel based tools and process for development step
- examples : source code generation (like Acceleo), PSM model based editor

DSM
- Domain Specific Modeling (and DSL : Domain Specific Language)
- definition : metamodel based modelers to design specific and semantical models
- examples : GMF based modelers, Workflow modelers, Wysiwig model based modelers

ADM
- Architecture Driven Modernization
- definition : modernize existing software with a metamodel approach
- examples : reverse engineering systems, recasting engine (like Agility)

Of course, let's do a metamodel of theses model driven definitions :

ATL v2 will be release very soon.
ATL is a model transformation engine based on MDA standard and Eclipse platform.
It can used for:
- interoperability between tools
- translate a model from a notation to another (for example: relational to uml)
- propose "different zooms" on a model (for example: global specification -> detailled specification -> global design -> ...)
- create any kind of bridge (for example: BPMN -> BPEL or BPMN -> SCA)

ATL 2 is provide some new exciting features:
- better completion on model elements
- virtual machin based on EMF
- better performance
- lots of bug fixes
- a clean updatesite
- integration inside Ganymede (Eclipse 3.4)
- and a new commercial support on http://www.atl-pro.com


See News and Noteworthy for more detail on ATL 2.

For Acceleo v2.0 and launching of Acceleo Modules Farm, Obeo will release with an OpenSource license one of its commercial modules : UML2Hibernate.

I have create this module. It uses UML 2.1 models (class diagram with stereotype > >) and generates :

- DAO layer
- Entity objects
- HBM mapping
- SQL tables (3NF)
- JUnit tests
- Hibernate v3 compatible Design Patterns

It manages lots of associations :
- inheritance
- 1-1
- 1-*
- *-*
- recursive associations
- unidirectionnal and bidirectionnal associations
- ...

It will be available before the end of may. I hope you will enjoy it, and you will contribue to improve its features.
Here is the link where this module will be available : http://www.acceleo.org/pages/modules-repository/

Hi,

I just work on some new icons for Eclipse SCA project.
I need some comments to choose which one need to be removed or changed.

On my point of view, it will be nicer than the v1.0 version because it will better fit Eclipse UI and icons style.

New global palette:

SCA Bindings:

SCA Implementations:

SCA Interfaces:


The new tree Editor:
The graphical Designer isn't ready because it uses old style for embedded icons.
For comment, you can use this bug report.

Eclipse Ganymede has just been released.

Here are list of new features of modeling projects:

• EMF 2.4
• EMF Query, Transaction, Validation 1.2
• Teneo 1.0
• CDO 1.0
• Net4j 1.0
• EMF Compare 0.8
• Ecore Tools 0.8

• GMF 2.1
• MDT 1.1 (OCL, EODM, UML2, XSD)

• ATL 2.0

There are other projects (like Jet, QVT-O, ...) but there haven't a News and Noteworthy page.

After one year of work, Eclipse SCA 1.0 is ready.

This is a new project of Eclipse STP (Soa Tool Platform) for assembly of SOA applications.
To understand the goal of SCA standard (Service Component Architecture, available here), the easiest way is to use an example:
you have one GUI component (for exemple, C# based) named "A" and it need to communicate with one business component "B" write EJB and Java and with another external component "C" written in PHP and only accessible with WebService. With SCA, you just need to declare each component, a reference (required interface) on A (declare with C# interface), and two services on B and C.
The SCA server will automaticly translate protocols and API language to ensure everybody can communicate with everybody.
In a nutshell, SCA isn't a new middleware (it rely on existing middlewares or libraries). It's like Spring, but as a specification and for any protocols and languages.


The main feature of Eclipse SCA project is a nice designer. It's used color and shape very similar of official specification and it's based on GMF. I'm one of the commiters team of this project and the leader is Stephane Drapeau.

It will be bundle inside Ganymede (Eclipse 3.4).
You can test it and read this nice tutorial.

I have work some hours on a simple plone2.5 code generator with Acceleo. It is available on the acceleo svn: svn checkout svn://svn.forge.objectweb.org/svnroot/acceleo/trunk/modules/community/uml21/zope/plone/25/org.acceleo.module.pim.uml21.plone25/trunk This code generator is not finished, but the way of doing is good enought to start the plone3 one. I would like here to explain the purpose of the Acceleo Generator for Plone3 i [...]

Today i attended to a conference about Alfresco and MDA by BlueXML. What i have discovered is a set of softwares done with Eclipse and Acceleo to generate an Alfresco project (configure the portal, make content types, …). I have been really interested in the fact they have done a new meta model derivated from [...]

The second one (Part 2) consists in creating Acceleo services.

This solution provides additionnal functionalities in relation to the first one. Indeed, as the rules are written in Java language, you can decide that a specific rule won't overload a generic one for example...

I've created a "ValidatorServices" class which implements a mechanism to validate a model and get the report from templates, thanks to the services that it provides. The end-user has just to extend this one and to implement the "checkRules" abstract protected method in order to define his own rules.
He can use "validate", "isErrorChecking" or "isWarningChecking" services to validate his model.

But the main new feature consists in giving the possibility to use the result of the validation report and to act on the generation or not. Let's interest by this feature:

The "isErrorChecking" and "isWarningChecking" are able to notify if an error/warning at least has been detected. So, "isErrorChecking" may be used for example to forbid the generation if it returns true.

The "ValidatorServices" class manages a "singleton" behaviour in order to have only one validation launch per generation and to optimize the process.
Moreover, it manages a workaround about Acceleo architecture limitation on the instanciating of custom services between templates...

Indeed, the services don't share the same context between each template. So, let's take an example with two templates where each of them generates a file. We knows that the generation depends on the "file" parameter. Consequently, it's in this place that you have to use "isExistingError" if you want to control the generation. Not to have as many validation launches as templates which generate files, it is required to keep report in memory. To do that, the "ValidatorServices" retrieve data from a temporary file, in the temporary directory of the OS (Java environment variable). You can use a custom action to delete this file (clean data context) at the end of the generation process.
IsXXXChecking use temporary file only if it is called in different templates which generate files.

See the demo:


The main benefit of this way is to be able to cancel the generation if the validation process has thrown errors or warnings... according to your rules.
Then, it provides a flexibility for the use of the validation mechanism (priority of rules, control generation...) thanks to the Java language. So, applying a rule on a "super" meta-class and an other one on a "child" meta-class, you can decide to display the both respective messages if these rules are not checked (and not only the "child" one).

The concern is the technical heaviness of the solution which might be managed, in a more transparent way, by the acceleo core.
Then, the use of Java language involves a loss of the Acceleo features (debugging, traceability...).

With Acceleo, you can define your own functional validation rules on a model and log messages according to them, during code generation.

I suggest different ways to define the validation rules.

The first one (Part 1) consists in creating a simple Acceleo template where each script defines a set of rules to check on a particular meta-class of the meta-model.

I've created basic java services to log messages with different severities. These messages take as parameter the condition to check (a boolean) and the text to display if this one is false.

We knows that a script may be called if the « file » parameter is setted or if an other script calls it. We also knows that this parameter is used to decide to generate or not the code and to specify where it has to be generated.
In our specific case, we want to activate rules sets without generating code. So, each script owns a « file » parameter which is a call script returning nothing and which gets the particularity to call back the right script to run the rules to apply.

You can see a demo with an example of a template in order to validate a State Machine UML2 model:


The benefit of this way is really the easiness to define the rules thanks to Acceleo Language.
The generic rules (in this example, on the « Named Elements ») apply only on the objects not concerned by a specific rule (inheriting concept).

The only concern is about using the result of the validation to decide to generate or not, for example. Here, it's not simple to do that because, in a chain, every templates which are called are not able to directly communicate between them.

As a proof of concept, we create an Acceleo generator for UML2 Statechart diagram.
This generator has been made as a TopCased work (to be include, I hope, as a built-in TopCased generator).

Here is a nice flash demo: http://www.obeo.fr/download/transfert/capture1.htm

The source code generated uses Smuc framework, but it will be easy to target any standard technology (like C, Java, ...).
Thanks to Cedric Notot for all his work on this generator and who experiment new strategies for models validation with Acceleo.

I will start this blog by debating on differences between MDA (Model Driven Architecture) en MDSD (Model Driven Software Development) approaches. One could see MDSD as a deprecated version of the standard MDA. But another will see that MDSD has a wider scope than MDA. So I will try to explain what MDSD embraces and what's it is useful for.

First, let's compare what we've got on both sides. For MDA :

• Standardized by the OMG since 1999

• Based on XMI, MOC, OCL, UML...

• Aims at automating all transformations between models to code, suppressing the coding part

• Driven by the Y cycle and CIMs, PIMs, PSMs and PDMs

• Tries to define standard meta-models shared across industry domains

For MDSD :

• Based on the ideas brought by MDA

• Not bound to its standards : can be any meta-model like DSLs, not only UML and profiles

• Try to promote customized DSLs answering to each need, not assuming that every body will have the same needs on a given domain

• Use models as abstraction and still leave a place for development tasks

• Defines its own ideas of PIMs and PDMs depending on projects or needs contexts

From the use I can see in my job,the MDA standard is more something made for the big players in the industry, whereas MDSD is a more flexible approach that can be used by a larger group of users, less attached to standards and with smaller scale needs.

To conclude, I will just say that MDSD is a pragmatic way of using MDA concepts. With the new wave of tools such as Eclipse, EMF, GMF, Acceleo..., you can use these kind of approaches on large scale projects and I would recommend anyone to have a deep look into it as it really helps to cut down software development costs !

And the quickest way to do that is to try it using Acceleo I think !

Have you ever see EMF with Rhapsody ?

Let's see : http://www.rhapsody.com/emf

Is that you, Ed, with the black tee shirt ?
Very good :)

Students : stop to think you NEED to be a project chief to be someone !

I see lots of young IT engineers, who just come out from their high schools, and want to manage projects. Oh yeah, Excel, MS Project should be very exciting !

NO ! You can have a very good job and a very good carrier with some technical skills. IT is complex, and architecture is not easy for everybody. It's fun, there are some evolution every day, and companies needs some very good people to understand and create good architectural designs.

IT architecture is one the more interesting job I even see.

Planet Acceleo is online.
My blog is aggregated inside this planet.

http://planet.acceleo.org

Acceleo (http://www.acceleo.org) is a very impressive code generator.
I work on it since 2005 (v0.0.1 !!).

Acceleo v1.0 was born in 2006/04/01, with many features and a very good EMF and Eclipse integration.

Acceleo v2.0 will be the major evolution of Acceleo with 2 main features :
- modules generator can be deployed as real plugins
- open source modules farm


Acceleo v2.0 should be release on may 2007.

After an unsuccess try of creating my blog, I think this time will be the good one.
As you see, I decide to speak english.... Or try to speak english !

I will speak about :
- MDA
- IT Architecture
- Acceleo
- DSM

Voici une URL qui cause de Mozilla 2 :
http://weblogs.mozillazine.org/roadmap/archives/005689.html

On y apprend par exemple :
- python supporté dans les pages web
- javascript 2.0
- début de support d'XForms (coool)
- SVG supporté (pour moi, la plus grosse nouveauté)
- XUL 2 (et standardisé)
- xulrunner
- bien sur, utilisation de Firefox, Thunderbird, Sunbird et Nvu.

Il y a maintenant 1 an 1/2, j'ai acheté le nom de domaine javafr.org et j'ai commencé une maquette avec Spip pour créer un site de news dy style a19s.com ou linuxfr.org, sur Java.
Je l'avais fait hébergé par tuxfamily, mais l'histoire a voulu que tuxfamily ferme ses portes.

Depuis, je n'ai pas trouvé le temps de m'y remettre. La backend est prêt (merci spip), il reste encore le squelette des pages web à mettre au point (CSS à gogo). Il faut aussi que je remette en place la redirection DNS. En fait, j'espère qu'en maintenant ce blog, ca me donnera le courage de m'y remettre.

Si quelqu'un d'autre est partant pour l'aventure, qu'il me contacte. C'est bien plus motivant à plusieurs.

Je suis en train de me former aux conteneurs légers. Ca semble être un sacré changement de mentalité par rappot aux EJBs.

J'aimerai pouvoir une chaine complète modélisation des besoins -> modélisation UML -> génération code -> plugins Eclipse d'aide au dév -> résultat.
J'ai essayé :
- EMF : cela semble surtout dédié à servir de base à d'autres outils (enfin pour l'instant).
- Middlegen : partir de la base pour modéliser le métier, c'est pas trop mon truc (je préfère faire de l'orienté objet qui se mappe dans une BD plutot que l'inverse)
- XDoclet : j'aime pas trop le mélange induit par l'ajout en javadoc de tag de déploiement. Je préfère garder le Java propre. (mais je n'y suis pas fermé pour autant)

Pour les frameworks, je vais essayer :
- hibernate
- spring
- struts / jsf

Pourquoi ces choix ? Et bien parce que les EJB3 semblent prendre cette voie. Donc, autant anticipé !!

Rendez vous d'ici quelques jours (j'espère) pour mes premières impressions.

Et voici mon premier post sur mon tout nouveau Blog.
Je te souhaite bon anniversaire, pour tes 5 premières minutes !!

Je ne suis pas encore très sûr de l'utilisation que je vais en faire. J'y parlerai sûrement technique et informatique, mais ptet aussi sur des sujets annexes (comme un peu tous les blogs qu'on peut trouver sur le web).

Wait and see ... et longue vie à juliot.blogspot.com !!