Model Driven Blogging

Do you want to discard this editor's changes ?

2011-12-16T09:55:00.000-08:00

If you've used EMF editors you probably already have seen this kind of dialog :

This happens when you did change your model and some external changes (aka somebody else changed your file) happened before you pressed "save". This is not only an EMF problem, any editor has kind of problematic. Either way the end user have a very hard time undestanding why he has to pick one or the other version as most of the time these changes are not conflicting !

Is that the best we can do ? Another option is to compare both versions, detect conflicts, and if there is no conflicts, just merge the changes.

Here I changed the number of pages in the EMF Book from the model, and changed the title through the textual editor. When going back on my editor, the comparison, conflict detection and then merge process happens and I get this :

And when I have conflicts? Then the editor can't do much, right, at least it can helps you and show you the conflict :

How is it implemented ? That's fairly easy using emf and it's diff/merge support :

The general process is : the editor tells the WorkspaceSync class when it got saved (or freshly loaded) . This WorkspaceSync keep a copy of the state of the editor as "ancestor". When an event comes from the workspace, the editor version and the workspace versions are compared using the original copy as a common ancestor to detect conflicts. If there is no conflict, it merges, if there is at least one conflict it asks user.

The drawback is clear with this implementation : you're keeping around - in memory - a copy of your model to be able to detect conflicts later on. As such that solution is not for every case.

Other options are possible and might be great ways to exercise your EMF skills, if you try something, tell me !

Eclipse Day Paris 2011

2011-12-06T07:33:00.000-08:00

Eclipse Day Paris took place a few weeks ago, every year it is scheduled the week after Eclipse Con Europe. I had the chance to attend the 2011 edition and it was a real pleasure for several reasons.

1 - Organization rocked

The event was perfectly organized. Proxiad and Zenika did a great job, timing was perfect for the presentations, the content was interesting and the french touch for food and wine have been highly appreciated !

Proxiad and Zenika are fairly original service providers : highly technical and active in open source communities, it's always a pleasure to collaborate with them. Congrats to the organizers !

2 - Diverse content

The talks were very diverse, from Ralph and the Eclipse Foundation to UI testing going through modeling, OSGi, Scout, BI and industrial feedback. A nice combination.

3 - Wide and Diverse audience

The event was free and attracted a wide and diverse audience. That was perfect for me as I was there as "Eclipse Modeling Evangelist", helping people understand what kind of technologies we are building in this project and how they could benefit from it with a very low cost or risk.

Slides (in english) are available here.

The room was crowded and actively listening. I had many interactions after the talk. The Eclipse Modeling project is very hard to understand from the outside, it is highly fragmented and poorly publicized. I'll try to give more talks of this kind in the future.

4 - Hands on

Afternoon we had an "hands on" session with Obeo Designer, timing was short but all the attendees managed to build a DSL and a graphical modeler during the session.

It's always enlightening for us to interact directly with users trying the technology. It helps us identify very small things which are making a huge difference at the end. Obeo Designer 6.0 will bring a lot of good stuff in this regard, stay tuned !

In a nutshell I really liked this event which is a good complement to other Eclipse events like democamps or eclipse conferences. I'm looking forward to it for next year and can only advice you to book the dates !

SysML Comparison and Contributions

2011-12-01T11:41:00.000-08:00

Community and Ecosystem

The Juno release cycle has been very interesting for EMF Compare - as a project.

Discussions started through the Modeling Platform working group lead to the sponsorship of a bunch of new features (we covered those before but in a nutshell : UML dedicated support, UI enhancements, Graphical comparison support and Logical Model for EGit).

Meanwhile we took a number of actions to make this project a more welcoming area for contributions and to ease adoption, some of these actions are technical (documentation, build, tests and continuous integration) and others are focused on community grow (transparency, communication, discussions with academic researchers).

We are not done yet and have several remaining actions but we can already see some results :

- new adopters appeared and contacted us through the bugzilla with use cases we had not envisionned, trying to keep the answering delay reasonable helped a lot in converging to a patch. Within Eclipse itself we've seen several new projects adopting the technology.
- new features contribution : thanks to Arthur from Atos a dedicated support for SysML model just got integrated and is now built. In those cases where timeframe is obviously bigger than a simple patch, git helps a lot.
- discussions with academics helped us drafting powerful new features for 2.0 like fingerprints based matching (a complete blog post about this will come soon)

EclipseCon US will be a great place to share our experience, I if you're interested or would like to see a specific topic within this scope, feel free to add a comment.

More about SysML ...

The SysML contribution is built on top of the UML dedicated support, it just got integrated and built.
It never got released so it might be a bit rough, and we still have some issues we want to fix for 1.3 but if you feel adventurous, go get the bits here !(update site)

Follow the White Rabbit ...

2011-11-07T07:56:00.000-08:00

at Eclipse Day Paris !

If you're always wondering why we are so excited about Eclipse Modeling Technologies, if you'd like to understand how technologies relates to each others and how they can be used, stop by at Eclipse Day Paris tomorrow :

"Modeling" . Behind this simple word lies strong opinions, misconceptions, obscure acronyms, meta-things and marketing campains far from the reality of developping an application. But if you look more closely, this forest hides a fairly small set of simple, powerful yet flexible concepts. If you zoom in again, you'll see awesome technologies. While some "dreamers" are giving more and more abstract discourses about modeling, on the field these technologies are pervading, even close to the bare metal in the Eclipse platform itself. In 2011, you might already know you can generate rich applications, but what about web technologies, PHP, C ?

This talk will start by taking a step back about what is all this modeling stuff, what it isn't and what technologies the Eclipse Modeling project brings in this regard. The focus will be placed on tools and components useful to build any kind of application and not just Eclipse based ones : EMF, Acceleo. You'll come back with examples of how you could leverage those technologies for your own project.

Obeo @ Eclipse Con Europe

2011-10-27T02:00:00.000-07:00

Obeo invests a lot in Eclipse projects ( yes, we are a Strategic Member of the Eclipse Foundation), we're building, in the open the modeling platform we need for our product.

Conferences like the upcoming Eclipse Con Europe are great time for our team, we get to meet people we usually interact with using mails or bugzilla, adopters which are using our technologies, we get to have an insider sight of what is going on here and there, and we're pleased to show to others what we did in the generic technologies or how those pieces are used for domain specific needs.

This year the Obeo'ers are co-presenting or presenting numerous talks covering a wide spectrum :

Time Slot	Presenter	Title	Session Type
2 November 09:00 - 12:30	Mariot Chauvin	What every Eclipse Developer should know about EMF	Tutorial [3.5 hours]
2 November 16:30 - 17:00	Stéphane Bégaudeau	And you thought you knew Template Based Generators?	Standard [25 minutes]
3 November 09:00 - 09:30	Goulwen Le Fur	Scientific application redesign in oil industry with Eclipse Modeling	Standard [25 minutes]
3 November 10:30 - 11:30	Mariot Chauvin	Collaborative Modeling : the New Deal	Extended [55 minutes]
3 November 11:30 - 12:00	Gaël Blondelle	The Making of the OPEES Industrial Working Group	Standard [25 minutes]
3 November 15:30 - 16:00	Frédéric Thomas	Eclipse for Railway Safety Engineering	Standard [25 minutes]
3 November 16:00 - 16:30	Mikaël Barbero	What the heck are logical models?	Standard [25 minutes]
4 November 11:30 - 12:00	Alex Lagarde	Create useful documentation with Mylyn Intent : a step further in Application Life-cycle Management	Standard [25 minutes]
4 November 15:00 - 15:30	Mikaël Barbero	EMFCompare improvements: fulfilling requirements of the Modeling Platform Working Group	Standard [25 minutes]

Take this chance to discuss with the team !

Unfortunately I won't be able to make it this year. I'll celebrate the 10th birthday of Eclipse through Twitter/G+, so pleeeeease, tweet-it !

On the other hand I will present at Eclipse Day Paris : What the heck is Eclipse Modeling and why should you care ?

I'm looking forward to meet you there !

Model Transformation Preview

2011-10-18T08:37:00.000-07:00

Let's say you have a model to model transformation, and you want to provide the ability, for the end-user, to see and control what is going to be applied on the target model. How could you do that ? EMF compare might do the trick..

Here is a trivial model transformation, renaming all Classes which are "abstract" by adding a prefix to their name :

public class ModelTransformer {

public void process(Resource res) {
Iterator it = EcoreUtil.getAllProperContents(res, true);
while (it.hasNext()) {
EObject eobj = it.next();
if (eobj instanceof Class) {
renameifAbstract((Class)eobj);
}
}
}

private void renameifAbstract(Class eobj) {
if (eobj.isAbstract() && !eobj.getName().startsWith("Abstract")) {
eobj.setName("Abstract" + eobj.getName());
}
}

}

The orchestrator of this process has the following responsabilities : loading the original models, transforming those, and then opening the comparison preview, here is the code coming from an action :

protected void transformModelsAndOpenComparison() throws InterruptedException, PartInitException,

InvocationTargetException {

ResourceSet future = new ResourceSetImpl();

for (URI uri : selectedURI) {

future.getResource(uri, true);

}

ModelTransformer transformer = new ModelTransformer();

for (Resource res : future.getResources()) {

transformer.process(res);

}

new DifferencePreview(future).compareWithExisting();

}

Future contains all the models after they have been transformed. Now the interesting part is in the DifferencePreview class :

public class DifferencePreview {

private ResourceSet now = new ResourceSetImpl();

private ResourceSet future;

public DifferencePreview(ResourceSet output) {

future = output;

}

public void compareWithExisting() throws InterruptedException, PartInitException,

InvocationTargetException {

for (Resource futureRes : future.getResources()) {

now.getResource(futureRes.getURI(), true);

}

MatchResourceSet match = MatchService.doResourceSetMatch(future, now, Collections.EMPTY_MAP);

DiffResourceSet diff = DiffService.doDiff(match);

ComparisonResourceSetSnapshot snap = DiffFactory.eINSTANCE.createComparisonResourceSetSnapshot();

snap.setDiffResourceSet(diff);

snap.setMatchResourceSet(match);

ModelCompareEditorInput input = new ModelCompareEditorInput(snap);

CompareServices.openEditor(input, Collections.EMPTY_LIST);

}

Now contains the state of the models as it's serialized on the filesystem. We starts by constructing the Now resourceset getting all the resources which are present in the Future one. Then we call emf compare to compute the required match and diff , forge an editor input and open it.

How does it look like then ?

Pretty easy huh ?

Now let's say you want to allow the end user to customize your output model and allow him to see when the changes coming from the transformation are in conflict with his customizations. Its getting more interesting : to do so you will need to have a version of the model which has been untouched by the end user and use it as the ancestor. You need to decide where to keep this data and how to prevent the end user to edit it. It's up to your use case, it might be a file next to the output file, it can be in the Eclipse metadata.. Here for the example we'll just use files with a ".ancestor" suffix (see getAncestorURI) .

Anyway, then you'll need to move to three way comparison :

public class DifferencePreviewWithConflictDetection {

private ResourceSet now = new ResourceSetImpl();

private ResourceSet ancestor = new ResourceSetImpl();

private ResourceSet future;

public DifferencePreviewWithConflictDetection(ResourceSet output) {

future = output;

}

public void compareWithExisting() throws InterruptedException, PartInitException,

InvocationTargetException {

for (Resource futureRes : future.getResources()) {

now.getResource(futureRes.getURI(), true);

ancestor.getResource(getAncestorURI(futureRes.getURI()),true);

}

MatchResourceSet match = MatchService.doResourceSetMatch(now, future, ancestor, Collections.EMPTY_MAP);

DiffResourceSet diff = DiffService.doDiff(match,true);

ComparisonResourceSetSnapshot snap = DiffFactory.eINSTANCE.createComparisonResourceSetSnapshot();

snap.setDiffResourceSet(diff);

snap.setMatchResourceSet(match);

ModelCompareEditorInput input = new ModelCompareEditorInput(snap);

CompareServices.openEditor(input, Collections.EMPTY_LIST);

}

private URI getAncestorURI(URI uri) {

return uri.appendFileExtension("ancestor");

}

And now what happens if the user decides to update the name of an abstract class, here LibraryElement got renamed in AnyElement ...

That's right, we have a conflict !

It's a pretty simple example of what you can achieve using emf compare and how you can reuse it in your tooling. The model comparison editor which opens then is slightly different from the one you have using SCM operations and has less features (it does not provide the latest capabilities regarding diff filtering). It is also probably not the best fit for end users if many conflicts have to be handled, you might want a wizard in these cases. These are open subjects left as an exercice to the reader. We are clearly missing building blocks regarding ui so far.

On the newsgroup, bugzilla or during conferences we are often amazed to see how adopters are re-using the technology for their use case, keep telling us, we like to know !

Next steps ? Plugging this with an ATL transformation or using the scoping mechanisms (IMatchScope) to ignore parts of the model we don't want to check, we'll see.. Stay tuned.

Model Comparison : Logical Model, UML, Papyrus, EcoreTools and GMF Integration

2011-10-10T07:59:00.000-07:00

We just promoted an EMF Compare 1.3 integration build providing all the latests developments regarding EMF Compare, in a nutshell:

- Logical Model support for team operations (more especially with the eGit team provider)
- UML semantic comparison with dedicated management of profiles, stereotypes, and dependencies across changes
- GMF generic bridge for graphical comparison
- Papyrus specific bridge for UML diagrams comparison
- EcoreTools specific bridge for Ecore diagrams comparison

The build is here :

http://download.eclipse.org/modeling/emf/compare/updates/interim/1.3/

(subsequent updates will be pushed here too)

Depending on what you are trying to install you might need the orbit update site (google collection):

http://download.eclipse.org/tools/orbit/downloads/drops/R20110523182458/repository

The Indigo one (papyrus, gmf and Ecoretools):

http://download.eclipse.org/releases/indigo

Please if you are interested in any of this change, go grab the build and have a try, we will welcome your feedback through the bugzilla.

Synchronizing data : Dropbox-like based on open-source stack

2011-09-28T03:36:00.000-07:00

I had to find a solution for my backup/cloud drive needs lately. Dropbox works just fine, but the pricing is going high to fast as you want more space.

A 1To / 100Mbs dedicated server is not that expensive and provides the nice perspective of more server/web oriented hacks later on.

After trying a few open source projects in this regard (Syncany, Csync or SparkleShare) and keeping away from the desire of building my own, here is my short list :

Sparkleshare is very nice for things which I want to keep versions of. I really like the fact that it's keeping everything in a git repository, any file manager providing git integration will then allow me to dig through the history of files. As I'm not interested in the fact that it works on multiple platforms (linux, mac and soon windows) I still have to check if a script launching automatic git add . && git commit && git push is not going to be as reliable as SparkleShare while being lighter.

For non versioned directories, inotifywait + csync are just fine. (incron, a cron-like tool but using filesystem events as an input did work but is not supporting recursive watching)

I also considered Syncany but did not liked the fact that server side chunks of data are used which have no standard way of being accessed beside Syncany. I quickly had the feeling that git would do just fine in this regard, especially with a few git gc --aggressive from time to time.

I'm pretty sure using the new Java 7 filesystem notifications + jgit one could very quickly build an highly efficient and multi-platform solution. I managed to refrain myself trying it, but if you do or know someone who did, please let me know ;) edit : Mikael did start such a thing on github

If you are an OpenSuse user here is the magic repository.

We'll see in a few month if I'm still happy with this solutions. Feel free to add a comment if you have other options !

Textual Adventures in Ecore + Graphical Modeler

2011-09-21T02:16:00.000-07:00

I was cleaning up my ${HOME} folder today and found a set of demos I prepared two years ago.

I did this for a modeling course given at Polytech' . The course was about Model Driven Engineering, toward the end the student have to build a domain specific model for textual adventure games and then generate the corresponding Java app. Some students tend to go very far on this exercice buidling a fairly complex DSL.

The following demos are here to given an idea to the student of what can be done in a few minutes : a simple Ecore model

And then a graphical modeler :

And then we build Acceleo generator templates to directly map a game instance into its running Java code. It's a very interesting exercise, students are staying focused because it's about game, and at the same time it's a great example of the power of specific modeling. You don't design a game with an UML diagram, but building your own langage and using it you're quickly getting results and can evaluate many designs.

Building the complete tooling is a matter of minutes, not hours, here are the live demos :

Designing the Domain Model : vidéo

Specifying while running the Graphical Designer : part1 and part2

As a sidenote, these flash demos are based on a pretty old version of Obeo Designer, if you're interested, have a look on the latest versions which are even better !

Eclipse Modeling : the definitive tutorial

2011-09-14T05:08:00.000-07:00

One of the thing we keep hearing from the adopters is : we need more doc, not just reference documentation but also how using and combining the Eclipse Modeling components.

Richard Gronback's answer to these request was to write a book. But as we are living in a fast changing world filled with innovation it quickly got outdated.

Reinaldo de Souza, a GSOC student did an amazing work as part of the Amalgamation Project. He did prepare an awesome cross-modeling components tutorials : the design of an Android DSL using Ecore, providing a textual syntax using XText, customizing EMF editors using EEF up to generating the Android code using Acceleo.

The EMF domain model and Eclipse editors
https://github.com/eclipse-soc/amalgamation-examples-emf

Xtext Textual syntax for the DSL :
https://github.com/eclipse-soc/amalgamation-examples-xtext

Acceleo to generate the Android code :
https://github.com/eclipse-soc/amalgamation-examples-acceleo

It is more than just a start, it really is a complete tutorial with step by step instruction on the wiki and the corresponding projects one can import in his workspace.

https://github.com/eclipse-soc/amalgamation-examples-acceleo/wiki/Android-code-generation-with-Acceleo

The original idea was to provide also tutorials and examples for GMF or Graphiti. It could not be done in the timeframe but anybody wanting to continue the example with the same domain model using other components is very welcome !

Now we still have to package it properly so that the adopters can get it in a nicely integrated way in their IDE.

Collaborative Modeling : the New Deal

2011-09-07T04:55:00.000-07:00

Want to know how we tackle collaborative modeling @ Obeo ? Want to see live demos of consistent optimistic or painless pessimistic strategies ? Want to see more of what is going on mixing Mylyn and EMF/GEF/GMF ? Want to see live collaborative UI based on CDO/Dawn ?

Benjamin Muskalla (Tasktop), Martin Fluegge and I did prepare something for you.

All you have to do is to vote for this talk and come to EclipseCon Europe !

Live request interpreter for Acceleo 3.2

2011-09-07T02:51:00.000-07:00

Laurent is working on an Interpreter View for Acceleo 3.2 (coming soon)

It feels good already, one can launch queries on any Editor or View, syntax higlighting works and so is completion proposals. Compilation errors are shown too.

It's the perfect companion for building your code generator, once you'll start using it you will wonder how you could live without it before

By the way Laurent is going to give more detail about it quite soon..

Measuring Performances

2011-08-10T01:26:00.000-07:00

Performance is a feature, your users are needing it and so is your product. The code is changing, always, keeping track of the effect of those changes on the performance is not easy but it is as important as fixing bugs.

You don't control what you don't measure. The Eclipse Platform built a performance measure framework for their own needs. The API is pretty simple but the implementation, on the other hand is quite complex, querying for instance system specific commands to retrieve the memory state depending on the platform. Launching a performance test built with this is not easy, neither is getting the result in a human readable way.

Our needs were not as complex as the platform ones, we're not trying to measure the number of microseconds a Shell needs to be instantiated on every platform, we're not trying to launch thousands of performance tests for each of our component.

We decided to write a small framework to measure performance, Pierre-Charles did the first iteration and I'm applying it on EMF Compare now. This framework is using JUnit4 annotations so that one can easily transform an end user scenario into a performance test. First warning : this framework is not suited for micro-benchmarking at all !

Second warning : this framework is not without overhead either, it's filling an EMF model with the measures (which might take a bit of memory if you write thousands of tests) .

On the other hand, the output of the test suite execution is this EMF model, allowing us to quite easily browse the results, generate reports, and even more interestingly to compare two snapshots ! It's completely standalone and is not requiring more than Java, Junit, and the EMF Core Runtime.

In a nutshell, this framework is convenient if you want to measure tasks in the order of seconds, and memory usage if you're looking at megabytes.

So far it's giving you memory usage (through JMX) and system time for each tests, it's running the tests several times with a "warmup" phase launching the test but not measuring.

A test looks like this :

The test class :

And the Test Suite :

It's here if you want to give it a try, it's EPL, it's on github, feel free to fork it :

https://github.com/Obeo/fr.obeo.performance

Comparing pom.xml files while waiting for indigo

2011-06-21T07:01:00.000-07:00

I know you're all waiting for the Indigo release final bits ! These 0 and 1 are finding their way on the mirrors as I'm writing to make sure we'll get the smoothest release ever ;)

So, you ends up waiting ... In the meantime, I'm going to show you a nice piece of technology which is not going to be a new feature is Indigo ... as it's been around a few years already ;)

Maybe you had a look at Maven/Tycho, it definitely gained momentum this year, it's completely based on these pom.xml< files. I used them a few times already and even with the Minerva project (which helps a lot) I'm already in a love/hate relationship with those files.

"When the wise man point at the model, the idiot looks at the XML "

Hopefully Maven is providing an XSD here : http://maven.apache.org/maven-v4_0_0.xsd which you can use to initiate an EMF model :

Starting from an XSD is never as cool as starting from Ecore, but at least the EMF project can provide you an automatic mapping. And here is the mapped Ecore :

If you want a cleaner model you can tweak the mapping.

Using the genmodel you'll get the corresponding Java code. From now EMF is now able to load and save pom.xml files transparently and you can work with them using the Java API or the EMF reflective API.

What for ? To leverage all the great components around here, for instance, EMF compare is then able to use this and compare the model and not the XML serialization.

Ok, It probably took you less than five minutes to read this, if you're not a Friend of Eclipse you still have to wait for the release. As a sidenote, it did not take me more than 5 minutes to prepare it ;)

If you did not checked out EMF&co, you should really have a look !

Eclipse Modeling Package : SDK or not ?

2011-05-06T05:24:00.000-07:00

The indigo release will be the first year the Eclipse Modeling package is no more marked as "incubating". As I'm checking the status of every component I'm wondering : do you, end users of the package, want an SDK package or not ?

I, as of now, considered that using EMF&co without the SDK was a real pain, but maybe I'm not the best representative and I'd like your feedback. Especially considering that now with the provisionning capabilities of Eclipse we also have a third option : transforming your non-SDK to an SDK package in one click.

So here is the poll, it will stay online for one week and it needs like, 2 secs, for you to fill :

What are the implications ? Non-SDK package mean smaller package (around 100mo probably) or package with more modeling tools. On the other end SDK package means you can start using EMF&co as frameworks right away.

The poll will be on for a few days, go ahead and pick your choice !

Mylyn Intent @ EclipseCon 2011

2011-03-03T05:48:00.000-08:00

In case you're not aware (yet ;) ) the Mylyn Intent proposal is going forward, if everything goes well we'll be able to get a shiny git repository on Eclipse.org in the incoming weeks.

Mylyn Intent is going to help you co-document and design things. As we consider that code activity is part of the design itself the tool is analysing your source code and projects to assist documenting it.

What does "assist" mean in this context ?

At any time, you can synchronize your documentation artifacts regarding the corresponding models and source code. The really interesting things happens when it is not synchronized, you'll then be able to compare the expected design versus the actual one and, either update the doc, or update the code depending on what makes sense.

The design word has a broad meaning, and indeed under this term we are placing anything that we do formalize through an Ecore model.

It really is up to your team, development process, here is an example of what you could want to capture if you develop Eclipse plugins :

This one is pretty flexible and straighforward, you could come up with a slightly more complex model taking in account the versioning and change management aspects.

Basically this model capture every feature targeting either the end users or the developers. For a developer feature one has to associate at least one corresponding API exported by a bundle, for each API's one has to associate the corresponding unit tests. For an end user feature an acceptance test is required and it should be associated to an interaction (this part is left as an exercise to the reader ;) ).

I already hear you screaming : but you said it would be fun to document !? I'll have to fill all that information ?!

Don't panic.

With a blue highlight now : the things which are going to be synchronized with your development environment. What does that mean ? It means you won't have to dig yourself through the code finding unit tests, filling the bundle and exported packages, Intent will do this for you and will be able to quickly update your documentation. Furthermore, once you're back on coding, Intent will still work and check that your changes are in sync with the doc, telling you when it's not.

The non-blue things, you'll have to describe those in your document, Intent really can't figure it out for you.

Please note that this is an example of what can be achieved plugging a specific model and the corresponding synchronization code in Intent, you'll be able to plug-in your own very soon.

Let's go back to the point, what do Intent offer then as a platform ? What does Alice has to do with this ? How does she looks like ?

You'll figure it out at EclipseCon on Tuesday 22th, in Steven Creek at 11:10, don't miss it.

2011 - The Thrill

2011-01-18T07:03:00.000-08:00

One- two-three, one-two-three.. 2011 begins ... one-two-three..

Is that waltz ? Clearly 2011 is starting with another kind of tempo: a fast and dynamic one !

Fred Madiot just joined Obeo, you probably already met him at an Eclipse Conference and know him through the Eclipse Modisco project. He is joining us to develop the business through the Obeo Designer and Obeo Agility offers, we're quite excited about this and happy to get him on board !

Speaking about getting on board , we still have room for internships, if you're interested in working on innovative open-source projects focused on modeling and app modernizations, feel free to contact us !

Now on to the 2011 subjects: as french we like to cook, here is a taste of what is going on :

You already know we're involved in many Eclipse projects, 2011 will see the launch of a new project named Intent [proposal] within the on-vitamin project Mylyn.

This project is transforming the tedious and boring task of documenting software into a useful and easy process. You can have more information looking at the [Intent EclipseCon Talk], the [Wiki] (we're filling it up), [blog post fromAlex] or simply asking in the [Eclipse Forum].

The Acceleo Team is working restlessly on enhancing the tooling (which is already awesome by the way). The wiki has been reworked, my favorite page is the [Features Matrix] (credits to eGit release reviews docuware) which will give you a nice overview of what is available and how. If there is one page to look at, it's this one !

You saw [EEF in action] lately, the 0.9.0 is in the process of being released (currently in RC), this version will be the reference build for the upcoming Obeo Designer 5.0 !

If you're monitoring git in Eclipse, you might have seen the general project rush on this new infrastructure ! EMF Compare successfully did the move, you can now easily [fork it] and experiment at will !

[Patrick] also joined the team and actively worked on getting a compare release which includes the MPatch support I blogged about [lately].

Speaking about compare you can expect user interface enhancements, merge stabilization and dedicated UML support for this year. Coming soon in another blog post !

As I said : exciting times and dynamic tempo !

Sequence Diagrams for your DSL's

2010-10-28T00:53:00.000-07:00

We're working a lot on Obeo Designer 5.0 - release planned for Q1 2011 , on the traceability support and the next-gen model to text transformation language.

Concerning the editing and diagraming support changes are more subtles though powerful. Here is a quick glimpse on the latest milestone :

The most visible change is the work on the diagram ergonomy, the user interface has been cleanup, streamlined and features are more accessible. The global toolbar has been replaced with a dedicated toolbar embedded in the diagram editor providing access to the filters and the enablement of layers.

The contextual actions have been re-organized too.

If you're used to nice Eclipse editors you'll be happy to learn that the "Quick Outline" (summoned thanks to CTRL+O) is available in the diagrams now.

Just type in any word here, and the corresponding model element will be revealed in your diagram.

More interesting is the redesigned support for diagrams ! You can, for any kind of model being UML or your own DSL, specify and leverage a diagram editor keeping the model sequence order in sync with the diagram ordering.

you have the same level of customization that for the other kind of diagrams, you can change the shapes, colors and use the sequence diagram constructions like lifelines, messages and executions.

Here we're not using UML but our own "interactions" DSL which refers to another DSL describing domain entities.

As a sidenote, you can now have a color definition which is interpolated on a color palette depending on some model computation. Here we have a nice shade of green depending on the level of execution.

In a nutshell this new release will bring you more control, to the visual aspect and interactions on the tooling, the ability to define sequence diagrams, still keeping the complexity to a minimum : no deployement requirement, one file describes the whole design environment which you can test and try without even starting an Eclipse runtime.

It doesn't mean you can't deploy your environment as a set of plugins with proper dependency checking thanks to P2, it's just that you don't have too.

If you don't know about Obeo Designer and you want to setup a dedicated design + transformation toolchain for your domain, have a look here.

Here is a flash demo being a recap of these features :

Model Comparison : Patching with MPatch

2010-10-13T05:25:00.000-07:00

The following message is posted on this blog on behalf of Patrick Könemann

Cédric already announced it two weeks ago: MPatch is integrated into EMF Compare!

Did you ever want to transfer changes from one model to another?

Or do you frequently perform the same changes on your models?

MPatch is a technology that stores model changes as self-contained artifacts, just like patches, that are also applicable to other models! Let me show an example of how MPatch works:

This is just a simple model, a base version on the left and a modified version on the right.
Modeled with the IBM Rational Software Architect, but any kind of EMF model is supported.
The changes are highlighted: 3 deleted attributes, 1 updated attribute, 1 new class, 3 new generalizations.

EMF Compare is a nice tool for calculating such changes. The result is shown below.
All changes are nicely highlighted in the treeviews and one can browse through them.
This is where MPatch comes into play: the export menu lists a new option!

An export wizard is started that guides the user through the MPatch creation task.
In the end, the changes are stored in a file, extract_id.mpatch for example.
This file can now be applied to other models, even if their contents differ!

The model below is a different one -- again we want to extract the id attribute into a common superclass.
However, the attributes, the classes, and even the number of attributes and classes differ!

Let's see how MPatch handles the situation.
Selecting Apply MPatch triggers a wizard with the same name.
The crucial part is the so-called resolution of symbolic references -- they are responsible for selecting the proper model elements of your target model.
Let's have a closer look:

The first change is not applicable because there is no attribute called Title -- ignore this!
The second change is applicable because a similarly named package (data vs. customerdata) is found -- ok.
The third change is applicable because I manually selected Contract and Invoice -- ok.
The fourth change is applicable because similar named attributes (id vs. inv_id / con_id) are found -- ok.

Following the wizard to its end updates the given model and this is the result:

To wrap up, an Mpatch is not only a self-contained patch for models, it is even able to make the changes applicable to different models!

Installation instructions and a lot more information on the project website: http://modeldiff.imm.dtu.dk.

Autumn is a second spring when every leaf is a flower

2010-10-01T01:17:00.001-07:00

Maybe twitter gives a false impression that you're keeping the users informed of what is going on. False because 140 chars can't be enough !

Many things are keeping the Obeo guys busy, from the Eclipse and open-source involvement to the incubation of highly innovative products you'll love while still providing the best service to our customers looking for expertise :) .

Oh, and we provided the first Helios service release for Compare, Acceleo, EEF, ATL and much more, go get the modeling package !

Summer is an internship time in France, and for us every internship's ultimate goal is to hire another great person. I can say we did succeed this year ! Expect even more great contributions, user experience polishing and features for Indigo !!

Furthermore the newcomers completely understood the chocolate-commit spirit ...

No doubt you'll hear about those guys at some point, Stéphane already started to blog...

Speaking about Indigo, we wrote down a "long term roadmap" for EMF Compare on the wiki, feel free to have a look ! Coming soon : more information about the MPatch contribution recently integrated in EMF Compare.

Ok, enough teasing, back to code generation. In case you did not noticed Acceleo 3 provides one of the most compelling editing tooling you can get with the Eclipse platform. Using the JDT I often find myself thinking "oh, they did though about this ! great !" : you'll often get the same feeling with Acceleo 3...

Let's try with an example: it's often useful to be able to call Java logic directly from a template. If you want to do so, start by writting down this java logic.

Then call it from your template, obviously it's not going to work as is. Here we're calling the "getJavaCompatibleName" method on an EClass, but this method is not existing on this type. Acceleo provides a mechanism to call Java logic associated with a given meta-class: the first parameter of the method have to be of the type of the extended meta-class and Acceleo will automatically transform a myInstance.myMethod() call to a SomeClass.myMethod(myInstance).

If you want to try that, call the quickfix menu on the compilation error with CTRL+1 :

Choosing the "Create Java Service Wrapper" quick fix will add a new query to your template :

And your done !

Eclipse Helios - a whole year of goodness

2010-07-27T06:09:00.001-07:00

Eclipse Helios is a release, but it's also a complete development cycle in a global and distributed team of commiters. Since I choose 3 features I especially liked in Helios this kept bugging me : what is Helios to me ?

Helios will have its place in my memory, not the bits themselves but good things we had as a community.

1 - The Acceleo Community joins Eclipse.org and starts by using black magic to build bits

It's just the begining of this move but so far it went pretty well :)

2 - Eclipse Summit Europe is the best Eclipse conference to meet friends

3- The dreaded diamonds of the Simultaneous Release are still haunting my dreams...

4- Our friend Hudson is now serving way more projects, but not always happily.

5 - The Foundation keeps moving things forward

6 - EMF Compare rocked at Eclipse Con 2010

Last but not least, this Helios cycle was filled with more interactions with end-users and adopters leading to nice enhancements in Eclipse as a whole, thanks for your help !

3 Good Reasons to use the Helios Modeling Package

2010-06-28T05:31:00.000-07:00

Now that the entire world noticed that I don't know even one thing about soccer and I'm even trying to cheat, I should get back in sharing what I understand instead of those silly forecasts.

Helios has been out for a little while now, the mediatic storm is pretty much gone and it's a good time for me to have a look back.

This year one of my goal was : "I want to transform the Modeling Package in a product which I would use myself". I've been using it quite extensively lately and I'm pretty happy with the results, the Galileo package is far from being usable but the Helios version is just great :)

Why ? a few reasons...

1. because it's including hidden EMF goodness !

EMF generates code... which is good as any code you don't need to write means less bugs. But sometimes you don't even want to see that code !

If so, you're lucky, there is a specific filter for your workspace !

And the integration goes even further, code you manually changed is highlighted with different colors !

Oh, and you can compare and merge any kind of emf model, starting from the Ecore ones.

2. It provides Class diagram support

As a developper you always ends up needing some kind of graphical support for your communication, a class like diagram is well known by others, the modeling package includes support for Ecore thanks to the EcoreTools project.

And you even have specific views to browse your design hierarchy or usages.

While I'm at it, if you're interested in contributing to this project which is highly popular, you should really get in touch with Ed ! We're looking for fresh people to reboot this project, it's not as active as it deserves to be !

3. It's an SDK

As the modeling project provides a lot of high quality frameworks, you often need to have access to their source and as such it's one of the few packages providing SDK's.

All those reasons are making the modeling package the best one to get started with any modeling task but also any RCP development planning to leverage those great frameworks.

Oh yes, that should make this package a nice starter for e4 too :

post scriptum : 4. It's easily extensible

Of course the modeling community is way more active than that, I would strongly encourage you to have a small click on this button and have a try on the latest hot contributions which were not part of the Helios release the Agent Modeling Platform :

And the Papyrus UML modeler

And now it's time for you to download this package !

Forecasts Comparison For The World !

2010-06-28T01:04:00.000-07:00

I have to admit I know nothing about soccer. Yes I'm a french guy, but I know nothing about soccer. That said I'm not against having a few beers in front of this broadcasted green field and I'm always in when its about having fun with a small game leveraging Eclipse technologies.

Obviously I played with the EEF based rich client for the forecasts, and from the moment the source code has been made available I started hacking the code.

The forecasts, matchs and results are all kept in a model accessible through an http uri, and as EMF rule them all, find them, bring them all and in the darkness bind them, you can leverage any Eclipse Modeling component to hack something quite easily.

That's what I did with Compare.

I extended the EMF editor adding a specific action, "Compare with / Player with Best Rank"

This action allows you to compare your own forecasts with the best ones, and then merge your own forcast with the best player one (Noooo, that's not cheating ! )

And here is the user interface you get for free*, with a pure semantic comparison :

* you have to depend on EMF Compare though...

Here is the logic needed to launch the comparison :

I had to use a few tricks, I had to provide a specific match engine enforcing the match of two players, otherwise the Compare component stop matching the forecasts from the beginning as the players are differents.

That's all for today, If I can free more time for this hack I'll provide a diff extension to change the score delta representation to a more meaningfull one, so far it's left as an exercise for the reader ;)

Eclipse Modeling Survey results

2010-06-18T01:50:00.000-07:00

The survey has been going on for more than one week now and the trends are only enforcing themselves. Let's summarize it:

First, the audience represents many non-commiters (2/3) though the commiters are still quite represented. That's quite consistent with what I was expecting, the survey was published on the planet, some newsgroups and through twitter and as such targeting commiter or adopters following quite closely what's happening in Eclipse Modeling.

Concerning the package size, we're right now at 250MB, it looks like it's mostly ok but being a bit smaller would still be nice.

As the package is an SDK we could probably drop most of the dupplicated javadoc in the plugins.

This one is interesting, it's something we're hearing and hearing again at each Eclipse conference, users do want more documentation, moreover best practices are hard to reveal through the wiki, newsgroup and online help jungle.

There is probably something to do here but, hey, there is an EMF Book already, an Eclipse Modeling one and everybody can contribute on the wiki, so why isn't this urgent need covered yet ?

It might be because:

People are not even aware of these books or books are old fashioned now : all content should be on the web !
It's so hard to understand what each project is providing that one really needs some Modeling Guide.
As a user you always want doc even if you won't ever read it, it just gives you the confidence that the technology is not going to vanish in a glimpse.
[ ] <----- any opinion expressed through the comments

It's even more disturbing when ...

yes, most people would be willing to give time to make this happen. We might need to do something here, maybe crowdsourcing the doc would do the trick... What is pretty sure is I wouldn't like it if Eclipse Modeling commiters spent half of their time documenting : we should make it easier for the adopters to contribute back.

And yes, writting doc and books takes a huge amount of time !

I asked another related question in the survey about "examples". In fact examples are way easier to provide and in my opinion are more valuable in most cases. And when you look at it, each project is already building its own examples, but these examples cannot be composed in some way. Just like Toast is a best practices application for OSGi, we would need a modeling one.

At its beginning the Amalgam project was providing some; yet since these examples were not part of their target Eclipse project (EMF examples in EMF, ATL examples in ATL) they were not maintained correctly. As a result they are not reflecting the "state of the art" of Eclipse Modeling anymore... Maybe for the next release !

I'm done for the strong trendes, others questions like "Having on the shelf design and generation tools" or "Domain focused UI instead of component focused one" were quite uncertain.

A few more ideas or questions have been given through this survey,

It will take another blog post to describe those.

Thanks again for your feedback !

Eclipse Modeling Package Survey

2010-06-09T23:49:00.000-07:00

I've been quiet in the planet lately, it doesn't mean I've been inactive, quite the contrary in fact, just like all the other commiters I've spent the last few weeks polishing the Eclipse Modeling Helios release. (As a sidenote, I'm giving more update from here --> )

And now the final bits are almost here ! More info about what's new in the Modeling Package soon, but you might have already seen that we have a pretty good feedback :) .

Helios is almost public now, we're already wondering what shape Eclipse Indigo will have, and to do so I'd like to have your opinion. I compiled a tiny survey, 6 questions you can fill in seconds.

I'f you're interested in Modeling in General, and Eclipse Modeling in particular, please spend the next seconds filling this survey.

the survey is embedded in the post or accessible here

Compare/Helios - Every Second Counts

2010-04-28T05:43:00.000-07:00

I tend to break a lot of keyboards. Not because I release all the aggression that I hold deep within me on them, but because I drool testing the product Obeo is going to launch really soon now.

During EclipseCon 2010 It struck me that some keyboards might have died because of EMF Compare. Ok, no more drooling here, the colors are nice, but when you are using compare with pretty decent models (like thousands of elements) you end up thinking it could be faster.

Hold your breath, order your very last keyboard which you'll use for a long time now, Compare's scalability has been improved a lot both in terms of performances and memory.

This work was pretty focused on the matching pipeline, there is room for improvements in the other parts of compare (especially the UI) but the matching was just so obviously slow and is even called 2 times for the 3 way match. That wa just making sense to fix things there.

The performance test case is using UML models containing 1,000 to 256,000 elements organized in a decent way and is matching them several times, here are the results before the scalability sprint:

Yes we have quite a strange value for the 1000 elements model, after investigation it looks like it's just some kind of corner case.

The last models have no time result for the simple reason they use all my memory and I end up with this dreaded OOM error.

Here are the figures after the sprint:

Now I can feel from here that you've been thrilled by all these figures and you only want one thing : to get your hands on this release. The Helios M7 release will be a good time to do so, wait for a few more days and go ahead: give us feedback !

Not only will the Helios release provide these major performances enhancements but the future looks even better: Stefan will work on a new match engine implementation focused on scalability for his google summer of code.

Waking up as every morning, getting up but being a bit happier than usual as I know I made progress on something important for adopters :)

Please, keep in mind that your feedback made me work on this, thanks again.

I'm a poor, lonesome cowboy ..

2010-03-26T00:54:00.000-07:00

I'm a long long way from home.

And this poor lonesome cowboy.

Has got a long long way to roam ...

That's right, EclipseCon 2010 is over, each year it gets better and better and leaving it is always a bit sad.

I'll use this blog post as a memento of my feelings and the things I noticed during this week:

Many people are using EMF Compare. That should not be a surprise as it provides a key feature for anybody working with models, but still it gives me a warm feeling :) The ECon attendees provided me a lot of very relevant feedback, among others it looks like scability is not so nice when one is using a big model. Don't worry, I'll work on that (In fact I already started) and you can expect a performance boost, even for the generic engine. More of that in a future blog post with figures.

People are now used to the idea of e4 is going to exist, it will provide new means for writting application, I also have the feeling that people understood that e4 is going to be what WE as a community, wants it to be.

Chocolate fountains are not mandatory, but some bugs will always arise.

ATL is definitely THE model to model transformation language, it's mature, and now thanks to William's work the tooling is a bit closer to the perfection.

CDO is one of the most amazing framework I had the change to use, it's quite unbelivable that such a small and slim framework can provides you such a power. You need years of engineering and professionalism to achieve this. congrats to the whole CDO Team !

I have a lot of hope for the Mylyn Review project, the approach is simple but perfect for people like me, it will just be "yet another key feature" of the IDE. In fact the whole Mylyn project is providing, as usual, innovations.

The Sharks Rocks ! They blasted the Dallas Stars ! And I guess I'll be more interested about hockey now :)

Pascal has not been abducted by aliens, he is still the same although being transformed in a Maven guy now.

Modeling is everywhere. It's just pervading on everything : from your IP Log to the next generation platform you'll rely on.

End users really appreciated the work I did on the modeling package, Here again, thanks for your feedback.

Xtext was everywhere, and will be a key asset for the upcoming IDE generation.

The Eclipse Foundation did a tremendous work for this event, and it' s been perfect ! Thanks again !

Acceleo is so powerful that many people expressed their wish to use it for their code generation needs : step one on the "taking over the world" plan is validated.

Nasa, Rockets and Robots are cool.

The Architecture Council is taking more and more initiative and Martin is doing a great job driving it.

Now that EMF is everywhere everybody wants to use EEF

Huge companies like SAP or Thales are building their tooling strategy around Eclipse - not only as a platform but also as a community.

I already said "No" to my manager at least two times !

Such a conference in an hotel can work, and it's actually even better than in a Convention Center, we have nice couch, a bar, it makes discussion way easier.

Having tutorials in the morning during the whole week is great, then you start smoothly, learn things and code : I can fill my addiction.

It's possible to create a conference program of high quality (the best I had in the previous four years to my opinion), with such a diverse community. Kuddos to Oisin !

I'm pretty sure I'm forgotting things, but anyway, I really need to sleep now...

In a nutshell : the best conference ever :)

Diff, Merge and Patch your Models with Helios

2010-03-23T23:12:00.000-07:00

Ok, you're stuck at home, you are one of the numerous budget shortcuts victims ? You did not had the chance to come at EclipseCon ? Here is some kind of transcript of the talk I just gave:

This talk will tackle team-working with models. Once you use models in your development proces, they matters as much as the source code. Don't you want to be able to diff, merge or even patch your models just like with text files ?

The good news is that unlike text files models have a semantic structure defined thanks to their ecore model, as such we're able to semantically compare the models, comparing the serialization (XMI or other..) is often meaningless.

By the way I'm the project lead of EMF compare, the project has been contributed in Eclipse in early 2007, at that time many EMF adopters realized that this piece was missing in the Modeling ecosystem and this lack was often a blocker !

So here we are, three years later. EMF Compare - in the EMF Technology project at first- graduated and is now part of the EMF project itself !

Just like Transaction, Validation or CDO, Compare is one of the many pieces you can reuse as a framework, or just as a tool. Its focus is quite narrow : comparing, merging and patching any kind of EMF model, the later being an UML model or a domain specific one.

As we graduated we've been focusing on keeping stable API you can rely on. We really think that EMF popularity is highly due to the fact that depending on it is easy as it is completely forward compatible. Working nicely as a pure Java jar library is another key asset of EMF, we tried to stick to that for the Compare project: our framework can be used as a Java jar, not depending on Equinox or any extension point.

We could phrase the Eclipse IDE spirit in : be extensible, be customizable, be integrated. We are sticking to this motto too, you can extend or customize any part of the comparison process.

The compare and merge features are completely integrated with the Eclipse Team API. When you launch a comparison from the workspace or from an history, if the file is in fact a model, EMF Compare will be opened and will show you the differences, allowing you to merge, or switch back to the serialization diff.

Let's have a look on the tool through a demo. This demo goes higher and higher in coolness, as such it's starting by comparing an old fashioned UML model on a dying CVS Repository.

A bit more cool : comparing a domain specific model on a SVN repository.

Total coolness : comparing an XText DSLsemantically, merging it, on top of a GIT repository !

That's just the tip of the iceberg, EMF Compare has a few more features and is especially useful in a lot of contexts, rather than listing all these details I'll focus now on the inside, revealing you which kind of magic make this clock ticking.

As I said at the beginning, the good news comparing models is that we've got semantic information we're not comparing plain text. There is a drawback though: models are graph and as such being able to match similar graphs is a complex and tricky problem.

The first thing we have to do for a comparison is to match the elements from both versions of the model.

If you've got ID's that part is trivial, EMF Compare will use your ID's (either business one or technical ones). On the other hand if you don't, we are providing what we call the "generic match engine", this engine uses a few statistical metrics to match the elements.

For a given element this engine will extract it's type information, the content values, its relations with other elements and its name if we can detect one. Each piece of this extraction will be compared with other elements to compute a similarity coefficient, from this one we can try to get closer and closer to the perfect match.

Once this engine has done it's job, it provides a Match Model grouping all this information and weaving the other models.

It gets more complicated, (and then more interesting) when using source control management systems. Then you have to match three versions of a model: yours, the remote one, and the common ancestor between those versions.

To do so we builds two match models, between your local version and the common ancestor, then between the remote version and the common ancestor, and we combine those two match models into one, weaving the three models altogether.

At this stage it should be obvious that the faster the match engine is, the faster you'll get a result.

To be honest the generic match engine is not so fast, having little clue about the models it's matching it spends a lot of time browsing the structure, trying to match things which probably have no possibilities of being the same..

Being aware of that we eased the definition of your own match engine specific to your Ecore model. In doing so no doubt you'll get better results and way faster.

Let's take a step back. What are we trying to do ?

We are trying to change two versions of a graph into a set of events, in reality we are trying to re-construct "a posteriori" the history of the graph: what changes have been made to transform the original one to the new one.

Match computation is done by the Match Engine, the Diff one by the Diff Engine. This processor has to provide a Diff Model from a Match Model.

In fact, when you have the MatchModel, deducing the DiffModel is not a huge task, you basically have to browse the matched elements, checking for changed attributes and reference, and then create for each "unmatched element" the corresponding deletion or addition event.

Here again, you can plug in your own diff engine, and you can even define your own diffs specific to your formalism. Instead of having a "stock value changed from 12 to 34" event you can define yours as being "stock value has been increased from 12 to 34" and even aggregate several atomic diffs in a single top-level one.

Being a first class model itself, the diff model can be leveraged through model to model or model to text transformation to publish the changes to another format.

Now you should have a basic understanding of what EMF compare is trying to solve and in which way. We've seen that stability both in term of API and code was our primary goal right now but does that means nothing new is being done in Compare ?

For Helios we fixed many issues thanks to the community feedback, support for fragmented models and matching of referenced resources has been greatly improved.

The primary feedback is bug reports, but we also had quite a few contributions among those a new API to scope the matching process and a whole new set of plugins to create model independent diffs resilent to transformations in the model you want to apply the diff on.

So many things to discuss in such a short time frame.

Give it a try, EMF Compare is part of the Eclipse Modeling Platform SDK, download the package and you're done.

I would be happy to discuss with you, either IRL or through electronic means. Please uses the EMF newsgroup, the bugzilla or the #eclipse-modeling IRC channel on freenode. We're also available and new trendy channels like Twitter : @bruncedric.

Want's more ? Have a try downloading the Eclipse Modeling Package !

Modeling Project Runaway : ATL

2010-03-23T15:30:00.000-07:00

"Modeling Project Runaway" was the talk you had to attend to get a vision of what is going on in Eclipse Modeling and more especially how lively this community is. The talk was even too short for EEF to get in but this project had his own talk yesterday.

Ignite style event, I did a quick demo of the new features in the ATL tooling. ATL is a model to model transformation language, it's incredibly powerful and usable in many different contexts. It allows you to transform information from a formalism to another one or to refine a model.

ATL has been around for quite a long time in Eclipse and has proven to be quite mature. Nevertheless great new feature have been added this year !

The tooling editor has been reworked providing now content assist every where, hover tooltips, "open declaration" and even code templates to quickly get started.

A long awaited feature is the "refining mode", in this mode the transformation is directly applied on the loaded instances of the model, you can then use an ATL transformation as a refactoring script and integrate it in your editor, before the synchronization could only be on the Resource level, forcing you to save and then reload the model.

Acceleo is providing you a Java API to launch your code generation, ATL is now providing you the same thing ! It's then trivial to launch ATL within any other tooling, just use the Java API, furthermore you can even launch it as a standalone Java application !

Demo time !

By the way ATL is one click away from you, just install the Helios modeling package and use the discovery UI to try this out !

Eclipse Amalgamation 2.0

2010-03-17T01:52:00.000-07:00

I'm waiting for a nightly M6 Modeling package to get downloaded on my laptop. As I've got a few hours to wait getting it I'll use this chance to give news about the Amalgamation project.

It's a well known fact that the Eclipse Modeling Project is myriad of small focused projects, Kenn is working on sanity checks for each of those project, more than 50 ! The benefits of this organization is that you can choose which bits you want to use depending on your use case but this flexibility come to a cost: making sure there is no overlap between proposals is often tricky and making sure those projects taken as a whole are providing a consistent platform is even more challenging.

A few years ago the Eclipse Modeling Amalgamation project was created and started by providing Eclipse distros tailored for specific needs and an "All Eclipse Modeling in One Package" distro through EPP. At some point the project staled and during last October a new team gathered and I've been designated project lead.

Most users and adopters are consuming the Eclipse Modeling Project through the EPP package, one don't have to figure out how to browse and install the projects you need. But this package was including all of modeling, as such it was huge, cluttered, un-tested, and nobody could really use it.
Downloads of the package felt down and the Eclipse Modeling project has a whole probably suffered from that.

My first objective for the Amalgam project was to update the package to get a sane one : changing our big messy package to an Eclipse Modeling SDK composed of the core runtime components and framework :

EMF core and its low UI profile companions : XSD, Transaction, Validation, Mint and compare

Graphical support with GEF and GMF runtime

OCL and UML2 : you can't really live without those standards.

CDO : it brings EMF - as a framework - to another level with collaborative editing and remote model repository.

This set of features + Eclipse SDK and Mylyn is composing our new platform, and we went from almost 400 to 250Mb. It's still big but hey, it's an SDK !

Still, many more great and useful components are built within the Eclipse Modeling Project and getting those to install was painfull. Mylyn was already providing a solution to that : a discovery UI :

In the meantime during the year this discovery support has been moving from Mylyn to P2.

As a user, having this UI makes my life easier, I can install components without even thinking about where I'll find the pieces and P2 is taking care of the requirements and consistency of my Eclipse installation, I'm looking forward to hear from your feedback about it when the M6 Package will be out.

This modeling platform is a basis we'll test and polish to get a streamlined user experience and we'll have to organize ourselves to make sure to release a tested, used, and clean platform. The Eclipse Modeling Panel will be a perfect time to give your opinion and feedback, do not miss it, it's on Monday !

Its time already !

2010-03-11T08:31:00.000-08:00

You're a computer science or engineer student, you love open source and would like to be involved in one of the greatest OSS project of all times ?

You're lucky, the Google Summer of Code 2010 is starting and is a perfect moment to join the Eclipse community.

If you're a commiter you can throw your idea on the wiki page, if you're a student contact the development team or provide your own ideas.

I provided a few of idea, here are those who got most of the votes at Obeo :

EMF Shell, This one is geekish : providing an environement with "shell like" commands to manipulate models. One would expect wc to count model elements, grep to filter models elements, cd to move within models, ls, sed to substitute, and all the other commands which could be useful in this context.
Haven't you ever dreamed to filter the opened view of your e4 modeled workbench using grep ?

Now that SWT-QT seems to be a reality, I can't prevent myself to dream about a GEF port on QT. QT has amazing graphical capabilities and provide the best performances on every platform around there. GEF is great, but is it ready for next gen graphical modelers ?

Go and have a look on the demos. That could be a game changer for graphical modeling let's call it CuteGEF :)

Of course Modeling in general, EMF Compare and Amalgam topics are on the wiki page, you have plenty of subjects to choose from !

Please, if you're a student and are interested in participating to the GSOC, do not wait ! Work with the projects to prepare your application !

Ecore In Colors (In Motion)

2010-03-04T05:25:00.000-08:00

Speaking about Ecore In Colors, If you're interested in here is a small flash demo showing the kind of interactions you can specify in a Viewpoint Specification Model and the resulting modeler you get :

By the way, Freddy convinced me to join the Twitter community (at last! ) its going on here.

Unusual Propulsion System

2010-03-01T00:40:00.001-08:00

It's been more than four years now since I joined the just founded Obeo company and started to be involved in the Eclipse Community. I had the chance to join one of the few French companies integrating the Free Software and OSS movement in its business model and plans.

At that time most companies were keeping an eye on this movement from the side, not getting involved more than by consuming what the movement was producing - that's all.

My choice was not a hard one at that time, it wasn't hard to find a job as a software engineer but it was hard to find a FOSS focused job within a company having realistic plans. Any outcome for this journey would have taught me a lot.

Since then, the river froze for many around the world, every day is providing evidences of this.

But the river being frozen and nobody going there doesn't mean you should not or could not go !

An unusual propulsion system can lead you to amazing places.

Despite the cold and without any kind of VC's heating, Obeo grew from a 4 men company to a 40 men one.

The Eclipse/Obeo relationship is a symbiosis. Obeo's involvement in Eclipse is huge : we're the unique french company being a strategic member of the Eclipse foundation, leading Amalgamation, Acceleo, SCA Tools, EEF, EMF Compare and working extensively on other key components like ATL, GMF, OCL, Papyrus, SWTBot. We're doing so in a completely open and transparent way : contributors among others.

We're working a lot for the community, but we are earning back in many ways : Eclipse is our unusual propulsion system. Thanks to everybody, from the users to the contributors and the foundation staff for making such a journey possible.

Thanks to Jean-Luc for the awesome Kayaks trek and pictures :)

Ecore In Colors

2010-02-08T07:58:00.001-08:00

I landed on a few articles about "UML in Colors" lately, I enjoyed reading those as modeling is used here as a design tool and support for efficient communication. It also made me think : that's a nice use case for our extensible modeling environment !

The Amalgamation book is already describing how to define your own "Domain Neutral Component" model and create the graphical modeler thanks to GMF. Let's take an existing formalism for a change and as I like Ecore, I'll pick Ecore.

Here is the diagram editor before the extension, quite boring isn't it ?

We'll add an "archetypes" layer for the Ecore modeler, this layer only contains a specialization of the container mapping definition used to display the EClasses in the Ecore modeler.

Specializing the diagram definition is mainly about adding a few new conditional styles (for the colors) and a few tools in the palette. I decided to use Ecore's annotation to keep the information about "being an archetyped EClass". Here is the full definition :

Let's have a closer look on a few user interactions : adding the original EClass mapping in "extra mappings" of the tool definition allows me to define modeling assistant accelerators to contextually change an archetype:

I also used the tooltips on my tools to help the user identify the archetypes :

And here is the final result !

Of course not a single line of code is needed to get this and the modeler specification is automatically deployed adapting the original Ecore one.

Enjoying the colors ? ;)

Eclipse Modeling Gems for Developers

2010-01-07T01:34:00.000-08:00

Eclipse is the best modeling platform around there, even god knows that. What people tend to ignore is that fact that the Eclipse Modeling components are focused on providing framework and tools to actually get some work done, to write better code quicker, and not necessarily model just because it's fun and you can then print huge posters in your office.

What does that mean ? That means if you're writing code you can be pretty sure Eclipse Modeling might help you, do not wait to long to have a look or you'll waste your time and you'll regret that sooner or later. All those gems are available through the Eclipse Modeling bundle and might help for your daily development tasks. I submitted a standard talk for EclipseCon to demonstrate how the Eclipse Modeling Projets might boost your productivity when you integrate them in your development process just like the JDT, PDE or Mylyn, if you want more info, ask for it through the comments! I have no doubt Oisin is wrapping up a great event renewing its spirit; I'm looking forward to it !

To make this post worthy for you, I'll briefly take a spin to one of those gems focusing on pragmatism : Acceleo. Acceleo is all about helping you to generate code in a consistent way, within Eclipse, in a glimpse. To do so you usually use a template language and use some kind of expression substitution. Here the template language is quite powerful, templates might call others and a template might inherit another one. The dispatch to the templates is dynamic depending on the instance type (more specific first) and on the evaluation of any precondition on the templates (That helps you design your templates in a maintainable way).

Enough said about the language, lets focus on the tooling to see how easy it is to leverage it for your coding. Let say you've got a specific pattern you reproduce quite a lot in your code and you don't want to bother writing that code again even if you need it, then let's generate it !

What we've seen is that most of the time you start with an example, and here the example would be the code you write all the day. Acceleo provides a specific tooling to help you starting a template from an example :

In this video you'll see the new template wizard with the option to initialize it with an existing file content, then I'm leveraging the search & replace smart completion to quickly transform the example to a real template I can apply on a model (notice how the "for" closing brace completion auto-magically find a coherent place, it's using the text structure to do so).

In a few minutes you get a first working generation tailored to your specific needs. Of course here it's Java but it might be any language using any framework !
As a sidenote the generation engine allows you to define protected areas in your template allowing you to generate code you can then update by hand and then re-generate without loosing anything.

Stay tuned for more gems.

Eclipse Summit : here we come !

2009-10-26T03:50:00.000-07:00

I'm polishing and putting the last touches of goodness in my slides for Eclipse Summit Europe. I'm looking forward to a great event as usual, with this warm and fuzzy feeling you have realizing you're part of such a vibrant community.

If you are wondering how "we" - the Acceleo projet became "we" the Eclipse Project, do not miss my talk :

ESE, even more than EclipseCon, is a nice moment to learn more about all the technologies available at Eclipse and to exchange with the teams behind those. I'm going to catch you : " projects I'm particularly interested about ", and ask you questions, even dumb ones ! Please take this chance to do the same about the Eclipse Modeling project !

Exploring Eclipse Plugins: beyond Terra Incognita

2009-10-09T06:54:00.000-07:00

In software engineering the "Terra Incognita" boundary is never far away from where you're standing. Most software are lacking an "overview" documentation or model and you have to open your path yourself through the code trying to understand what's going on.

That's especially true when you are analyzing a legacy application in some kind of good old language not being considered, these days, as hype as SCALA . COBOl, NSDK are examples among others, reverse engineering become a requirement and at Obeo we are working hard providing tooling so that our customers are able to understand and migrate to other technologies.

That said you don't need a flux capacitor requiring 1.21 gigawatts of electrical power to have this "understanding" issue with technologies. It's still a problem with the application we're building using 2009 ones, let's take the OSGi Bundles for the need of the demonstration.

I already did a draft implementation of a tooling easing the exploration of Eclipse plugin years ago using GMF, and we've got this nifty PDE visualization tools based on ZEST, but I was in the mood of trying again to build a tooling from the following principle:

construct and explore step by step

Now that we built this cool technology enabling you to design your own modeling environment, I decided to give it another try.

Here is the result, please note that's a one day work and the underlying runtime is in development (you might catch a few bugs during the demo). Please also note that the demo capture software is not so friendly with the original color, we are rendering the diagram with more than 256 colors ;)

The legend is the following :

The plugins model is captured thanks to PDE APIs, we're going to explore the Eclipse plugins starting from Mylyn, building groups, and seeing what kind of relations those groups have with each others : dependency and/or extension.

So now the next step would be to build the whole Galileo Map step by step, anybody feels like a 21st century Magellan?

Here are a few extras :

EMF Core dependencies

EMF Core extensions

Acceleo.org standalone plugins

Ok, that's Friday and I'm kinda lazy : no text annotations in the demo for now, may be later if I've got thousand questions through the comments..

Having more control ...

2009-09-29T06:57:00.000-07:00

Who never asked for more time to focus on things that matters, like, for instance, gigantic barbecues ?

And then you fulminate against this tool which should help you and which is not,it's just another burden placed on you to provide this documentation nobody will ever maintain or even read. Is that what modeling is about ?

Life as a software user is often harsh, especially as you have, most of the time, no control at all on the software you use. As a developer it's even more difficult as you have an idea on what's going on behind the scene, and not having control is something you just can't handle now that so much open-source products are providing you this power.

If you had control on your tools, if you could adapt it or even easily define it, then you could focus on useful things. Modeling can bring it back to you, not modeling like in UML Modelers, modeling like formalizing your domain model as a way to capture your though or your coding tasks.

A Model doesn't have to be high level, a model doesn't have to provide as much information as your source code, a model is just here to help you answer questions about what you're doing.
If you can't say, for a given model what kind of questions it's helping you to answer, then your model is just not relevant, it's not a model, let's call that boxes with edges.

And now let's take a small example, you wants to define a software using components which are providing services, then you wants to assign these "logical" components to Eclipse plugins, here is a model definition you can come up with :

From an instance of a model you can answer the questions : how is split my application ? what services are provided and required by who ? And how these components are linked to the Eclipse plugins I'm coding ?

From now you can either capture an instance and start working thanks from EMF Dynamic support , or specify a tooling to ease this capture. If a diagram is a good representation for your problem, pick it, if it's not, pick a tabular, tree or even textual representation.

The following demo describe a tooling specification (click on the image! ) at the top, the specification, at the bottom, the tooling which is dynamically adapting itself to the specification.

Modeling itself is useful to organize your though, validate your design or even can help to pick the best trade-off for a given architecture. In a old post I was showing how a modeling tooling having support for viewpoints is powerful in this regard. The next demo is showing you how the developer or analyst, can then leverage the tooling definition (click again !) :

Now you described everything and you're quite happy with the result, why not using this information to help you produce code ? As soon as the modeling environment is linked to the development tasks with code generators, the model is not going to be deprecated, it will be used by the team to get the tedious work done.

Moreover when the environment provides you navigation from your code to the model, then to the code, and support for customizing anything in the generated code, then the tool is no more a burden, but a relief. (yet another demo !)

It's been 3 years now since I arrived in Obeo, and every tool we developed since then has been designed following this motto : "Having more control, not getting in the way and providing value to the developer."

So far I'm quite happy with the results :)

ps : thanks to Jérôme who did the démo

The 09/09/09 09:09 0.9.0 Release

2009-09-10T02:32:00.000-07:00

Laurent did it not even on purpose, but the latest Acceleo I-build, which is the 0.9 branch, performed well and has this golden qualifier :

So If you're superstitious or a numerology believer, don't miss such a release !

As a sidenote, the Acceleo Team will be at ESE with the talk : "From Acceleo.org to Eclipse.org" And the EEF project, first consumer in Eclipse of the Acceleo Technology will present : "EEF you want sexy properties ..."

If you're interested in the model power, EMF goodness, modeling environments, viewpoints based modeling and/or the Eclipse platform in general, let's meet in Ludwigsburg!

Let's take a step back ...

2009-08-05T01:11:00.000-07:00

Lately I had to step back a bit and have a look on what's going on in the software industry. I think most of us did that lately as big players moved their chess pawns and many new technologies seems to have gained some kind of maturity. Many events happened in the last years being evidences the game rules are changing, are all those web apps white or dark magic ?

First we've seen this "Web 2.0 move" and what they call "social software" or whatever, then every single app the "base user" would need had been ported to the web, and now most parts of the "meaningful" data are hosted on private servers all over the world. From the beginning, as an FOSS advocate who thinks that freedom matters more than anything else I was really standing against those apps.

Moreover from a technical perspective I couldn't say it was making sense: considering your app container is a web browser, I mean, it's so poor !, that's something which is supposed to be *document centric* and not *interaction centric* you can't really expect more than "drag& drop" from a webapp !
And what's that idea of transforming personal computers to terminals ! It took years to go away from that nonsense and now even the cheapest computer has so much resources ! I'm not even speaking about the "you've got no choice than being connected to the WWW " statement. But now we can say those apps were representatives of a real need for user: another shoot in the software landscape.

But well, things changed quite a lot, the technology grew and Google played a big part in most of those changes, some webapps are now supporting offline mode, user interfaces and interactions got richer, we've got, at least, a pretty good copycat of 90's user interfaces and as nobody really jumped from that, even on the desktop ...

And now I'm facing this big paradox, most of the G-technologies are so cool and well designed I would love using them from a daily perspective, just a quick glance at what Tom is doing or to the E4 effort is enough to make me feel "whoa, our stuffs are so old fashioned, am I no more a cool kid ?". This path I was considering as doomed have been made brighter by complementary technologies, gears for offline suppport, GWT to be able to maintain this crappy Javascript and provide nice interactions , an many more enhancements.. And though, I keep thinking that most people would prefer using a desktop app if it would manage to tackle the main webapp assets :
- one click, it works and everywhere (which is mainly in the case of web aps : register and you're done)
- no re-install, maintenance should be invisible
- don't care about your data, we're taking care of it

and the main point, in my opinion being :
- you can share and collaborate with others without even having to care about it !

Those points have been missed by desktop apps, and those points could be done with an approach protecting privacy if the people doing it have no interest in trading information. Eclipse is a platform with a great potential especially concerning the "run everywhere, easy install, update and maintain statement", the "collaboration" aspect is probably the one needing much more love to make our favorite project blossom in the following years.

And now that I washed my mind writting down these opinions I never really had time to organize before, I'll try to focus my activities around those concerns to make Eclipse easier to use, install, and moreover supporting multi-tiers share and collaboration.

Let's jump forward !

Feedback from IT companies leveraging Acceleo

2009-07-17T02:42:00.000-07:00

The first Eclipse Acceleo Day took place last week and was a pretty nice event., no doubt we'll organize others like that :)

The day started with business feedback about Acceleo deployement and Model Driven approaches in IT units, more especially Cap Gemini, Atos Origin, Orange Labs and Bull. These big IT companies used different approaches to get a higher software quality, quicker, and even more important : easing the maintenance. Each of those approache was valid and was meeting their final goal and Acceleo was a big asset which is really nice to hear when you're part of that team :)
Slides will be available on the event program page.

I really can't summarize all the discussions and presentations in a single post, have a look on Goulwen's report which is way more detailled, but there is one feedback which need to be emphasized : Model Driven Software Development might sound like a big "corporate" expression quite far from the developers actual concerns which is about agility and quality, but it is not.

Using models and leveraging them with code generation techniques is just about that : bringing agility to your development process. With tools like Acceleo which are fully integrated in the Eclipse IDE, the developer has the power to build software systems quicker and better. What we've seen is that most companies are organized in "one transversal team creating the modeling environment and the corresponding generation templates", thats a common organization when a company want's to capitalize over its tooling and templates.

Keep in mind one thing : we are building tools which are making the task of creating of such a modeling environment (modelers, code generators or transformers) so easy, that a developer is able to do it quickly, even just for a single project. You might have a big boost of productivity, quality and consistency on your code just defining a small set of generator templates perfectly tailored to what you want.

So people claiming that Model Driven Development is incompatible with Agile Development are just plain wrong, the tooling supports this kind of development and make it easier, it will just depend on the organization you pick : if your goal is about defining a process for your whole group so that you get quality and consistency over all your projects, then go ahead with the transversal team and keep in mind you'll have to work on your tooling a lot more to handle all the projects use cases. If you just want to build a given software quicker and better, consider defining a tooling in a few days as it will make your life, as a developper, way easier.

Eclipse Acceleo Day is going on...

2009-07-10T05:38:00.000-07:00

Eclipse Acceleo Day started this morning. The event is collocated with the "Libre Software Meeting" at Nantes (France) . Yes, that's right ,we're part of this huge and lively movement which is free software.

So far the even is going fairly well and many people from convinced users to modeling sceptical ones are attending. Getting feedback from the end user is always valuable.

I'll keep the Eclipse community in touch with what's going on here, thanks again to Freddy who organized the event and to the foundation staff for their help !

Galileo Modeling Package is Here

2009-06-23T07:58:00.000-07:00

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 !

Quick glimpse at Galileo Modeling Package

2009-06-16T03:30:00.000-07:00

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 !

Viewpoints-enabled Modeling Tools

2009-05-29T05:37:00.000-07:00

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

The 20 minute Graphical Modeler based on Eclipse

2009-05-13T10:02:00.000-07:00

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

Live Models Using JBoss Rules (Drools) and EMF

2009-05-05T09:03:00.000-07:00

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

Award Winning Acceleo moving to Eclipse

2009-04-24T05:55:00.000-07:00

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 !

Modeling your EclipseCon

2009-03-25T13:49:00.000-07:00

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"

Eclipse Modeling Summer of Code 2009

2009-03-10T08:46:00.000-07:00

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 !

ShuangXi effect : UI testing and documentation

2009-03-04T05:23:00.000-08:00

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

Engineering dictator strikes back : querying your team repository

2009-02-17T08:44:00.000-08:00

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

2008 was full of excitement,let's make an even better 2009 !

2009-01-21T01:31:00.000-08:00

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

Back from ESE 2008 : WOW !

2008-11-25T22:05:00.000-08:00

I'm now back to France after this great conference. Ed covered the "modeling events" quite well already but I can't prevent myself from sharing my pleasure as I'm still filled with excitement !

My overall impression on the conference is that it had many clear signs of an active, innovative and enjoying community. No doubt E4 has its role in this whole "refreshment" thing, the debates in the symposium were more than interesting and I've no doubt such good and skilled people as those involved in E4 right now will come up with a great platform. In this regard, Tom's talks were more than interesting, keeps doing the fun stuffs !

The "modeling is crap" statement has been repeated quite a few times during the various talks, Ed described and analysed such misconceptions, models will rules the world ! Resistance is futile !
More seriously, I have the feeling the message "modeling is not UML" was really getting in, thanks to Ecore and all the amazing projects under the Eclipse umbrella, you can define your own DSL and quickly develop your tooling or adapt existing tooling around that. That's being agile !

On the other side of the barrier, Eclipse is now able to compete with profesionnal UML tools thanks to Papyrus (and one a sidenote EMF Compare ;) ) This quality of tooling was only available in commercial tools before, things are changing !

Speaking about EMF Compare, I was amazed to see how many people reused this project or integrated it in their own tooling. Getting this kind of feedback is not easy, especially with the newsgroup as you mostly only get the "This stuff seems not to work" messages, ESE is a great place to meet your user base :)

Getting to ESE using the "night train" was not the best way to rest, but the modeling symposium was perfectly handed by Markus and the tiredness quickly disappeared.

Then the talks took place. High quality ones for sure ! That's a shame we have not been able to provide slots for the many good other talk submitted, let's hope we'll have more slots next year !

Summit also mean socializing ! Many people, many beer, good food, it can only lead to a nice reception :) I even hacked a bit with Sandro from the JCR management project which is really cool. How is that possible that all the guys working on models repositories are so friendly ?

I also chatted a bit with the whole Eclipse marketing effort !

Then many more talks, chats, with many other Eclipse project :) Time gets away too fast, and we were already having a last modeling beer at the Nestor hotel !

See you at EclipseCon !

How much computer scientists do you need...

2008-11-06T10:17:00.000-08:00

To setup doors for a bathroom ?

At least 2 model driven enthousiasts + me !

And tadaa !

Thanks again for your help guys :)

"Babies are such a nice way to start people"

2008-11-03T09:11:00.000-08:00

I did not blogged a lot lately, several reasons for that:

my web hoster decided that I had too much spam on my blog and destroyed the whole website with all its content :S
I had a few weeks of vacation, a good chance to rest you'll say ! Well.. not really as you'll see with point 3 and 4 ;)
in order to compete with Ed's incredible garden we decided to bought a house, so expect many more metaphoric blog posts with home made pictures!
And at last but not least : Gaspard (Casper in English) joined us after 9 months of ecstatic waiting

That makes many good reasons to justify my lack of "mail answering" the previous weeks don't you think ? :)
Now let's work on those mails and prepare this great incoming Eclipse conference !

(The title is a quote by Don Herold)

Amazing forest

2008-03-25T15:24:00.000-07:00

Open-source projets are similar to tree in some ways. They are living through time and slowly but steadily growing, being much and much impressive and at some point far bigger than what people expected from the beginning.

But they face aggressions from diseases, insects, industrial limber and are even in competition to get the needed piece of sun not to collapse. The license act as a protection concerning all these attacks, following the example of the Sequoïa’s tanin, the GPL protects the project from massive industrial exploitation without couterparts, and even if the people changes, the tree keeps groing up.

But even big trees may fall if the roots are not deep enough, and like the sequoïas we would not even know the tree has fallen as the tanin keeps it alive for hundred years on the ground.

So, what kind of roots do we want now?

Chocolate commit

2007-12-16T15:12:00.000-08:00

At workwe have a rule : if you commit something which does not compile, or that cause failure of the build, then you haveto bring back a chocolates candies box.

Many “chocolate commits”happened lately and we manage to always get a candy for the coffee break. As I’m working on a quite tricky project I’m thinking ahead and I did prepare chocolates this morning.

The recipe is quite simple :

dissolve/melt some chocolate
waita bit ’till it’s quite solid
maketiny balls with the chocolate
rollthem in sugar
rollthem in hot really black chocolate
rollthem in cacao powder
waita bit ’till it’s totally solid
commitsomething using String.isEmptyfor instance, be sure someone notices the mistake fast
bringthe chocolates !

Modeling at ESE 2007

2007-10-11T16:33:00.000-07:00

Eclipse summit is almost over now, a lot of things happened and the modeling project is, for sure, really lively.

Many talks were targeted at people interested in models, great tools and business cases using these tools just show you may benefit using models. On a more personnal side the EMF Compare talk went really smoothly, the room was crowded and people had interesting questions about wether this component would be able to solve this or that issue. If you’re interested in getting the slides, they are available here.

The Rich & Ed talk really showed EMF, GMF and Modeling projects in general may be used together to produce complete toolchain, well, the mindmap domain could be seen as a bit trivial but doing so much things in such a short demo is already a challenge without considering a more complexe domain.

Integration has been discussed during the Modeling Symposium, basically technical and “user-centric” integration is something we really need in the eco-system. Discussions has been started with the GMF people about providing integration with “compare” but this is quite a challenging subject too.

QVT was also a hot subject, well we can be quite confident Quentin will manage to provide a nice QVT-Relational component.
More information will follow on these subjects, on a another side Trolltech guys were here and were very nice too and the poster reception (free beer \o/ ) eased to meet people from really different parts of Eclipse.

During this session I had been able to see a comparison tool for the HL7 standards which was using a similar approach than EMF compare, the author was very friendly and I’m looking forward to a possible collaboration.

Just a downside on this event, well, Nick was not there so I had not been able to offer him beer for his help in setting up the emf compare build, let’s just hope I wont owe you more beer since we see each other again or you’ll quickly get drunk

" I love deadlines...

2007-09-12T03:02:00.000-07:00

… I like the whooshing sound they make as they go by.” D. Adams

Here it comes, the first release of the emf compare component ! You can download it on the website and use it for your every-day work, if it doesn’t fit, report a bug, works keeps going in the maintenance branch and in the CVS head.

So, what will I get with this piece of software :

Model comparison and merge: that’s good news as it’s the main objective of this project. You will be able to compare any EMF model, serialized in files or not, coming from XSD or a twisted metamodel.
ID (xmi or Ecore) support : if your model provides ID, they will be used in the comparison process.
SCM management : thanks to the Eclipse compare framework you will be able to compare versions of models in CVS or SVN repository.
Sexy user interface : I know we said at EclipseCon we would not focus our work on the user interface, but thanks to Laurent’s work the result has outperformed our expectations.
“EMF only” dependent core : the core, responsible for comparison and merge, only depend on EMF and as such is easily re-usable.
Extensible framework : let’s say you have a shiny new idea about model comparison, or that on your specific kind of model you could setup a strategy to match 2 elements, then you can define your own engine and EMF Compare will use it.
Export diff : you may save your diff in a file (emfdiff) and then re-open-it later without computation.

So what, let’s have a look now,

Where is the doc ?
The bundle only provides reference doc right now, in order to get up-to-date FAQ, tutorials or design overview stay tuned on the wiki.

What’s next ?
Next release (0.8.0) will provide 3 way comparison, diff extensions and many other nice stuffs. Concerning the algorithms we are trying to get better results with generic comparison algorithm through other methods coming from the research world. An initiative (website) about model transformation/weaving and comparison is taking place in Europe an you may expect that the EMF compare implementation will evolve toward these works.

We will also take part in the Ganymede simultaneus release to help in providing a coordinated modeling distribution.

I’ll give a talk at ESE about all these nice stuffs and the potential use of this component in other Eclipse tools, it will be a great place for exchanges, if your interested in, do not hesitate

New licenses for QT : any progress on Eclipse ?

2007-08-22T03:14:00.000-07:00

A few days ago the trolls opened their great framework a bit more adding new licence exceptions on their Free Software edition. This means Qt software can be used along with a larger range of other Free Software libraries and dependencies. One of these licenses is the ” Common Public License - 1.0″.

Discussions took place a long time ago about using QT as a toolkit for Eclipse (the same way we use GTK) and AFAIK the blocking point was its license. As a Linux user I’m a big fan of QT and I often cries concerning the GTK slowness. QT applications feel a lot more responsive and each release brings really nice features like a broad SVG support or soon a webkit component. Moreover this toolkit is cross-platform, I had a chance to use it coding a Python/QT application and it was effectively working on Linux/Windows and MacOSX without recompilation providing a native look and feel.

Lately Trolltech went toward the Java world with QT Jambi, and more especially toward Eclipse providing a full set of plugins for user interfaces design.

Did this licenses extension changed something concerning an eventual SWT/QT integration ? Do anybody want to share information ?

Beautiful Evidence

2007-06-08T03:18:00.000-07:00

When I discovered the NodeBox project, that thought (in fact - a book title ) immediatly catched my mind.

Tufte is right when he says that “The commonality between science and art is in trying to see profoundly - to develop strategies of seeing and showing.”, analysis needs relevent and beautiful representations. Here these representations may be animated, and that’s another big point, the first purpose of our mind associated with our eye is to analyse moving representations and finding out visual inconsistencies.

The gallery provided for that tool is just amazing, mixing different research domains, using the web as an information pool and providing “near artistic” representation.

Do I need to say this project is made in Python ? Well, most of the time, projects using many other libraries gluing them in order to provide unexpected results tend to be in Python. The bad news about this one is it seems to be exclusively MacOSX compatible, but lets hope the 2.0 release using Jython will hit the ground soon, this one could work, at least, on Windows.

“Simplicity is the ultimate sophistication”

2007-06-05T21:50:00.000-07:00

Leonardo Da Vinci was damn right about it, and Acceleo 2.0 is just another step in the right direction.
As planned we released this new stable version today. Have a look on the new and noteworthy to get an idea of the exciting features.

Ready-to-use bundles are available on the download page providing Eclipse, Acceleo, its dependencies, the whole set of generator modules and usefull other plugins like Subversive or Topcased.

This release mark the opening of the project to a broader community: people gathered to provide open source generator modules for JEE, CSharp, Php or Python. This set is made of stable and feature-full generators but also of experimental ones.
I do not forget about generators not yet ready to be released, mentionning Wisss or Enterprise Application no doubts they will soon bring new exciting technologies !

The Acceleo website had a huge makeover for the 2.0.0 release, more especially in the documentation and development sections. Speaking about documentation another great news is that fact that the “Obeo advanced documentation” is now free for a commercial use too !

Don’t miss the new “Take Part in Acceleo” page opening to various contributions users, architects or developers are able to do.

Still, to get to ultimate sophistication, we need your feedback ! Do not hesitate to interact with the team !

EMF Compare now uses XMI_ID

2007-03-26T14:43:00.000-07:00

The generic emf comparison engine uses statistics in order to match elements, it compare their content, their type, the relations with other objects and their name. This process gives good results on many metamodels, especially specific ones, but this process can be costly for instance on UML models because we’ve got many attributes on each element. On the other side, big models and standards ones are often serialized in XMI using Id’s .
The generic engine now uses these id’s if they are available, in order to find matching elements, the cost is just about zero and the correctness is good. Next step is to use the functionnal Id’s one may define in an Ecore metamodel.
Here comes a screenshot showing the current state of the emf compare project, comparing two UML files.

XML files comparison/merge

2007-03-20T17:34:00.000-07:00

On the EMFT mailling-list Martin Taal asked me if EMF compare component was usefull when one has to handle XML file.

Thanks to the EMF/XSD project this feature just comes at no cost ! If you create your metamodel using an XSD then the model will be serialized in it’s native XML format but in the emf compare point of view it’s just another EMF model ! Then you’re able to compare, and of course merge modifications on the files.
Here’s a screenshot of the tool comparing two XML files coming from the well known “Library” example (sorry I did not put nice icons on the models ;) )

The XSD project really should have more visibility, it’s obviously usefull in many use cases where XML matters and EMF provides so much nice features, you should not miss that !

Joining the community

2007-03-13T08:38:00.000-07:00

First time blogging , many first times these days :)
As the EMF Compare project lead I had to go to EclipseCon, the component has just been accepted so it was the first time for me to follow EclipseCon from the inside and not from Planet Eclipse.
The event was just great, the interesting people are countless and the Eclipse world is amazing by many aspects. I attended many talks, for a modelling guy like me many stuffs were interesting.
EMF/EMFT was present everywhere, it’s the basis for many tools and software and it deserves to, it just cover the need everybody has using data and models, serialization, notification, validation, transaction or now relational database storage thanks to the Teneo project.
EclipseCon allow you to meet the people behind all theses projects and to have a quick glance of the other projects, the data binding stuffs were just great as the Zest framework from Ian Bull and the UML talk done by Kenn Hussey.
I did a panel there about the EMF Compare component with Antoine Toulme, Jean Bezivin and Ed Merks, it was quite good as the audience had many reactions. I emphasized there the fact that we are aiming to provide a great basis for other tools to work with, a basic UI for comparison and merge (same as the JDT) but no diagram support yet. As the tool is metamodel agnostic, meaning you are able to compare UML or Ecore or anything else, questions were asked about providing special behavior like, for instance, custom dependencies management while merging. Good point there, we’ll try to provide a mecanism for that!
I also did a poster session about the code generator Acceleo, nice reactions there too, people would like to use a MDA approach but most of the tools are quite hard to tackle, Acceleo is just great about that, it’s easy to install, to use and you may generate any kind of text.
In a nutshell the event was great, special thanks to all the staff there and I’m looking forward to see everybody back at Eclipse Summit !