The next-gen Acceleo has differences with the Acceleo.org one, especially the new syntax based on the MTL OMG standard.

Here is a demonstration of the first version of the wizard that will help you to migrate from the old syntax to the new one.

We are actually working on that. The final tooling will be available on June 2010.

Don't hesitate to track a new bug on the following page if an equivalence is not yet implemented : https://bugs.eclipse.org/bugs/enter_bug.cgi?product=M2T

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 :-)

Acceleo 2.6.0 is compatible with all the Eclipse releases of the last 4 years, named Eclipse Galileo (June 2009), Eclipse Ganymede (June 2008), Eclipse Europa (June 2007) and Eclipse Callisto (June 2006).

Acceleo.org was created 4 years ago, and as the time goes, the Team has been more and more convinced that the MOF Model To Text OMG specification was the way to go for the project. We started to code a reference implementation for the standard within the Eclipse M2T project. We have managed to provide nice tooling, simple syntax and efficient code generation with all the pragmatism we had about Acceleo.org. There aren't a lot of differences between the old version of acceleo and the new one.

We are confident that the Acceleo community gain value from moving to a self hosted project to an Eclipse one, and that end users will follow the transfert from Acceleo.org to Eclipse.org as we will provide the same level of functionnalities and we will insure an interoperability between the old syntax and the new syntax (the standard one).

The Acceleo Team will continue to maintain the old syntax of Acceleo outside of eclipse (www.acceleo.org ) during some few years, but the new versions and the new features will take place on Eclipse.org. In the next release you'll have an automated tooling helping you to migrate your templates from a syntax to another.

For Acceleo lover, you will find in Eclipse Acceleo everything you have loved in the Acceleo.org version and more (the standard compliance with more documentation). This specification is really a good one: http://www.omg.org/spec/MOFM2T/1.0/

At the moment, those who need a perfect stability must continue to use the Acceleo.org version (2.6). As time goes on, Eclipse Acceleo is better and better and you can already have a try right now (0.8). That said, we still need some few month to get the same stability level between our current stable version and the new one. The next generation Acceleo will be ready for the next Eclipse simultaneous release (Helios).

If you're a friend you can download the Galileo packages. The modeling one is here !


Please notice the great "What's New" page with live content :

Yes, If you're interested in software engineering, If you think "modeling is crap" and you're looking for nice pragmatic tools focused on making things easier, come and join us during the Libre Software Meeting at Nantes the July 10th for the Eclipse Acceleo Day !

Eclipse Galileo aka 3.5 simultaneous release is coming soon. We now all have this fuzzy feeling when development stops and we stay here a bit dizzy, wondering what we'll do next.

Yet another release, yet another step in the direction of the best IDE, of the best Platform, of the best Modeling tooling or whatever goal you have. The eco-system is so diverse, every new release can't be reviewed as whole, you can only savour "just a bite of this big cake".

Even if I'm quite sensitive to all the good stuffs added in the platform: as a plugin developper these features makes me happy everyday, I'm gonna focus on only *some* features of the modeling package for Galileo...

Each year a few more modeling projects are joining the team for the simultaneous release, you're now getting a full-fledge modeling environment for Galileo.

Let's design stuffs, that's what models are bout, right ? Thanks to EcoreTools, you now have a nice modeler for your domain models. I only want to say one thing: the sexyfication of this modeler is great :) You now have nice gradients, shadows, and many views bringing you stuffs you're used to in the Java tooling : Class hierarchy, Show references and so on..


Definitily worth trying !

If you design your models with a team, you'll be happy to see EMF Compare when you want to merge your changes with those made by your coworkers
Compare graduated and has now the 1.0 stamp ! It's seamlessly integrated with CVS, SVN, GIT and can diff and merge any kind of models.

Speaking about design, xText allows you to design your models using a textual syntax, that's pretty cool and the team worked hard this year, check it out !

Once you design your stuffs, most of the time you want to transform that into something you can use for your development. There are basically two options here : model to model transformation or model to text transformation. Each one having pros and cons depending on your use case.

Eclipse Galileo provides pretty much anything you might want to transform your models, some of them being based on standards :

• Model To Text (aka code generation) :

JET have been here for quite a long time now providing a steady and stable code generation technology.

XPand and Acceleo joined the release train this year providing template langages with great tooling, debug mode, full featured editors...

• Model To Model :

QVT Operational and ATL competes in the model to model area.

Work on ATL has been focused on user interface and API, that means ATL is now easier to use from both an end-user point of view and developer point of view.

I looooove the new wizards compared to the old one :)


Acceleo is a complete rewrite from the Acceleo 2.x versions which made our team "Eclipse Award Winners". One of the thing which is cool with this rewrite is that from the beginning we're making sure the core generator is "standalone" and might be used without Eclipse, something we had a hard time to provide a posteriori with Acceleo 2.X . Another common need is the ability to easily launch your generation from your java code, it's most of the time quite tricky when you use your own language.

The Acceleo team came with a nice solution : next to every "main-like" template we generate a Java class which is this template API. Then you can easily launch the generation, you just have to create an instance of this java class and launch it.

Here is a small and dumb template :

And here is the corresponding Java launcher :

Kicking your generation is just a class instantiation and a call to the doGenerate( method ! You have no excuse for not integrating your code generation into your editor.

In a nutshell Galileo bring the best of modeling with pragmatic components, you can't miss that !

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

This post follows those showing how it's possible to leverage EMF and JBoss Drools to get an interactive model getting updated considering business rules, and how you can get a set of graphical modelers to ease your design tasks and provide feedback while you're building your system.

Now let's focus on providing "the right feedback at the right time". When you're designing a system, you're trying to reach the following goal : building it nicely and making sure it fits your requirements and contraints. You're always balancing between different concerns, your system simplicity, agility, performances, safety ...

Having a good tooling for that is more than important, and the tooling failed since now : it's always providing many more information or possible actions than what you actually need and not what's your focus right now.

Here comes the viewpoints (IEEE) , viewpoints enabled tooling is able to extends, hide, or provide new representations and actions depending on what you want to consider. As building a system is always a trade-off between multiples criteria, you don't want to be overwhelmed with all the constraints feedback, you just want to see relevant information and be able to do relevant actions. The concept is quite similar to the Eclipse perspectives.

The first demo (a few minutes) provides an overview of the tooling specification model we started in the last post. It's been completed with a few more representations, validation rules, and, more important, re-organized in term of viewpoints.


The following demo (6 minutes) shows the usage of such a tooling, using (again) the simple "Flow" example.



Eclipse is great as a platform and enables you to build great tooling to that your users stay focused on their business issues (which are complex enough already) . That's what we are trying to achieve with this product.

Moreover, Eclipse Modeling is a gem mine driven by enthusiastic people, don't wait and come with us, resistance is futile ;)

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.

My last post about the flow model simulation was really missing a demo so that you get the "live" aspect of the model construction. No problem, that's a good occasion to show you a secret product we've been building on top of the Eclipse Modeling projects since a few year now. In my dictator position on this product you can guess I'm quite excited to show you that, nothing public came out about it since now but the first public release is not so far...

Let's stop the teasing and watch the content, here are a few flash demos . If you're just interested in the resulting modeler, go directly to the last one showing the live model design. If you don't understand what's about that flow stuff or if you're wondering how all that load and capacities properties gets updated, have a look on my preceding post.


The first demos are showing the graphical modeler construction. In a few clicks, just defining the concepts you want to display, how you want to display them and how to retrieve them in the semantic model. You get your modeler in a matter of minutes, and you really should not need more than that as it's quite simple.

I really like the "specifying the modeler and using it side by side" feature even if you need a big display for that and here for the demo I have no choice than scrolling.

The next demo is focused on defining "conditional styles" so that the graphical shapes changes depending on the changes in the semantic model (node/edge sizes and colors), in this demo I also specify the fact that a CompositeProcessor reuse the graphical mappings define for the diagram and that I should be able to create a sub diagram on a CompositeProcessor.
The request langage I'm using is Acceleo, but you could also use OCL, I tend to prefer simplicity ;)


And at last, after a bit more tweaking off stage, the usage of this finished dynamic modeler.



So, to be fair, the final modeler is more a 25 minute modeler than 20, but that said, I get a first working modeler a the minute 10 of the first demo.

Be sure that's only a tiny portion of what we've been able to achieve leveraging the Eclipse Modeling components (EMF, GMF, Acceleo, Compare just naming a few...) and the Eclipse Platform : graphic modeler are one thing, but other representation matters and I'm not even speaking about the "full viewpoint support".

Stay tuned for more eye candy ;)

Modeling Kata here again ! Models are useful to describe things, systems, knowledge, basically any information you want to organize and formalize will gain in using a solid formalism like Ecore.

Structuring and describing is nice, but then most of the time you need to evaluate your design. You basically have choices here, one of them is using the validation tools so that any "error in your design" is shown to you and so that you can fix it. The drawback of validation is that you can't easily get the big picture of your design quality corresponding to the constraints you defined.

Who can say that this bees invading my garden are organized in a nice or poor way ? That's definitely not a binary information.


Another approach is designing your models with tooling updating or self-constructing other part to gives you information about its quality. Let's take a (quite naive but still interesting ;) ) example :

I defined a formalism for a "flow-like" langage, you can use it to describe DataSources and Processors linked by DataFlows. Processors and DataFlows are capacity bounded, which mean they've got a maximum capacity and under given load will be iddling or over used.

Here is a class diagram displaying the simplest parts of the flow.ecore :
Here I'm mixing both the information I'll describe (a given system with datasources, processors and flows) and the feedback about my design (the flow element usage).

Note that every element here might be activated or not (see the FlowElementStatus enumeration).

Now to define my rules updating each values considering the overall model, I basically have the choice either to implement that in Java, or use a Rules Engine. Implementing in Java might look like a good idea but you'll quickly realise that :

• adapting the rules to a constraints which are specific for a project will make you redeploy everything
• you'll write code to browse everywhere in the model and update the values depending on your browsing result, and with big models you'll get poor performances

That said, this exercise is interesting and might be the subject of another kata.

You bet I picked the Rules Engine, so that I can get my hands dirty with those strange beasts you (most of the time) never ever want to meet again after you graduated. I picked JBoss Drools which seemd just nice, powerfull, and based on an implementation of a Rete-like algorithm - which make it fast - and I have to admit I liked their logo is really cool.

EMF and Drools are going along really nicely. Drools considers your Java instances as facts and is then really easy to integrate with EMF. EMF provides the generic notification mechanism which make it really easy to integrate with drools so that drools know that something changed and that he might have some work to do.

Here is the result, let's design a flow related to my work :
Freddy is a datasource which produces lots of information (8). He's inactive right now (see the red icon ;) )

Let's add Laurent which is way more quiet, "Me" which is a processor both being a flow target and a flow source, as I'm providing data to "My Computer". My Capacity is 10, my computer has way more capacity than me.

Let's connect everybody with DataFlows, each of them having a max capacity of 10.
Freddy and Laurent are both connected to Me, and I'm connected to My Computer.

Everybody is inactive, let's activate some part of the system : Me and My Computer.
As long as Freddy and Laurent are not there, everything is fine, my usage is "low".
Activating elements in the editor, everything gets updated "on the fly" and the labels are reflecting the current usage of an element.

Now Laurent is activated. Everything is still fine (you kind a guess the next step, right ? ;) )


Freddy is activated, I'm over stressed (see the red) and even the dataflow from Freddy to me has quite an high usage (orange color).

So now I have different options, I can redesign my system in a way that the capacities are higher (for me and/or the dataflow), or split parts of the Freddy flow and distribute it on other processors. I'll be able to try every solution, activate/desactivate elements, and see if my system is meeting my constraints or not.

Now let's have a look on how I did that...

Here are the rules I'm using, quite straightforward and it's easy to put more rules expressing really complicated constraints.

This language is dedicated to the logic rules definition and is, as a matter of fact, good at it.

Mixing drools and EMF has just been about setting up an adapter on my resource when loading the model, then if something gets updated, EMF tell drools which instance changed, and drools fire the corresponding rules, chaining them if needed.

I'm not the first one doing that, googling a bit you'll find papers.

Quick reminder of what's nice with this approach :

• not re-inventing the wheel again
• great expressiveness for your rules
  
• great performances even with many many many rules
• rules are easy to customize and you don't need to change your code to consider new construction rules.

Stay tuned and feel free to provide feedback on a similar or different approach !

After Java Productivity tour 3 weeks ago, I could participate to the first edition of "Jeudis des modèles". Theses meeting take place in EMN Nantes every two months and deal with the Model Driven Engineering.

So, thuesday there was two presenters for this first time :

• Nicolas Rouquette from the JPL, NASA
• And Patrick Albert from ILog (IBM)

The first talk (from Nicolas) introduced the use of models in the JPL and especially why NASA came to use the models in its software design process. Nicolas, who defines the Software design methodology, explained the evolution in the way of create software that drive the lander sent on mars. Of course, this kind of software must be very robust and it design became more and more harder this last years.
So JPL had to improve again and again its design process and with the growing complexity of this process, they came to using models since 10 years now.

The talk of Patrick describes the evolution of software design in ILog. During the ILog evolution, they realized that there was an important part of programming that didn't implies algorithmic but only business rules. Theses rules could be defined by end-users if the way to express it was enough easy.
In this approach, they decided to create a language easy to understand that allow to defines theses rules. With the years, they naturally came to use the DSL part of the MDE.

Finally, these two very interested talks described two different ways to come to using models. It was very instructive to see other uses of the MDA that the one we apply every day and I hope can participate to the next edition.

I wanted to add some pictures I took during the conference but the camera of my cell made very ugly shots and I definitively can't show you them. Perhaps it's time to ask for a cell with 10Mpxl camera ... :)

Thank you from the Acceleo Team (unfortunately not complete here, have a look on the team pages for core and modules) !



Thanks for all the people involved in Acceleo's winning the "Best Open Source Eclipse-Based Developer Tool" price this year. No doubt you'll be quite pleased to hear that "Next-gen Acceleo development is taking place in Eclipse.org ", right there, in the M2T project.

The next-gen Acceleo has many differences with the Acceleo.org one, especially :

• efficient standalone support right now, that means you can reuse the generation engine even outside of an Eclipse or OSGi context, just put the EMF and OCL jars and you're done.

• a new statically typed syntax based on the MTL OMG standard

• aspect-like patterns to extends existing cartridges.

• automatically generated Java API for your generation module. It's then really easy to leverage a generation cartridge from your own action or wizard.

But we keep the fondamentals that made Acceleo.org a success, especially:

• Pragmatic vision : let's make it easy for the 95% stuffs everybody does, let's put Java extension for the remaining 5% stuffs not everybody needs.

• Nifty tooling : debug, completion, show references, open declaration, highlighting, markers, any feature you expect from an Eclipse Editor is there.

• Community : the Acceleo.org community has been pretty active in providing a full set of "ready to use cartridges" for a lot of technologies (JEE, PHP, C, Python, C#...). No doubt this community will follow the project on Eclipse and expects nice pragmatic generators. EEF is opening the path.

Want's more ? Here are a few demos :

Creating a new project From a Sample


Acceleo Eclipse Tooling

Overview of the Acceleo Syntax

Migrating from the old syntax to the new one


Want's more and more ? Acceleo is part of Galileo and builds are provided.

Do not hesitate to have a try and give feedback on the M2T newsgroup !

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)

Il y a maintenant une semaine que je suis rentré du salon Solution Linux / Open-Source 2009. Cette dixième édition se déroulait cette année Porte de Versailles. Après 5 années en tant que visiteur, ce fut l'occasion pour moi de passer de l'autre coté de la "barrière" pour devenir exposant et conférencier aux cotés de mes collègues Etienne et Stéphane. Nous étions localisé sur le stand d'Alliance Libre, le pôle d'expertise en logiciels libres Nantais auquel nous sommes membres.
Durant ces 3 jours, j'ai pu présenter les produits Obeo, échanger avec différents acteurs du libre. Mais aussi voir quelques autres membres de l'OSSGTP, ainsi que mes anciens collègues qui ont lancés en direct leur nouvelle plateforme de Cloud Computing Faascape. Ce fut aussi l'occasion de faire le plein de T-Shirts Geek, outil indispensable au télétravailleur que je suis

Mardi dernier, j'ai présenté pour la première fois le projet Eclipse Papyrus, le nouveau modeleur UML de la fondation Eclipse sur lequel je contribue. Voici les slides de la présentation :

Hi,

Acceleo.org was created 4 years ago, and as the time goes, the Team has been more and more convinced that the MOF Model To Text OMG specification was the way to go for the project. More than one year ago now, we started to code a reference implementation for the standard within the Eclipse M2T project - named MTL. We're now convinced that we'll manage to provide nice tooling, simple syntax and efficient code generation with all the pragmatism we had about Acceleo.org and we asked
the Eclipse Foundation to rename MTL in "Acceleo".

Our goal is this one: a transparent development strategy and stop having two similar projects in 2 places : Eclipse MTL and Acceleo, but in a near future, promote just the Eclipse one as the "Next Gen Acceleo".

We are confident that the Acceleo community gain value from moving to a self hosted project to an Eclipse one, and that end users will follow the transfert from Acceleo.org to Eclipse.org as we will provide the same level of functionnalities and we will insure an interoperability between the old syntax and the new syntax (the standard one).

Don't worry. There aren't a lot of differences between the old version of acceleo and the new one

The Acceleo Team will continue to maintain the old syntax of Acceleo outside of eclipse (www.acceleo.org ) during some few years, but the new versions and features will take place on Eclipse.org. In the next few days you'll get an automated tooling helping you to migrate your templates from a syntax to another.

For Acceleo lover, you will find in Eclipse Acceleo everything you have loved in the Acceleo.org version and more (the standard compliance with more documentation)
This specification is really a good one : http://www.omg.org/spec/MOFM2T/1.0/

At the moment, those who need a perfect stability must continue to use the Acceleo.org version. As time goes on, Eclipse Acceleo is better and better and you can already have a try right now. That said, we still need a couple of month to get the same stability level between our current stable version and the new one.

I'm sure that Eclipse Acceleo will be a success ;-)
You can download the first builds (0.8.0) here :
http://www.eclipse.org/modeling/m2t/downloads/?project=acceleo


A presentation of Eclipse Acceleo took place at Eclipse Conference and had nice feedbacks.
http://www.eclipsecon.org/2009/sessions?id=387

Congrats to all the commiters and contributors involved in the first stable version of this component

Thuesday took place in Nantes (La Beaujoire) the JavaEE Productivity tour. It was a presentation of three companies Obeo, ProxiAD and SpringSource dealing with their feedback on productivity in the JavaEE world.

First, Arnaud Buisine, from ProxiAD, presented the current state of his company about project industrialisation. His presentation deals with many topic like :

• The choice of frameworks
• The choice of code generation
• The quality process
• The developper post : settings and building
• ...

Then comes Julien Dubois from SpringSource. His part dealt with the productivity in the framework point of view. He talk about :

• Spring what it does and what it will do !
• Groovy
• Grails

Finally, Etienne from Obeo, shows our tooling dedicated to JavaEE productivity. It was the moment to talk about :

• Acceleo and Acceleo Pro
• Obeo designer
• And Obeo Network

After this 3h30 of presentation, It was the time to lunch and discuss about this topic. Interesting topics make interesting audience and interesting audience implies exciting discuss.

The JavaEE productivity tour will take place in another site soon and I hope It will come back next year in Nantes for new exchange on our wild JavaEE world :)

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 benjamin ) official commiter on eclipse !

i just need some time to do the paperwork :)

Here is two examples of the EEF generation result :

• In a tabbed properties sheet page :

• In a JFace wizard :

After a good Proposal Phase (with some propositions of several interested parties), we currently work on the Creation Review for EEF. Thanks to everybody who help us to create this exciting project !

EclipseCon has been going on for a few days now, and I'm quite happy to say this year's event is great, especially concerning the social interactions. I've been coming here in Santa Clara for a few years now and I had the pleasure to meet, in real life, many of the Eclipse commiters and contributors. That's why going back there now also mean seeing friendly people again and having great time with them.

It started with the AC meeting on Sunday, which Martin perfectly handled (as usual). It's really nice, for a newcomer in these councils like me, to see that things are going on, and that people are pushing stuffs to make it real ! So please, do not hesitate to ask the AC !

It continued with the tutorials which really helps newcomers to adopt and understand our technologies. That was the occasion to meet many new people which is kind of a refreshing thing :)

From the Modeling perspective, this years also opens a lot of opportunities, despite the fact that our benevolent dicator is not with us right now, our community is really active and pragmatically tackles real world problems. The modeling BOF was a good example of that, and may be even a bit too much. We have not been able to have a really controversial debate as usual, I guess people keep that kind of stuffs for the numerous e4 events during EclipseCon !

One of the BOF result you'll soon experiment is that more "business cases" of successful usage of the modeling technologies will be advertised. Basically everybody in the BOF had at least one successful customer story to tell and that kind of feedback could be valuable for the community as a whole.

Speaking about pragmatic implementations and success, my talk about EMF Compare went really well, the room was filled with people already using, or interested in using modeling ! The corresponding slides are (at last) here :

Team Work With Models Web

View more presentations from cbrun.

unfortunately the demo links have been lost during the slides upload, you can watch the talk demos :
Metamodel agnostic diff/merge supporting multiple ressources
Platform Team API integration (CVS, SVN and GIT)
Graphical modelers integration (draft)
EPatch feature

Extensible diff model export

Among the interesting questions I had at the end one was : "Can EMF Compare is not able to compare a 50Mb model ? I tried and it crashed" - well, that's right, no doubt there is room for optimisation in the generic match engine used by EMF Compare, but comparing two versions of a whole huge model seems quite inappropriate most of the time, that's basically the same thing as if you would like to compare your C: drive with your D: drive, what's the point ?
EMF Compare 0.9 (soon to be 1.0) now supports model fragments, just split your models !
hat said, some of the use case for such a model (and even way bigger) stays valid and that's why I launched the GSOC idea about "comparing huge models" - by huge I mean millions of elements or more. That requires a very different algorithm, and specific handling of the "runtime data" needed to compare the models. Interesting subject indeed !

The good news is that seems like this subject is interesting students, great ! go ahead ! and provide a great application !

Another proof that pragmatism with modeling helps , Acceleo won the "Best Open Source Eclipse-Based Developer Tool" , I'm really sorry not being able to get my pictures from my camera right now because it contains a proof that girls can't
resist on a kiss from a french guy, just imagine the picture with Jonathan and Lynn ;) . We've got an high standard to keep !


Stay tuned as EclipseCon is not over, I'll come back with even more event reports and "imaginary pictures"

Un évènement dans l'Ouest à ne pas manquer !

JavaEE Productivity Tour co-organisé par Obeo, ProxiAD et SpringSource s'arrête à Nantes, au Stade de la Beaujoire le mardi 7 avril, de 9h00 à 13h00.

A cette occasion, nous partagerons avec vous notre vision commune de la problématique plus que jamais actuelle de la productivité des développements JavaEE.

La grande plus value de cet évènement tient dans l’association autour d’un même fil rouge de 3 spécialistes de la productivité qui vous apporteront une vision complémentaire et intégrée des enjeux et solutions de la productivité en JavaEE. Les intervenants lors de cette matinée vous dresseront une vision globale et homogène de leviers de productivité d’un projet JavaEE. Ils se concentreront ensuite sur les bénéfices d’une cible technique performante et d’un environnement de développement adapté.

Nous aurons enfin le plaisir de nous retrouver autour d’un buffet à l’heure du déjeuner.

C’est gratuit, les places sont limitées et les inscriptions se passent Ici !

Yes, summer is coming fast, and if you're a student interested in software development and engineering, Eclipse is a great place for a Summer of Code !

New ideas are still appearing on the wiki page and no doubt you'll get many more in a few weeks. Let me highlight some of the cool subjects you might apply for if you're interested in modeling.

Let's speak about EMF Compare, we tried to focus on cool stuffs as that's what open source is about.


First, the 3D visualization ! Using EMF Compare, the GMF Diagram support and GEF 3D, one can imagine to get a nice "time machine like" visualization of the model differences. One can easily imagine really nice representation using that third dimension, we have to display two (or three) versions of a diagram annotating the diagram elements with graphical hints saying "that's a new element", or "this one has been changed", so 3D can make sense here.

Second : huge models comparison , by huge we mean really huge like millions of elements. EMF Compare uses an heuristic-based algorithm to compare two models, while doing so its keeping processing data in memory (more important the models are, the more memory is used). The subject is two folds : first design and implements a MatchEngine needing less stuffs in memory, then leverage Eclipse technologies like CDO or JCRManagement in order to break the memory bound ! That may seems trivial, but when you need to process a lot of data, many parameters are changing.

Third : improving the "Graphical Compare'" proof of concept initiated by Tobias (flash demo here) .

Many more ideas are available and looks really cool especially in the modeling area, so If you're a student, jump and meet the Eclipse Community !

In my never-ending quest of ideas or tools to avoid doing boring stuff (that sacred goal explains my interest in pragmatic modeling), I made quite a victory today thanks to one of those gems you find in Eclipse.

Here I'm speaking about the help/tutorials you get in the Eclipse help menu.
We often add many many screenshots in the tutorial but this tiny litle idea of "showing stuff to the user" may have a huge cost ! The drawback of using such images in the help is that as the tool evolve the ui do so, and the tutorial screenshots are quickly really different from the real tool user interface.
Then you even have to recapture screenshots for at every release, or just decide that "a real doc has no screenshots"

Both are inadmissible, one idea would be to integrate this "screen capture" step in the build process and automatically capture the wizards, views or properties. Then, you would even be able to localize your documentation screenshots starting this process for every localization you have. You've got pretty much any thing you need, right now thanks to Eclipse, to do that.

The gem I mentioned is SWTBot , thanks to this litle tool I quickly managed to get a basic test scenario working to test UI. Even if testing is important, and testing UI is tricky, here my goal was to produce the screenshots from the tests, here is the code (it anybody knows how to highlight code with blogger...):

bot.view("Welcome").close();

bot.menu("Window").menu("Open Perspective").menu("Other...").click();
SWTBotShell openPerspectiveShell = bot.shell("Open Perspective");
openPerspectiveShell.activate();

bot.table().select("Acceleo");
captureScreenshot("1-switch-perspective.png");
bot.button("OK").click();


bot.menu("File").menu("New").menu("Project...").click();
SWTBotShell newProjectShell = bot.shell("New Project");
newProjectShell.activate();
bot.tree().expandNode("Acceleo").getNode("Generator Project").select();
captureScreenshot("2-new-generator-project.png");


bot.button("Next >").click();
bot.text().setText("org.acceleo.uml2.gen.java");
captureScreenshot("3-new-generator-step1.png");


bot.button("Finish").click();

bot.waitUntil(Conditions.shellCloses(newProjectShell));
captureScreenshot("4-generator-project-done.png");


bot.menu("File").menu("New").menu("Empty Generator").click();
SWTBotShell newTemplateShell = bot.shell("New");
newTemplateShell.activate();
captureScreenshot("5-new-template-wizard.png");


bot.comboBox().setSelection("http://www.eclipse.org/uml2/2.1.0/UML");
bot.comboBox(1).setSelection("uml.Class");
captureScreenshot("6-new-template-wizard-full.png");
That's the喜喜 (ShuangXi) effect, you roughly test your UI and you get your screenshots !

ps : special "Hi" to the unique Guangzhou visitor I had on this blog so far :)

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 ...

Since six month ago, I have been within Obeo in order to work on Model Driven technologies. Indeed I manage Obeo's contributions to the Eclipse Papyrus project.

During this period I worked on the Papyrus to improve wizards, properties views and the usability of class Diagram. I'm also participated to the preparation of the IP Process checking.

Since one month, The source code of Papyrus was hosted on Eclipse SVN repository here.

And Now, since Tuesday, I'm proud to announce that I have been nominated Eclipse Commiter for Eclipse Papyrus project! It is a great honor in my hacker's life And I will put best efforts to provide quality contributions.

Also I will talk about my work on Eclipse Papyrus project or other Eclipse technologies on this Blog or on my Twitter Micro-Blog (Don't hesitate to follow me!).

After this news, I commited my first official contribution as a commiter #263431. I refactored the Papyrus Outline and implemented a first version of the Model Explorer view in order allow the navigation in resources, model and diagrams. This view is based on the powerful Common Navigator Framework (aka CNF) :

The result here :

More screenshots on the Papyrus Wiki.

CNF is very generic and extensive framework. Indeed, it allow to provide with the eclipse extension mechanism:

• content providers,
• label providers,
• filters,
• actions,
• sorters

I read some great articles to learn the CNF :

• Building a Common Navigator based viewer, Part I: Defining the viewer
• Building a Common Navigator based viewer, Part II: Adding Content
• What does the Common Navigator Framework (CNF) help me do?
• Building a Common Navigator based viewer, Part III: Configuring Menus
• Building a Common Navigator based viewer, Part IV: Object Contributions
• Building a Common Navigator based viewer, Part V: Action Providers
• Label Decorators in a Common Navigator Framework viewer

That post inaugurate a series of "modeling kata"'s. Modeling kata's are about basic usage of Eclipse modeling and related technologies to create fun stuffs, and more importantly doing it again and again using different ways and analysing the pros and cons of each solution. Of course the "kata" terminology is not from me.

Let's introduce the problem :

Taking my role of " Non Benevolent Dictator for Life " at work seriously, I like to keep an eye on the source code history of our products; on the mass of changes and on the places where the changes are made.

That was the idea behind the teamlog2rss.py script I wrote last year. But now, going a bit further in the "big brother" concepts, I hacked a small EMF model to retrieve the logs from the team repository and to generate reports, I'm then able to analyze the log messages and file uri's :)

The model is straightforward, here is a quick extract of the result :



The model implementation is querying Subversive to retrieve the logs through a "derived reference". That solution is quite crappy as accessing the model means going through the network (meaning - that's slow), but the advantage is : my EMF model is a plain old EMF model, and as such any tool will work with it.

Then I'm producing reports using Acceleo, for each week and commiter, I'm checking:

• how many changes have been made
  
• how many unique files have been changed
  
• how many tests have been changed
• how many "happy checkstyle" commits were done
• commit activity concerning "bugfixing"
  
• how many "happy boyscout" commits were done

here is an extract of the M2T template:



I'm then able to generate HTML, and even generate a small uri for Google charts to get nice pictures:


I'm even able to add the commiters picture in the "weekly hall of fame" through user code tags in the HTML :)

That said, M2T transformation is not the best pick for such a need, I really need to deduce new information from the original teamlog data to produce, afterwards, a nice report. Next try on this kata will probably involve M2M transformation to deduce the information, or Birt reporting... But, I don't want to spoil you, stay tuned ;)

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.

Times have been busy since Eclipse Summit, mixing the great stuffs I'm doing at work, Gaspard (Casper) incredibly fast growing, the Eclipse and Open Source activities and the whole Christmas and New Year's Eve stuffs, each day was full of excitement.

First, Ed came at Obeo/Nantes for a full day of cool technical stuffs, demos, and of course, pastry ! If you didn't met Ed you can't even imagine how friendly he is, that was a great time and I've been able to give him back the chocolates I was owing him. Feel free to come back any time Ed !



Speaking about chocolates, the end of the year was full of those at Obeo. As more and more internal projects uses continuous builds with hudson, more and more chocolate commits gets detected ! A day without a new chocolate box has been a rare thing lately.

About code, projects and products, If you're a model user, you'll probably be happy to learn that EMF compare 0.9 features are being done in the repository, here is a quick glimpse of the "ResourceSet Match" also known as the "EMF Compare can't handle my models having external references bug"


Here we're comparing a genmodel, and you probably already knows that genmodels are decorating ecore models, and as such have references on the ecore model.

If you're interested in EMF Compare, do not hesitate to have a look on the webinar Laurent and I did in December !


It's demonstrating EMF Compare both from a user point of view and from a developper, tool vendor or "extender" one :)

As a side note, do not hesitate to ask the foundation to organize a webinar for your project, you'll get those Eclipse Shirts which are quite collector ones then ;) Thanks again for your help Lynn !

These are just a few things who made the end of 2008 an exciting time and no doubt 2009 we'll be even more exciting !

First I'm now a member of both Architecture and Planning Councils, I'm confident I'll enjoy theses and I'll do my best to fulfill the expectations there.

Second :

Yes, I'm speaking to EclipseCon thanks to Obeo and the program commitee (nah nah, nothing to do with the chocolate box ! ) and I'll present a talk there about Team Work with models so that I can show EMF Compare in action, its integration in GMF modelers and even a bit of 3D if I'm able to code a prototype with GEF 3D since then.

Stay tuned for more exciting stuffs from the modeling space ;)

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.

Wednesday, I met the others commiters of the Eclipse Papyrus project. We have prepared an action plan to prepare the IPZilla process. As you can see a great week of work ahead! You can see the minute here:

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.

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 !!