Hotwine's beverage

Time for new challenges

2011-11-09T17:16:00.003+01:00

4 years ago, I joined Obeo, a startup focused on model driven engineering. At that time, I just finished my google summer of code for Eclipse Foundation, and it was a nice opportunity to join a company involved in the eclipse community. Tomorrow, it will be my last day of that adventure, an adventure I have decided to leave for reasons I explain below.

Obeo has been using Eclipse as unusual propulsion system, we have benefited a lot from the eclipse platform and its modeling stack but we have tried to give back as much as we have received, creating a driving force.

The people I have worked with at Obeo are brilliant. I am not writing that for the blog post, I really think it. You probably already know some of them (Alex, Cedric, Fred, Goulwen, Laurent, Mikael, Stephane, William) involved in eclipse projects, I can tell you there are others doing awesome modeling stuffs. I will miss those guys.

The first reason of my departure is that I feel like working on other topics. Before joining Obeo, I worked on various subjects, not modeling related and sometimes even not software engineering related. I like that diversity and I believe in the transversality of knowledge as well as in the strength of experience.

The second one is the wish to take up new challenges. We took up several at the beginning of Obeo, in particular on the project I was working on, but, with the growth of the company, opportunities to work on disruptive innovations became less frequent.

I don't know yet how I will be involved in Eclipse in the future, so I would like to thank you Eclipse community, it has been a pleasure.

Modeling Symposium @ EclipseCon Europe 2011

2011-11-08T15:23:00.002+01:00

The modeling symposium at EclipseCon Europe 2011 was really nice with several talks on various topics related to modeling. I would like to thank all presenters and particularly István who filmed all presentations with his smartphone.

Xtext 2.1 by Sven Efftinge
OCL by Ed Willlink

Slides are also available.
Acceleo Interpreter by Stéphane Bégaudeau
EMF-IncQuery by István Ráth
EMF-IncQuery EclipseCon Europe 2011 Modeling Symposium Talk
EMF Store Demo by Maximilian Koegel
EMF Profiles by Hugo Brunelière
MPS by Markus Völter
EMF Compare by Mikael Barbero
EEF alternative generation by Goulwen Le Fur
GMF Tooling revival by Mariot Chauvin

Collaborative modeling @ EclipseCon Europe 2011

2011-11-08T12:53:00.002+01:00

Last week I presented with Martin and Benjamin why collaboration in modeling becomes an important concern, the issues we currently encounter, and the eclipse technologies which are improving to provide seamless collaboration.

	In the last five years models usage generalizes, modeling tools matured a lot, but often they have not be designed to allow one to work efficiently in team. On the same time, collaboration, in a general manner, took a predominant place in tools and medias. Successes of Wikipedia and the Huffington Post show that trend.
	Modeling or not, working with others is a challenge. Which separation of work ? Which rules to set up to keep the coherence ? How to deal with the different concerns people may have ? Answers are often most organizational than technical, however tools, technologies may constraint your organization and you way to work in collaboration.
	Model together is first dealing with a large amount of information and depending of your manner to represent them it could become quite tricky. For graphical representations, beyond layout problems, from a certain number of elements, we are not able to focus on the useful information, the signal noise ratio becomes to low.
	Even without representation scalability remains an issue, as by default EMF load the entire model in memory.
	How many times are we not able to understand legacy code or models done by others ? It is necessary to document your models and explains your choice behind design decision, but it is as important to keep documentation synchronized across the changes and refactorings you made.
	To collaborate means dealing with concurrent accesses, and often end users do not want to have to compare or to merge. Starting from that requirement you quite easily ends up with some kind of pessimistic strategy.
	The most simple implementation of this strategy is an instant messaging discussion. As long as your model is not changing too often its bearable. Sophisticated versions of that implementation are directly integrated in an SCM supporting file locking, but that remains a not very elegant solution.
	From that you'll try to avoid blocking the whole team and then you'll split your model into many files. It's slightly better but it's not that easy to do, as you have to carefully design your Ecore model avoiding most of the cross references. More over EMF fragments are not correctly supported by many tools.
	The other strategy, called the optimistic one, is to allow conflict happens and to deal with them when they occur. It looks like a dice game, and depending on the frequency, it could become hard to deal with conflicts.
	Those problems could be tackled with several technologies which enable one to work more naturally in collaboration.
	How to deal with large diagrams ? Thanks to EMF Mylyn bridge we are able to focus in the diagram on the information which matters, the information contextual to a change you have to do or that somebody else did.
	How keeping documentation and model synchronized ? Thanks to Mylyn Intent we could mix natural and formal language. This is some kind of literate programming adapted to modeling with one specificity : you can update the model, or the doc, it doesn't matter, the tool help you keeping them synchronized anyway
	How to support better models fragmentation ? Model tools could be behaving like the tools we are used to when programming. They should not make the assumption that every referenced element will always be there. This is possible by playing nicely with the EMF proxy mechanism.
	Keeping models coherent with fragmentation could be ensured through platform logical models. That API enables components to trigger changes on any file operation.
	How to avoid models splitting ? CDO is an impressive technology which have been around in Eclipse for a few years now. It keeps getting better and provides, as a model repository, every service you might dream of. Using it, one is able to build a solution based on pessimistic locking at the model element level, with live updates when you are connected.
	If you are more interested by the optimistic strategy, CDO offers the possibility to provide conflict resolver, to solve conflicts in the more automatic way, when they happend. CDO does not enable only efficient collaborative strategies, it solves the scalabilty issue, by loading only necessary model elements and unloading them automatically.
	I would like to share with you what is happening on a broader scale. Those technologies are only a start in collaborative modeling, and there are many ways to get inspiration about collaboration, github or google docs for instance.

Of course a large part of this talk was reserved for demos of the improvements in Mylyn, EMF Compare, EGit, and Dawn, but I have currently no video of them to share.

Modeling Symposium Program

2011-11-02T18:46:00.002+01:00

As previously announced there will be an exciting modeling symposium during EclipseCon Europe.

Thursday, November 3rd
from 18:30 to 20:30
Silchersaal

Xtext 2.1 by Sven Efftinge

Xtext 2.1 allows to define languages for the JVM by just implementing two simple scripts.
In this short demo, I'll show an example of using this new API. You'll see what these scripts are about
and how awesome the the resulting language and its IDE support is.
OCL by Ed Willlink

The evolution of the MDT/OCL project from Java-only model support to an
OCL IDE will be briefly described. The extensive use of Acceleo and Xtext
for auto-generation of both Eclipse OCL and the OMG OCL specification will
be outlined. Finally the OCL 2 Java code generator will be announced
eliminating parsing costs at run-time and accelerating execution by one to
two orders of magnitude

Acceleo Interpreter by Stéphane Bégaudeau

I would start by the presentation of the new Acceleo interpreter view with its different features. I'll show how it can be used to execute OCL queries on EMF based models. Then I'll highlight its integration with Acceleo by using it combined with the Acceleo debugger. Finally, I'll explain how this view, that has strictly speaking, no dependencies with Acceleo can be used by other projects with a small example of its use without Acceleo to support another language.
.EMF-IncQuery by István Ráth

This presentation introduces EMF-IncQuery, a declarative and scalable EMF model query framework. EMF-IncQuery uses a graph query language, and provides incremental query evaluation by caching the results of the model queries and incrementally maintaining the cache when the underlying EMF model changes. Furthermore, the EMF-IncQuery framework can be easily integrated into existing EMF-based applications in a non-intrusive way. During the talk, we quickly overview how easy it is to define and integrate highly scalable model queries into existing EMF-based applications, in the form of a very short live demonstration using the MDT Papyrus modeling tool. The scalability of the engine will also be demonstrated, with on-the-fly constraint revalidation that takes less than 100 milliseconds over large AUTOSAR models with over 1 million elements.
EMF Store Demo by Maximilian Koegel

EMFStore is a model repository for EMF and allows to collaboratively
edit EMF models and keep a version history. EMFStore can be integrated
into EMF-based RCP applications to provide the application with its
capabilities. In this demo we will show an industrial customer application where EMFStore was integrated and inspect the code that was required to do so.
EMF Profiles by Hugo Brunelière

Have you ever been in a situation in which you would like to annotate an EMF model with additional information, but the last thing you wanted to do was to change its metamodel to made that possible? I bet the answer is yes for almost anybody that has been using EMF for a while. In this talk I will present EMF Profiles a solution inspired from UML Profiles which provide a light-weight model annotation mechanism.
MPS by Markus Völter

JetBrains MPS is a powerful language workbench available under the Apache 2.0 license. It uses projectional editing, so it supports quite flexible syntax as well as language modularization and composition. Best of all, the development roadmap include an integration with Eclipse in the context of version 3.0. In this slot, I will give you a short demo of what MPS can do.

Hope to see you there !
If you would like to be included in this program, please contact us .

Modeling Symposium

2011-10-22T18:22:00.000+02:00

In previous years, the Modeling Symposium at Eclipse meetings in Europe attracted a large panel of attendees interested in sharing their ideas and in learning about the projects of others in the community. At the last event, we had fifteen interesting presentations and the room was full.

This year, there is no session planned for the symposium, so it will take place during a BoF on

Thursday, November 3rd
at 19:00

If you are interested to show a demo, exchange ideas, or gather feedback about a proposal, please contact us with a short description about what you would like to talk. We hope being able to announce an exciting agenda.

Collaborative modeling, the new deal

2011-10-21T15:03:00.000+02:00

I already blogged about collaborative modeling but I would like to stand back from the previous post, which was very technical, and introduce the talk I will present with Martin and Benjamin at EclipseCon Europe.

Since several years now the Eclipse modeling platform provides useful tools which have help to democratize the use of modeling technologies. However those tools have raised issues linked to collaboration we start to better address.

To visualize and edit models in a graphical manner diagrams are often used. However usually diagramming technologies do not scale well and this is problematic as the more the models and their complexity grow the more one wants to work in group.

When you model with other people, one of the difficulty is to understand reasons behind their choices and design. Document them is of course necessary but the main difficulty is to keep documentation accurate across refactorings and changes.

In fact, often the more the time flies by, the more we lost the intention, documentation being seen as a post-design step.

Collaborate means dealing with concurrent accesses. To enable them you have two strategies. One is to prevent conflicts either through models splitting or with locks. But models splitting is not well supported by tools and coarse-grained locks are not pratical.

The other strategy is to allows conflict happens and deals with them when they occurs. It looks like a dice game, and depending on the frequency, it could become hard to deal with conflicts.

Interested by the subject ? Come to the talk to discover what are the available technologies to address those concerns, and understand why collaboration matters in modeling.

Acceleo 3.2

2011-10-10T17:09:00.001+02:00

To celebrate the historic victory of the french rugby team in the world cup quarter final, the Acceleo team is proud to announce its 3.2 release very soon.

Photo from NikRugby23

We tackled performance problems in compilation. Acceleo is now as fast as Vincent Clerc, and even if you totally don't know who he is, you will appreciate the better reactivity of the tool.

We provide a new useful view to test Acceleo and OCL expressions on the fly, the Acceleo interpreter. You will find more details and example of usage of the interpreter in the Laurent's blog entry.

Screenshot of Acceleo Interpreter

Want to join the scrum ? You could install a release candidate and give us feedback before the final release planned for October 24th.

Modeling 2.0 : Let's collaborate!

2011-09-15T01:34:00.000+02:00

A bit of history

4 years ago, when I joined Obeo, I started to work on a new modeling tool dedicated to system engineering. The main focus of this tool was to enable system engineers to model graphically complex systems with different representations, for each speciality, depending on their viewpoint. The tool was associated to a methodology and integrated in a modeling workbench.

Separation of concerns by representations was a first step to scalability of graphical representations, another was to add several mechanisms (layers, filters, hide/reveal) to allow end users to hide some elements. The approach is somehow similar on what Miles is working on.

We took the decision to create a generic runtime with the possibility to specify graphical representations and to drive the tooling by the viewpoints. The approach has similarities with Jan current's work, and I think our work inspired him a little bit.

Since the runtime has been used for safety analysis (diagram screenshot) and several other use cases.

However, although our tool primary concerns was collaborate modeling since its inception, we did not offer directly a solution to the concurrent access problem. In fact, we left it to the Revision Control System (RCS) used by end users. As Alex wrote concurrent access management by RCS have several drawbacks, so we decided to offer the possibility for end users to collaborate more seamlessly.

On the technical side, we decided to use CDO, a technology we had experienced successfully in others projects, and which seems to match the most to our requirements. As our graphical modeling technology is based on GMF Runtime, our global technical task was to integrate GMF and CDO.

GMF and CDO, integration challenges

If you are used to component architecture like the Eclipse platform one, you may think that these two components will plug together quite easily. Unfortunately, this is not the case for various reasons :

EMF Transactions and CDO Transactions
GMF Runtime relies on EMF Transaction to manage read and write accesses to models. To simplify this means that one is not allowed to do a modification without encapsulating its change in a recording command. On its side CDO provides its own transaction mechanism, which relies on the database store one. So it is necessary to integrate the two mechanisms. This is one of the features Dawn provides (see those bugzilla entries for further information).

Transactional model break in GMF Runtime
GMF Runtime is a bridge between EMF models and GEF. Among others things, it provides a notation model, to store graphical information. The synchronization between the graphical model and the semantic model, is one of the responsibility of edit parts. The choice to split the synchronization responsibility in each edit part enables one to easily override the default behavior for a given edit part. This choice is consistent with the high extensible approach of the framework. However, it has one major drawback, edit parts should be instantiated to update the notation model ! As GMF Runtime edit parts creation is done in an post commit listener, when no models changes are allowed, the runtime have to force the transaction using a special option.
This behavior prevents one to have triggers for those modifications. If you need to avoid conflicts (see below), you will not be able to acquire lock before commit. In this case it means that one have to extract the synchronization from edit parts and to call it at the right time.
Avoiding conflicts
If CDO provides live updates of shared models, it does not prevents conflicts. There is two ways to handle them. The first one is to write your own conflict resolver, which will take a decision when a conflict occurs. The second one is to avoid conflicts through locks. Easier to said than to implement, but that the way we choose.

Lock integration
To avoid conflicts, the simplest way is to lock automatically elements before their edition. In practice, one could use the EMF Transaction trigger mechanism to do this. Edit parts need to listen to locks events to deactivate accordingly their edition capabilities and provide visual indicators of the lock. Lastly, to provide logical lock for end-users, one may provide a lock strategy.
Consistency maintenance on client side
EMF Transaction enables one to rollback a transaction, before its commit. This is generally done for validation or lock acquisitions purposes. The recording command manages this rollback and will abort properly the transaction if it occurs. However with the abort, the CDO state of the object will change (see bug 312534 for more details). To avoid conflicts a solution is to use CDO save points to restore the object to a clean state if a transaction aborts.

Native mode for GMF Runtime notation models ?
One of the coolest thing of CDO is its EObject implementation, but to benefit from the scalability it provides, you need to regenerate your metamodel with a CDO dependency. When one works with such CDO model instances, the mode in which one is, is called native. As GMF Runtime notation metamodel depends on the EMF one (don't do this at home), using notation models in native mode is far from being easy. So we worked on a solution which keeps source and binary compatibility with legacy code (see bug 336707 for technical details) and provides notation cdo native models, the code is available here (no builds yet).
Content and cross reference adapters
These two utilities should not be used as they will break the lazy loading mechanism of CDO. By default GMF runtime initializes one cross reference adapter when configuring the editing domain. You could quite easily override the default behavior. EMF Transaction uses an adapter that walk through its content, but removing it is much harder.

On our product, the work is still in progress, but we he have implemented solutions for most challenges presented above. During this work we opened several issues :

fixed : bug 345719, bug 352191, bug 355915, bug 337870, bug 353167, bug 329753, bug 315570, bug 329869, bug 329752, bug 353076, bug 351393, bug 351921, bug 325436, bug 346378
not yet fixed : bug 339908, bug 352189, bug 352977, bug 352204, bug 357400, bug 329786

As you may seen, the CDO team has been very responsive, and already provided fixes for most of them. I would like to thank them for their availability and help.

This blog entry present results coming from a work collaboration between Thales and Obeo.
Ce message de blog est issu d'un travail en commun entre Thales et Obeo.

EclipseCon Europe submissions advice

2011-07-28T19:28:00.001+02:00

EclipseCon Europe submissions deadline is approaching, and I received already several advice requests. So it's time to share some hints for increasing chance of being accepted. Just a reminder before the enumeration, we are several people in the program committee, and every one of us has his opinion and his sensibility, so do not blame me if your talk is finally not accepted.

Read the submission FAQs
Submit before August 3, 2011, you talk may be accepted early ! Early bird winners will be advertised on the website, and speakers will receive a special gift.

Photo from Magnethy

If you submit a talk about well known Eclipse Project, or a talk already presented several times, consider an original presentation format.
Blog about your submission to give further details and provide us some screenshots if it's worthwile. You may also receive interesting feedback.
Be reactive if the committee ask you details about your submission.

Hope to read you soon.

EclipseCon Europe needs you

2011-07-21T18:58:00.000+02:00

I have always appreciated Eclipse events, and see them as a great opportunity to meet the community. I think that from connections made over frosty beverages could emerge new ideas and durable collaborations. This year the convention in europe will celebrate 10 years of Eclipse, it's an unique chance for measuring the road we have traveled, but also to discuss about the future and new ways to explore :

Photo from FlyingSinger

But August 17 is approaching and if you dot have done it yet, it's time for a submission. To not miss accidentaly deadlines there is even a calendar you may import.

Last but not least there will be Java 7 summit organized by Oracle this year, another reason to come.

SWTBot @ Eclipse Party Toulouse

2011-06-25T16:11:00.000+02:00

Eclipse Indigo is here !

If you come back from vacation, or dot not follow Eclipse community on a daily basis, you may have missed that once more, the eclipse annual release train has been shipped on time.

To celebrate the event, Toulibre organized last thursday an eclipse party with several talks and a great attendance. This was a great opportunity to give a presentation about a tool I am working on.

SWTBot is a small open-source tool, dedicated to functional tests. It focuses on helping writing easily UI tests with a nice API.

Developers are aware of unit tests, TDD is now a common practice and uncle bob converts each day developers to clean coders and craftsmen. But focusing on internal quality is not sufficient.

Functional tests enables one to ensure that your application works as expected from an end user point of view. When you do not have a tooling to automate these tests, you should run them manually, which is time consuming. If you should release often, it will be costly, and if you have a limited budget, you will release less often. In others terms, due to budget restrictions or due to the necessity to meet deadlines, this is often the manual quality tests which will be dropped.

SWTBot API wraps each SWT widget. It hides synchronization with the UI thread through a fluent interface, making tests very readable.

SWTBot provides matchers (thanks to hamcrest) to find easily controls and conditions to write robust tests, independent of the execution context.

One great small unknown feature of SWTBot is that it will take a screenshot each time a test failed, this will give you clues to find what went wrong.

You will find a lot of information on SWTBot on its wiki page. But if you hesistate to have a look to this technology, fear of losing time in configuration and information seeking, follow this tutorial and in 5 minutes you will have written your first test.

About SWTBot

2011-05-31T23:34:00.005+02:00

I recently read a blog post about SWTBot, which I consider as a unfair rant.

Before going further, I would like to say that I think having several eclipse projects with the same functionalities is totally fine. Diversity and competition enable one to bring innovation and new approaches. I think it, but I have also experienced it inside the modeling platform with Acceleo, Jet and Xpand or Grafiti and GMF. That said I think each project should concentrate on building a successful technology and an enthusiast community associated, and not trying to claim that other projects suck, more over when criticisms seem a bit peremptory.

Below are my answers, point to point :

I agree that support for other keyboard mappings could be enhanced a lot in SWTBot, but I do not think this issue is a blocker for functional testing your application in a majority of cases. Seriously, how many features depends on umlaut and trema in your text inputs ?

You may prefer TestNG, but having support for this test framework is not mandatory for having SWTBot to work. However to complain about a feature request, never asked before, making SWTBot not usable, seems to me weird.

The comment above apply, but I will add that the issue you encounter seems to be rather in the scala eclipse integration plug-in than in SWTBot. Anyway it should be easy to fix.

I was not able to understand your problem and the what the trick you mention fixes. Please open an issue with steps to reproduce and the behavior you expect.

May be you were trying to suggest cool new features, or priority in fixing issues, in that case do not hesitate to open bugzilla entries or add your comment to existing ones.

SWTBot is a small project, with a dynamic community, which try to improve it step by step. It is certainly not perfect, had issues and room for improvement, but we try to make it work.

About modeling workbenches

2011-05-26T16:45:00.015+02:00

I was last week at Cambridge for Code Generation 2011.

That's the first time I attend to this conference, and I feel I have missed for several years, agreat opportunity to discuss and share ideas about modeling beyond Eclipse community.

One hot topic of the conference was language workbenches with a competition dedicated to them one day before the official start. You will find several summaries on this first journey with the several presentations, including the Obeo Designer one. I really enjoyed this workshop and discovered interesting new workbenches such as Essential or Whole platform.

The day after I presented how you could create easily your own modeling workbench mixing several kind of editors. If you did not attend, following is a summary of my presentation.

I started by explaining why particularly graphical DSL are more interesting than UML if you want to raise your level of abstraction rather than level of complexity.

UML graphical notation, along being not specific, is ambiguous and not intuitive.

Building a graphical or textual DSL should be driven by end user way of work and data you model.

Neither expect from an emacs user to program by drawing some kind of diagram sequence, nor expect from a powerpoint user to create a flowchart by literally typing it.

One of a key point for a modeling workbench is its ability to support collaborative work, which means enable people with different concerns to work on the same models.

A modeling workbench should adapt to the workflow of users and set process with conflicts handling.

Modeling is valuable in itself, however you can reach another level of productivity gain when you use models to produce deliverables : code, documentation or settings file.

A modeling workbench should manage de- synchronization between models and the deliverables.

Obeo Designer is a modeling workbench platform which focus on adaptability, flexibility and tooling. It is based on eclipse modeling projects.

For instance for text generation it includes Acceleo, a template based approach generator with featured editor, debugger and profiler.

It includes also Viewpoint, a graphical runtime to specify graphical representations such as diagrams and table editors. You don't need to generate any line of code to specify representations.

Viewpoint provides several mechanisms to display only relevant informations such as layers and filters.

Live demo showed how to create such editors to edit graphically models and then did a model transformation from UML and a code generation to Java.

This platform has been used for several Obeo customers and partners with different kind of editors and with various generation use cases.

For instance for safety analysis with FTA diagrams.

Viewpoint technology is also capable of drawing advanced diagrams for your domain specific models such as sequences diagrams (including interaction uses and combined fragments).

Even if you should often avoid UML you may have to deal with such legacy models.

So we provide open-source UML editors you could easily extend or integrate in a descriptive manner.

If you want to know more, presentation slides are available online.

I attended to a lot of interesting talks, but if I should to retain only two, it would definitely be the keynotes from Terrence Parr and Ed Merks. Strong opinions, good sense of humor, and a understandable speech to explain what they have realized.

Obeo Designer @ Code generation 2011

2011-04-27T11:46:00.009+02:00

I will be speaking at Code Generation 2011 about Obeo Designer, our DSL Studio based on top of Eclipse modeling technologies.

I will notably present several customer use cases of graphical workbench dedicated to end-users and how the platform flexibility and extensibility allowed us to overcome challenge we faced.

Process modeling

Temporal specifications modeling

Speaking about obeo designer, we are currently working on the next version, which will include following eclipse project versions :

Acceleo 3.1, with ant and maven better support, generators documentation, and syntax coloring configuration
EMF Compare 1.2.0, with Filtering capabilities and UML dedicated comparison engine
EEF 1.0, with one click generation and EMF/Edit alternative

On the Viewpoint side, we will use these technologies :

The viewpoint specification editor properties will be based on EEF
Acceleo 3 queries will be possible with completion and live validation

Acceleo 3 queries with live validation in EEF properties

Acceleo next version

2011-03-23T21:35:00.013+01:00

For the next version of Acceleo included in Indigo, we are working on several items, following is a presentation of some of them.

Ant and maven easy integration

Currently you could easily use Acceleo as standalone, but if you need to integrate the acceleo compilation or generation in your workflow it's a bit difficult. So we are working on providing ant tasks and better maven support.

Documentation of your generators

We add documentation capabilities for query, module and template. Documentation will be available on mouse over and during code completions. You have also support of deprecated tag with proper warning in case of use.

Improved performances

You will have the ability to compile modules as binary resources. It will reduce significantly the size of compiled modules and increase the performances. This serialization will be the default one, but it could be modified in the preferences.

By the way we organize a BoF this evening about Acceleo, come on to discuss with us !

GSoC 2011 @ Eclipse

2011-03-16T16:10:00.014+01:00

This year again, Eclipse applied as a mentoring organization for Google Summer of Code. We already have been started to collect ideas, they could be contributed on the wiki.

Do not miss GSoC !

It's a great opportunity to see enhancements or new features added to your favorite projects. If you are a student, you should consider GSoC as an awesome chance to integrate free and open-source communities by doing (not only using), trust a former student. If you don't know how to get involved, have a look to our contribute page and keep an eye on the timeline.

Here are some ideas I added :

Acceleo has the ability to profile a generation. It creates a model containing the profiling data, and his able to display it. However it would be nice if we could export this model to a gprof file and reuse existing analysis tools such as the view from the linux tools project.

Thanks to its discovery UI modeling package users could very easily discover and install modeling components. However we miss an updated reference example to see how to use together all this technologies.

EMF Serialization is extensible and Protocol Buffers is an efficient serialization technology so it could be interesting to see how to combine them.

Graphical modeling @ EclipseCon 2011

2011-03-11T11:03:00.022+01:00

If your read this blog entry, you probably already heard about EMF, but you may still wondering how modeling and all this meta stuffs could help you in your daily developer work.

If you are in this case, then you have to attend to the EMF tutorial for at the next EclipseCon. In the first part you will have time to discover the basics of EMF on a case sudy. In the second part you will have an overview of additional powerful technologies, such as EEF and GMF, 2 projects I will present related to being able to create and modify a model in a graphical manner.

EEF is a tool which enables one to generate sexy properties, but not only. It's a framework, which could be use to generate several kinds of user interface to edit your model.

It has been designed to be compatible with validation and transaction existing EMF components. Let's have a look to to see how you could easily generate an eclipse form editor in one click from your metamodel.

Even EEF if is a quite young project, it is already used in the industry and arouses interest with frequent questions on the newsgroup.

By the way EEF has been nominated and is finalist for the eclipse community award 2001 in the most innovative project category.

GMF is a project dedicated to the creation of diagram editors. It is split in 2 components, the runtime and the tooling.

The runtime connects GEF and EMF. It plugs your EMF model as the model in the GEF model-view-controler architecture and provides a diagram metamodel.

The tooling enables you to generate an editor based on the runtime.

The runtime has been designed for extensibility, you could extend it or redefine some parts very simply.

The tooling uses code templates, that you could extend to generate custom code. This enables you to keep your GMF models and the generated code always synchronized.

That's all for this EEF and GMF preview, if you want to know more, come to the tutorial !

Obeo new modeling box is coming

2011-02-16T12:36:00.014+01:00

At Obeo we are currently working hard for the finishing of the next version of our eclipse based modeling studio named Obeo Designer.

Obeo Designer 5.0 embeds our latest modeling technologies.

Acceleo 3.0.2

Acceleo is a text generation tool. If you think that code generation sucks due to its lack of tooling, then you should probably try Acceleo. Its offers much more than a complete eclipse editor with syntactic coloration, code completion and quick fixes. For instance it provides an integrated debugger :

Acceleo debugger

Acceleo is a technology that has been recognized as innovative and effective.

Obeo Traceability 2.0

Obeo Traceability is a tool to manage the synchronization between your models and the generated text. For each model element, you are able to know which text section have been generated and navigate between text and model. If you decide to modify the generated text, Obeo Traceability will automatically indicates it, and offers you the choice mark the section as not generated or to update model and generator.

Before modification on the left and after on the right

Obeo Traceability provide these features with a user interface completely integrated to Eclipse.

Viewpoint 5.2

Viewpoint allows one to create easily graphical editors. Easily ? For each editor you simply define mappings between model elements and graphical styles along with tools which describe modifications to make on model in response to user actions. Graphical editors ? you could specify diagrams, tables and trees and the API allows you to define your own kind of editors.
See example editors below made with Viewpoint.

Diagram editor

Table editor

Highlights from ESE

2010-11-04T21:01:00.017+01:00

ESE is already over, and from this edition I would like to retain 3 things :

Community is open and diverse

Photo from Cliff

Eclipse is a community, and ESE is an awesome opportunity to meet in real life members of Eclipse community. I have found that the attendance was a good mix of committers, adopters and end users which lead to interesting discussion and feedback about projects and technologies. I have liked the accessibility and open mindedness of every person I met.

Modeling is everywhere

It was impressive to see that people have understood that modeling is not limited to UML and code generation.

On a textual side Xtext and Acceleo were the 2 stars with a lot of talks presenting their functionalities or exemplary usage. There was also a tutorial combining them to learn how to use these 2 great technologies to model and generate android applications.

On graphical side, there were plenty of eye candy things to see. EEF presentation from Goulwen showed how you could easily generate sexy properties and wizards for a metamodel. Mitra, a semi-automated model transformation tool, presentation showed a 3D user interface where each model is displayed on a 2D plane. I am not sure this is scalable but it was a great demo of what's can be done with GEF3D. Papyrus presentation showed the progress they have made in providing an UML (but not limited to it) reference graphical editor. Bonita Open Solution presentation showed a very attractive and intuitive BPMN editor. In its presentation of modeling for WTP, Etienne showed briefly modelers build with Obeo Designer, our DSL Studio on top of the eclipse modeling platform. Papyrus, Bonita Open Solution, and Obeo Designer relies on the GMF Runtime. Graphiti is a new alternative runtime, and its presentation was a demo of a beautiful library modeler. Last but not least and good transition, Dawn demo of collaborative edition between editors, including diagram ones was amazing.

Model management concerns had a very good coverage this year. CDO is aimed at scalability, sharing and storage of models and Eike presentation about it was very comprehensive. The more I know about CDO, the more I find it well-designed. COPE focus on models migration and its presentation pointed up the advanced tooling they provide to facilitate metamodel evolution. EMF Store is dedicated to models storage and versioning. It uses EMF Compare for comparison and COPE for migration. A talk and a poster were presented.

Other great stuffs were presented like collaboration of EMF and GWT for modeling in the cloud, or Sphinx an initiative to have a more coherent modeling platform.

According to this the modeling symposium was a real success. Many talks on various topics from different speakers. My only regret is that with such a crowd, it was a bit difficult to start a discussion just after a talk, but that's probably the price of fame.

Build simplification is moving forward

Photo from jolien_vallins

In past I had some headaches with eclipse build technologies. There are several approaches and several projects (PDE Build, Athena, Pluginbuilder, Buckminster, B3), but I think that the gap with them to create and maintain a build remains quite high. The demo I have seen from Pascal of tycho, let me think that it's a promising approach as I have found that it hides the complexity.

Of course there was lot of other pretty cool talks and demos, like the Jeff Noris keynote, that you missed if you weren't at ESE this year. See you next time !

Search in eclipse forum

2010-08-27T12:16:00.006+02:00

If you would like to search in eclipse forum, here is a quick form which may help you.

Resize matters !

2010-05-10T12:04:00.013+02:00

A spam like title because recently I worked was on resize stuffs :

On GEF Bot there was a painful bug . If the edit part was resizable, a drag behaves like a resize. Now drag behaves correctly and a new resize method is available to resize an edit part :
Do you find useful the ability to drag the selector figure in the outline of GMF Editors ? you will probably like the ability the resize this figure (fullscreen video) :

I will try to contribute this feature for 3.7

GSoC 2010

2010-02-10T11:27:00.008+01:00

Now that Google announced that they will sponsor this year again students to work on some cool open-source projects, I hope Eclipse foundation will be candidate again.

Mentoring organizations should candidate before March 12, but we could start now to collect ideas, they could be contributed on the wiki. GSoC is an incredible opportunity for eclipse community to see enhancements or new features added to your favorite projects, do not miss it !

If you are a student and don't know how to get involved, have a look to our new contribute page.

you will find more info on the GSoC 2010 flyer and important date on the timeline.

Sketch capabilities for your GEF based editor

2010-02-02T16:49:00.005+01:00

As everyone, I suppose you have seen iPad videos, at least you heard about it :

iPad from stadycam on Vimeo.

I suppose you have complained about its closed platform, its single-task os, or may be its tendentious commercial name. However with such a device (a tablet), you think your GEF based editor could benefit from sketch capabilities ? Indeed that something Ugo Sangiorgi did :

OmniModeling on MoLIC Editor from Ugo Sangiorgi on Vimeo.

The good news is that it will probably be contributed to Eclipse.org. If you are interested, have a look to this new project proposal.

Know your limits

2010-01-07T14:05:00.007+01:00

Thanks to OSGi one of the main qualities of Eclipse ecosystem is its modularity.
In a modular architecture, contract between components is fundamental. I called contract not only the features offered by a component but also its limitations. Quite often we tend to concentrate on features and and miss limitations.

To illustrate my point I will take as an example SWT Eclipse component
I recently needed to add printing support to a custom editor. SWT provides some printing API. I first tried an approach which consisted of printing a snapshot of my already drawn widget. I did it using the SWT faq and added quite easily header, footer and fit to page support but it remained a blocking bug. Sometimes, randomly, a white shadow (of the previously opened print dialog) appeared on my printed widget. I tried to hack by calling redraw and update methods on the control but as I am not a graphic guru I gave up and finally have implemented the printing feature with success using the excellent PaperClips library.

During my hack attempt I saw in code that Printer.getDPI() returns always 72X72 in SWT GTK implementation. I don't want to blame anyone neither SWT nor GTK, just remark that on linux print is not completely supported, and this information may be difficult to find until your get the bug or read concerned code.

So quick reminder for developers : think to document your component limitations !

GEF support in SWTbot and GMF

2009-11-06T16:38:00.008+01:00

Back from ESE where I gave my presentation about GEF support in SWTBot last week, I am happy to announce that GEF feature is available in SWTBot update site. Thanks Ketan for that.

Quite obviously there are several bugs opened and there is room for improvement but current API is not frozen, so it's time to test and ask for enhancements !

On GMF side I updated yesterday its main wiki page to use tabs. There is a lot of valuable information available on the wiki for GMF, but it was scattered. I hope you find the new page clearer and useful.

Nathalie effect : goals, tests and patches

2009-09-27T12:55:00.011+02:00

In the last post I blogged about La baule beach. This week-end it was the famous triathlon race in the atlantic seacoast city. At Obeo we try to participate each year to the tri relay. Tri relay distance is quite similar to a triathlon Sprint distance, but each sport event (swimming, cycling, and running) is performed by a different person. This year Ed participated with us. He took the opportunity to be in Nantes to went for a fresh swim early in the morning.

During the race, Freddy, Goulwen, Laurent, Nathalie, Stéphane and others cheer for us.
Despite of these many supporters, I did not beat a time, to be honest I was one of the slower cyclist. However the tri relay was not the significant competition, the football match on the sand after it was the real one !

After one hour and half we grab a victory and Nathalie was the key of our success !
In the evening we were very well received by Cédric, with a giant and delectable barbecue.

Friday and today I worked on GEF Support for SWTBot.
If you follow bug 269609, you should have seen that Initial code contribution was committed, and that I am currently working on SWTBot build to include the GEF feature.
Nathalie tested and provided patches on first versions, so many thanks to her on this side too.

Sea, Text and Fun

2009-07-28T11:08:00.007+02:00

I spent last week-end in La baule, having fun to swim, play football and read on the beach.

Photo from Burgermac

Speaking about books, I recently finished to read the great book from Robert C. Martin, Clean Code. One really interesting chapter, is about comments and how they could be dangerous.

I will not speak here about javadoc and API documentation, but all other comments which are used to add tasks (TODO, FIXME), explain an hack or anything else.

The main difficulty is to keep them in sync with the code. As they are not linked to the code they refer, they may move with code addition/refactoring or become inaccurate if the implementation change. Another leak from these comments is that it is difficult to retrieve the author, or to start a discussion from one of them.

In fact, as this kind of comments are meta-data, it could be more logical to dissociate them from code, I mean to store them outside of the code.
We do it of issue tracking (and sometime for tasks), but then comes the problem of integration between tools.

In the last version of OpenOffice, notes are displayed in the margin. I find it very usable.

So here is a quick mockup, of what I would like to have for this kind of comments.

Eclipse and firefox 3.5 on linux

2009-07-08T16:46:00.005+02:00

If you updated to the last version of the cool open-source web browser, mozilla firefox, on your favorite linux distro, you may have noticed some problems. For instance, if you opened the welcome view or the help contents, the following exception has appeared :

org.eclipse.swt.SWTError: XPCOM error -2147467259

This comes from xulrunner 1.9.1 which breaks binary compatibility with previous versions.You need to add to your eclipse.ini file as jvm argument (after "-vmargs") :

-Dorg.eclipse.swt.browser.XULRunnerPath=/usr/lib/xulrunner-1.9.0.11

Hope this help.

Using org.eclipse.ui.menu 3.3 API for popup menu

2009-04-27T15:11:00.018+02:00

I am not sure new qualifier still apply for an API available since Eclipse 3.3, but here are some questions I have asked myself and for which I would like to share some answers.

Where can I find a good introduction to the new API ?

There is a great IBM article ideal to discover the API.

Where can I find id for group ?

Have a look at the following interfaces :

org.eclipse.ui.IWorkbenchActionConstants
org.eclipse.ui.navigator.ICommonMenuConstant

Where can I find available variables ?

On the Eclipse wiki.

Where can I find an eclipse plug-in example ?

In one ATL plug-in for instance. Here is an example where the popup menu item is displayed only when the active perspective is the right one, and the selected files extension is ecore.

How can I get the selection for popup menu ?

Be careful the selection variable is not the same for classic menu and popup menu.
You have to use activeSelectionMenu.

How can I do to not display the menu if the selection is empty ?

You have to use count element.


<visiblewhen checkenabled="false">
   <with variable="activeMenuSelection">
       <iterate operator="and">
         <count value="+">
        </count>
       </iterate>
   </with>
<visiblewhen>

How could I call a test in Java ?

First you have to create a property tester :



<extension point="org.eclipse.core.expressions.propertyTesters">
 <propertytester id="com.mycompany.project.tester.MyTester"
  type="org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart"
  namespace="com.mycompany.project.namespace" properties="isLikeIWant"
  class="com.mycompany.project.namespace.MyTesterClass">
 </propertytester>
</extension>

Then you can use it with test element :




  <visiblewhen checkenabled="false">
     <with variable="activeMenuSelection">
        <iterate operator="and">
           <instanceof value="org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart"></instanceof>
           <test property="com.mycompany.project.namespace.isLikeIWant"></test>
           </iterate>
    </with>
  </visiblewhen>

EclipseCon 09 - Week-end before and first day

2009-03-24T07:56:00.012+01:00

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

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

At least we found one of their office

as well as their own street

and their famous google cars

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

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

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

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

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

Eclipse Foundation accepted for GSoC 2009

2009-03-16T10:55:00.008+01:00

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

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

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

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

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

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

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

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

Hope you will find it interesting !

Obeo grid layout contribution

2009-01-22T18:18:00.004+01:00

Open source projects are like plants.

Photo from A National Acrobat

As there is already some gardeners, there is no obligation to provide them with water, but I am convinced that giving some compost will help them to grow.

It could be feedback and help, translations ,articles, bugs tracking or patches.

Recently we contributed a generic grid layout provider for GMF runtime.
We hope it could be included in GMF, and people could benefit from it, as we benefited from both EMF and GMF projects.

Basically you inherit from the generic grid layout provider, and only define 3 parameters :

- the vertical padding
- the horizontal padding
- the number of columns

Here is an example showing the results with the GMF logical example, and 5 as value for each parameter.

Before arrange all.

After arrange all.