vendredi 16 décembre 2011

Do you want to discard this editor's changes ?

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 !

mardi 6 décembre 2011

Eclipse Day Paris 2011



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 !

jeudi 1 décembre 2011

SysML Comparison and Contributions


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)

lundi 7 novembre 2011

Follow the White Rabbit ...

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.

jeudi 27 octobre 2011

Obeo @ Eclipse Con Europe

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 SlotPresenterTitleSession Type
2 November 09:00 - 12:30Mariot ChauvinWhat every Eclipse Developer should know about EMFTutorial [3.5 hours]
2 November
16:30 - 17:00
Stéphane BégaudeauAnd you thought you knew Template Based Generators?Standard [25 minutes]
3 November 09:00 - 09:30Goulwen Le FurScientific application redesign in oil industry with Eclipse ModelingStandard [25 minutes]
3 November 10:30 - 11:30Mariot ChauvinCollaborative Modeling : the New DealExtended [55 minutes]
3 November 11:30 - 12:00Gaël BlondelleThe Making of the OPEES Industrial Working GroupStandard [25 minutes]
3 November 15:30 - 16:00Frédéric ThomasEclipse for Railway Safety EngineeringStandard [25 minutes]
3 November 16:00 - 16:30Mikaël BarberoWhat the heck are logical models?Standard [25 minutes]
4 November 11:30 - 12:00Alex LagardeCreate useful documentation with Mylyn Intent : a step further in Application Life-cycle ManagementStandard [25 minutes]
4 November 15:00 - 15:30Mikaël BarberoEMFCompare improvements: fulfilling requirements of the Modeling Platform Working GroupStandard [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 !


mardi 18 octobre 2011

Model Transformation Preview

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.

lundi 10 octobre 2011

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





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.

mercredi 28 septembre 2011

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

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 !

mercredi 21 septembre 2011

Textual Adventures in Ecore + Graphical Modeler

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  !

mercredi 14 septembre 2011

Eclipse Modeling : the definitive tutorial

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.

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.


mercredi 7 septembre 2011

Collaborative Modeling : the New Deal


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



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

mercredi 10 août 2011

Measuring Performances

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 :


mardi 21 juin 2011

Comparing pom.xml files while waiting for indigo




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 !


vendredi 6 mai 2011

Eclipse Modeling Package : SDK or not ?

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 !

jeudi 3 mars 2011

Mylyn Intent @ EclipseCon 2011


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.

mardi 18 janvier 2011

2011 - The Thrill

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 !