1. Changes

    imageHi everyone,

    This is kind of a special time for me, as I’m about to leave Obeo at the end of the month.
    A little bit more than 4 years ago, I was a young student discovering the enterprise world in a start-up focused on model driven engineering & eclipse technologies.
    I knew nothing.
    Since then, a lot has happened in my work life, and I can only thank the Obeo guys for that. I have so many good memories that I don’t even know where to start… The blazing discussions we had during our “Geekussions” meetings, sitting between Ed Merks and Eike Stepper at my first eclipsecon, the first time I delivered a software on my own, feeling part of an awesome developpers team, when the eclipse project I lead joined the Release train, the stress and then the pride of my first talk…

    But why am I leaving then, you may ask? This has not been an easy choice… I think I had a declic while giving a Sirius training: I really felt as if I was skilled in my field. As a fan of Bret Victor, I knew that feeling competent was the worst thing that can happen to the young software developer I am. I know not much, and I want to learn new languages, meet new challenges, discover other application fields with new people and ways of working.


    I have the incredible opportunity to join another startup, iRealite, as a CTO. Our challenge is simple: take brand new disruptive technologies (Brain-Computer Interface, Leap motion…) and find usages to improve the day-to-day life. You can subscribe to my new blog to discover new technologies & the APIs to manipulate them. I may also talk about team management & the day-to-day life in a startup.

    I’d like to finish by thanking all the Obeo & Eclipse guys I’ve had the chance to work with. I hope one day I’ll be able to learn to others as much as I’ve learned from you.



  2. EclipseCon Europe 2013 Day 3: Light my Fire


    Again a great day at Eclipsecon :)

    • Sirius BOF

    I think that this was the most amazing BoF I ever saw at eclipsecon (and I’m not saying that because it was about Sirius ;): we add a lot of attendes, each of them coming with their own domain models (or a demo one) and trying to create modelers using Sirius. After 30 minutes, there were already some nice modelers going on, and although we started to hear the Eclipse band playing many people stayed for… more than 2 hours!
    I think almost everyone did manage to obtain a modeler and understand how Sirius works, mission accomplished :)

    The night at the Nestor bar was amazing, the vibe was definitely good, and as always the Eclipse Fondation staff was warm and kind. That is why I did not manage to get up early enough to have the time to checkout and go to the keynote in time…

    How, that was an impressive talk. It convinced me that the barrier for using Scala has been blown up. Now you have tycho integration (just replace “java” by “scala” in your pom.xml), you can mix java and scala in the same project, you have a live interpreter to test your code… Really nice Eclipse integration. The killer feature for me was that you are now able to copy a java class, and when you paste it inside a Scala class the code is automatically (and smartly) converted to Scala.
    A great talk, and a great speaker. Of course there is still issues related to scala itself (the big VM for example), but Eclipse is ready for Scala.


    John made us walk into the jungle of graphical modelers, pointing out all the limitations, mostly in regards to end-user interactions. Funny and interesting.

    He worked on a prototype based on JavaFX with instant feedbacks, great layouting, live contextual menus, zoom in and out to navigate into new diagrams, movie, browser or forms live integration… This could be an awesome contribution to Sirius, so that your diagram can be renderred with GMF or JavaFX with the same Modeler Specification.

    • The end…

    By the way, Obeo guys gave interviews to InfoQ France that should soon be available :)

    And that’s it for this EclipseCon Europe 2013! Great talks, great people, and many interesting discussions.
    As usual, I’ll end this post series in music, but this time is special for me as this song was made by my music band “Ignition”. Now that you met me, you know my name, so do not hesitate to spam me through twitter or the Mylyn Intent and Sirius forums. See you all at EclipseCon US 2014, already have some exciting talk ideas :)


  3. EclipseCon Europe 2013 Day 2: Wonderland


    Hi again! An intense day, as I was at the Sirius booth I did not attend all the talks I was planning to but here is a sum-up of what I saw. Quite a lot of impressing technologies today, the Oculus Rift was definitely an attractive attraction, a shame I did not have a chance to test it.

    Marty shared his experience in how to quickly make your software scalable. Pinterest, a web-platform, had only a few users and 3 developpers in March 2010 and gazillions of views every day in April 2012.

    Lesson 1: It will fail, keep it simple. Avoid using many technologies you don’t fully master and keep your architecture as simple as possible.
    Lesson 2 Choose your technology stack wisely to use technologies that are mature and wildly used by others:
    - Does it meet your requirements?
    - How mature is the product?
    - Is it commonly used? Can you hire people who have used it?
    Is the community active?
    - How robust is it to failure?
    - How well does it scale?
    - Does it have a good debugging tool? A Profiler?
    Is the cost justified?
    Lesson 3: have fun (otherwise you’ll just jump out of the window)
    • Vert.x (Norman Maurer - Redhat)
    Vert.x is:
    - an asynchronous platform by nature
    - with general prupose
    - high performing
    - Polyglot (you can write your app in different langages such as java, javascript, groovy, ruby, python, scala, closure and php)
    - flexible
    - Supported protocols: tcp, udp, http, https, websocket, sockjs…
    It’s based on Netty. You can directly use netty for simple tasks.
    Vertx is based on a thread-model: everything is executed in one single event-loop.  Any non-core feature is defined in a module. You can create your own modules and register to the module registry so that others can re-use them. A test framework is provided.
    Here is a simple example allowing  read asynchronously in a queue:
    public class Server extends Verticle {
          public void start() {
    new Handler<HttpServerRequest>() { public void handle(HttpServerRequest req) { System.out.println("hello"). } }).listen(8080); }); }
    Simple and easy to read. The first milestone inside eclipse has just be released. Definetelly good stuff, I’ll give it a try home.
    Markus shared his experience as the lead of the EPP (Eclipse Packaging Project) through the 8 last releases of Eclipse.
    Eclipse has gone a long way since the Galileo release (10 projects) to the Kepler release (70 projects). As I already handle the participation of Mylyn Intent (and now Sirius) inside the Eclipse Release Train, I did not learn much here, but I hope that newcommers were interested in seing behind the scene of the Eclipse releases.
    Mikael took us to a journey in Model comparaisons, showing how can EMFCompare compare, detect conflicts and merge your models.
    Based on day-to-day use cases, the talk was composed of 3 demos:

    1. Comparaison of 2 ant files. We discovered:
    - how can EMF Compare be automatically plugged to detect differences in XML files in a nice graphical way, instead of having to handle text comparaisons. Everything is integrated in the Eclipse Team Provider UI.
    - With the appropriate EMF bridge allowing us to raise the level of abstraction (and define concepts like targets, imports…)., the differences are way easier to understand as they use semantic concepts.

    2. Detect binary compatibility breaks in our Java code.
    It would be great to have a tool allowing to compare 2 snapshot of a java code and detect only API breaks. With the appriorate EMF Bridge allowing to represent java projects as models, EMF Compare allows us to provide custom filters through extension points. Here we use a filter that only shows all the changes that actually break the API. I did like that Mikael did not just show an end-user demo, but actually taught us how to implement such filters through EMF Compare API.

    3. Incremental transformation
    We often define transformations on our models (for instance to transform our business model in a Database-oriented model).
    Mikael showed us how can we use EMFCompare API to define incremental transformations so that if you convert a business model B1 into a database model DB1, if you modify B1 you don’t have to relaunch all the comparaison but smartly transform only the elements that have not been created in DB1. Smart, efficient, and a good way to show how can we use EMFCompare API in standalone programs.
    But we still have a lot of corner cases (rename table keys when renamming the table…). Moreover, the database model may not be the direct result of a transformation (if users directly edit this database model).
    That is when conflict comparaison comes into play.

    Mikael concluded by showing another example of customization that we can bring to EMFCompare (such as filters): the graphical comparaison.
    One of the EMFCompare bridges provide new graphical viewers to see the changes you made on Papyrus diagrams directly on the diagram viewers and not from a tree view. The audience was impressed :) Very interesting Q&A afterward, to sum up it was a great talk.

    Eike is known to make great talks. It was the case that time too :)
    After having created a Metamodel according to a fake customer needs, Eike listed 10 reasons for which we were not quite ready to deliver, and for which CDO provides answers (I regrouped some of them):
    1. Persistence: CDO allows to store your models inside a database (of course the physical back-end technology is up to you: PostgreSQL, MySQL, DB4O, MongoDB…). CDO is compatible with several protocols so that your application can “talk” with the CDO Server (tcp, http).
    2. Transactions: CDO makes sure that all your model modifications occur in ACID transactions. If all your changes are accepted then they can be committed, otherwise you cannot commit a partial and invalid set of modifications.
    3. Collaboration: CDO provides a real-time notifications mechanism, so that when some user saves changes he made on a model element, all the other clients manipulating that element can be notified & updated in real-time. Of course there is a conflict resolution mechanism.
    4. Scalability: CDO provides Data Transfert Objects allowign to get rid of the strong references between model elements. This allows to garbage collect EMF objects and hence handle big models. Eike demonstrated this with a nice graph showing the objects loaded in memory, nice and clear.
    5. Thread safety: EMF is not thread-safe, which can be annoying if you want to do parrallel processes. CDO solves this by allowing you to open a transaction for each thread, which is cheap as all the Data Transfert Objects are shared by all transactions if identical.
    6. Auditing: CDO provides API allowing you to open “Audit Views”, i.e. a read-only vision of your model as it was at a certain date/commit. Eike made a demo with a slider allowing to go back in time and see the model state, Greater gods!
    7. Role-based security: I’ll not enter in details here as I coverred this topic yesterday.
    8. Fault Tolerance/Offline availability: if your connection with the server fails, CDO provides an offline mode support, allowing you to continue working, and commit the changes whenever the master Server is available again.
    Interesting Q&A, that allowed us to talk about the Query mechanism (to quickly query your whole database in OCL, SQL or your owns Query handlers).

    I’m damn proud of being a commiter on this awesome projects, and hope that I’ll help make it even better in the future :)

    The talk went well, I invite you to read the slides and visit Sirius website if you want more news about this new awesome eclipse project :)

    I’m posting right now because I’ll be busy at the Sirius BoF tonight at 19:00, attend if you want the sirius commiters to help you defining your own graphical modelers according to your own needs :)

    Read More


  4. EclipseCon Europe 2013 Day 1: Cat Attaks

    What a great day ! Sorry if this post is harder to read than usual, I did not have time to write it during the talks so I have to use my notes. I’ll try to do better tomorrow.

    After warm applauses to celebrate Ed Merk’s brithday, Brian gave us one of the best keynote we ever had at Eclipse Con. This is definitely in my top 3 with the EclipseCon France keynotes.

    It started with a quote that well sums up the talk: "Engineering is easy, people are hard". Although most of us has spent 5 to 8 years learning computer science, we haven’t spend one single minute to learn how to work with others. That’s why we spend most of our time yelling and complaining, instead of doing what we like. By working on humility, respect and trust, one could really improve his work conditions.

    One of our biggest issue is the genius myth: most of us want to be seen as smart, because we want to look like our idols (so true, for me that would be Donald Knuth or Bret Viktor ^^). There is no genius (well or maybe once every century). So this attitude only produces insecurity and inhibits progress because you’re so afraid of making it wrong. I think Biran got me when he quoted Tylor Durden :  You are not special. You are not a beautiful or unique snowflake. You’re the same decaying organic matter as everything else.
    Then Brian defined the Bus factor principle, which is the number of people in your project that can be hit by a bus before your project collapses. Lose your individual ego, it won’t get you anywhere. What is important on the other hand is to have a strong team ego: be proud and be demanding of what your team produces, . Don’t erase your failures, document them.
    Brian made us laugh with many stories, I loved that one : 
    A manager loses 10 millions $ in one day. Then he gets to his office, prepares his demission letter. When called inside his CEO office, he gives the letter. The CEO reads it, and say “Why? I’ve juste spent 10 grounds forming you!”.
    Don’t destroy bad habits, replace them with something better.
    Really a great keynote, with many concrete advices I’ll definetely apply at home.


    I did not attend Melanie’s Talk but so many people were talking about it that I at least have to put a picture :) She demonstrated how can Eclipse Sirius be used to define easy-to-access modelers to program a cat robot using arduino. The talk was definitely a success and you’ll probably have a chance to see it in future Eclipse events.
    Due to the diversity of the persons (developers, designers, managers) and the artifacts (code, doc, test, bugtracker issues, builds…) involved in a software lifecycle, everyone uses different tools to handle related information. Lean/agile development is ony lean/agile if it is handled from end to end. Managing information in a spreadsheet somewhere in the chain and you’ll fail.
    Thanks to the continuous integration & devops, we are now able to have a lean development on the software assets. But for the other artifacts, we need a software lifecycle integration (SLI) to link all this information. A good example is the gerrit mechanism in eclipse, in which hudson builds, reviewers and commiters can communicate very quickly and fail as early as possible. A similar mechanism must be made for scrum masters, managers… Federating is the keyword : find a common representation(model) to represent ALM information. Interesting talk, but I want to get more details about what’s planning for Mylyn 2.0.
    Well the least we can say is that many cool stuff are coming in EGit. I personnaly use the command line, but that talk convinced me to give Egit a try. 
    Egit 3.0 (June 2013) provides new merge options, rename detection, and the possibility to use expressions (head..3, commit id…) to reset.
    Egit 3.1 (September 2013) provides new presentation modes in the staging area (tree, list) and filters. There’s also an interactive conflict resolution during rebase, and the integration with emf compare for models, 3 way compare and mylyn links in history & staging view.

    Egit 3.2 (December 2013) will provide a lot of new features like
    • push branches (equivalent git push -u) and push tags wizards
    • interactive rebase support,
    • search for commits in the history view, 
    • Merge drivers: binary & model-base merge drivers will be added to the text-based merge driver
    • Support for HTTP

    There are also a lot of performance improvements (like the clone and fetch operations which went from 60s to less than 80ms thanks to the use of bitmap indexes to reduce the “counting” phase).

    The demo of these new features was really impressive: “compact tree” view, filtering, additonal Drag and Drop support to open files, completion showing previous messages and impacted files, interactive add… make rebase operations and staging area manipulation way easier.

    Graphical interactive rebase, although still a work in progress, is clearly impressive ! It has all the feature you could expect (skip, edit, squash…). Just select the commits you want to rebase interactively, click on interactive rebase, open the new git interactive rebase view, use UI tod ecide what you want to do with each commit and just press start. Convenient!
    Just to let you know that we’ll put the slides of our talk tonight. The talk went well, I’ll let you read the slides and ask questions if you’re interested.
    • Modeling Symposium
    Always a good place to discuss with modeling enthusiasts. Many projects were presented (EMF Client Platform, EMF Rest, EFactory 2 - based on Xtext, OCL…). Eike Stepper presented the new Role-based security model provided by CDO 4.3. It allows the definition of fine-grained access rules on your CDO repository. For instance you can easilly forbid one user to have WRITE access on any element of a specific type. Cool stuff ! 
    • Sirius Booth
    This year is particulalry busy as we also have to be at the Sirius Booth. Many many people interested in this new eclipse project, hope to see you all at the Sirius talks and especially at the Sirius BoF, where you will be able to build YOUR modelers for your needs with the help of the team :) 
    I also had passionated discussions with Mylyn Intent enthusiasts, many exciting things should arrise in the Eclipse Luna release :)
    Well that’s it for today, see you tomorrow! And as always, please do not hesitate to stop me and have a chat :)

  5. EclipseCon Europe 2013 Begins - Walk on the wild side

    Hi guys !

    Today starts the EclipseCon Europe 2013, plenty of exciting talks & events planned, as usual I’ll try to sum it up with day-by-day reports.

    This EclipseCon will definitely be the chance to take a walk on the wild side of Eclipse projects, with the first release of Eclipse Sirius, new major versions of awesome projects like Code Recommenders, tutorials and of course the BoFs which remain my favorite event as we actually can annoy the commiters of our favorite projects with our ideas. By the way, we’re giving a “hands-on” Sirius BoF tomorrow, come with your business model and leave with awesome graphical modelers for it! It’s been 2 years now that we have started this concept for companies, I’m really excited to see what the community will do with Sirius.

    Stay in tuch to get fresh news about the conference :)


  6. Intent Interview with InfoQ FR (French)

    Hi guys!

    Just realized I did not post about this interview made for InfoQ France. This is a general presentation of Mylyn Intent principles, with useful information to quickly get started (in french) http://www.infoq.com/fr/interviews/interview-alex-lagarde-eclipseconfrance2013

    We are currently working on Intent stability and performance, many improvements will be available in the Intent 0.8.1 release (aligned with Eclipse Kepler SR1 in September). In the meantime, you can install Intent nightly builds http://download.eclipse.org/intent/updates/nightly/0.8/N201308121238.

    And by the way, we submitted an exciting abstract for EclipseCon Europe http://www.eclipsecon.org/europe2013/living-documentation . Melanie will demonstrate how she used Intent to specify the behavior of UML Designer, and make sure that as soon as she modifies the behavior of the modeler, the specification is correctly updated. Your doc becomes alive, ALIVE!


    Stay tuned for more news about Intent and Sirius!


  7. Markup bridge: from Wikitext to EMF

    Today I wanted to talk about one of the components we had to develop for Mylyn Intent: the Markup bridge, which allows to represent any Wikitext-parsable document (written in MediaWiki, Textile, Confluence, TracWiki and TWiki markup) as an EMF model.

    Notice that this component is completely independant from Intent, and only depends on Wikitext and EMF.


    1. Why on earth did we do that?

    As explained in my previous post, we decided to represent Intent documents as EMF models. An Intent document is nothing more that a set of pure documentation zones (written using a Wikitext syntax) and additional information (links between doc and Java classes, Manifest files…).

    So to be able to represent an Intent document as a model, we first needed to represent Wikitext content as a model.

    2. How does it work?

     It is quite simple: we use a Builder Design-Pattern:

    • The MarkupParser (provided by Wikitext) sends signals while parsing a text conform to a Wikitext syntax (e.g. beginSpan(), image(url,links)…)
    • The ModelDocumentBuilder (provided by our markup plugin) intercepts those signals, and:
      • Changes state if needed (e.g. receiving the beginBlock(LIST) signal in the SSection state will makes us move to the SList state)
      • Creates the corresponding model elements


    3. How can I use it?

    Sources of the org.eclipse.mylyn.docs.intent.markup plugin are available on github (or from the intent git repository).

    Then you just have to create a new Markup parser (pure Wikitext) and plug the ModelDocumentBuilder (provided by the markup plugin) : 

    // Step 1: create parser
    MarkupParser parser = new MarkupParser(new TextileLanguage());
    DocumentBuilder builder = new ModelDocumentBuilder();

    // Step 2: parse textile string
    parser.parse(“h1. Some Textile text”);

    // Step 3: get corresponding model
    Collection correspondingModels = builder.getRoots();

    And for those who (like me) enjoy EMF, the markup plugin also defines a WikitextResourceFactory, associated by default to any file with the “.textile” extension, that creates an EMF Resource from a textile file.


    new ResourceSetImpl().getResource(URI.create(“platform:/resource/myProject/myFile.textile”))

    will return an EMF resource containing the content of the textile file as a model. We even have a prototype, the WikimediaResourceFactory, that allows to read a page from a Wiki and represent it as a model. Pretty useful for exporting the content of a wiki as a PDF for example.

    4. What benefits for me?

    Well representing information as model brings a lot of benefits, as explained in my previous post. The main one in that context may be that it is straightfoward to write new generators for Wikitext documents. The markup.gen plugin contains HTML & Latex generators - contributions are welcolme :)

    But all over benefits are interesting too: it is now easy to define validation rules on our textile documents, you can store it in databases or collaborate in real-time on textile documents…

    According to me, being able to represent any document (for the time being it is just for Wikitext-compliant docs, but we can imagine doing the same thing for AsciiDoc, Latex or LibreOffice documents) in an unified way allows to use the right tool for the right task.

    I think it makes cense to pull-up this markup plugin in the mylyn.docs component (instead of Intent), I have started a discussion about this with the mylyn docs community, and raised a new bugzilla issue.


  8. Why on earth should I use EMF?

    Hi guys,

    people often ask me why on earth I use EMF in the Mylyn Intent code. Intent has nothing to do with models (at first sight at least), and yet I use EMF everywhere. I think this question is interesting, and shows that a lot of people still don’t see the awesome benefits brought by the use of EMF & the whole Eclipse Modeling Tools.

    In this post, I’ll try to briefly list all the benefits and drawbacks of having based Intent on EMF technologies.

    1. Storage abstraction: from workspace to database


    The first benefits is that, by storing the Intent Document as an EMF model (instead of text), I can use any serialization mechanism provided by EMF. The default behavior (provided by the Intent Workspace Support) is to store the Intent Document as an XMI file in an hidden folder of the Intent Project, but we can do much more:

    • using the EMF binary serialization would optimize the disk space for free
    • using the CDO technology to serialize the Intent document allows to store it inside a database (MySQL, H2, MongoDB, PostgreSQL…) for free. CDO also provides real-time sharing capabilities (see 5).
    • We could perfectly imagine using a JSON-based serialization, so that my Intent Document can be interpreted by any javascript framework (to provide a web-based editor for instance).

    2. Synchronize with any technical arfifact (EMF Compare)


    One of the key feature of Intent is to be able to compare the technical artifacts referenced inside the Intent Document with their actual state in the workspace. To do so, we have defined a model-based synchronization mechanism: as long as you are able to represent a technical artifact (e.g. a Java or C++ class, a MANIFEST.MF file, or even a bugzilla task) as a model, then it can be handled by Intent.

    Then we use the EMF Compare project to compare the Intent Documentation with the Workspace. EMF Compare also provides nicelly integrated UI to display the differences between doc & code:


    And, of course, you are able to make interactive merges between the doc & the code.

    3. Complete tooling to export the Intent Document (Acceleo)

    Another strong benefits brought by the Modeling stack is Acceleo: it provides a nice tooling to define your own generators. So it is pretty straighfoward to write exporters for the Intent documentation: for the time being, there is only an HTML Bootstrap export available, but we are also working on a nice LaTeX/PDF export.

    In addition of being easy to write, providing type checking so that you can easily update your generators when your model changes and a first class user experience (completion, refactoring…), the Acceleo modules are easily extensible. So if you are not 100% pleased with the default HTML export and want to customize it, you can easily extend and override the little parts you want to change.

    4. Extensible Validation (EMF Validation)

    EMF Validation provides extension points and APIs to easily define your own constraints on models, using the langage that seems the most appropriated (OCL, Java…). 

    Intent uses this framework to validate in real-time the referenced technical artifacts. So you are able to define custom constraint with richier capabilities than with checkstyle for example: you can plug a custom constraint that says that “Any Java class extending AbstractAcceptanceTest should only contain public methods entitled ‘testScenario<SCENARIO_ID>’”. Any time this constraint is broken, Intent will display validation issues and provide quick-fixes (you can plug  custom quick-fixes by contributing to extension points).

    5. Real-time collaboration (CDO)


    According to us, Documentation is a social task, that could really benefits from real-time feedbacks and review. Thanks to the real-time notifications provided by CDO, with a CDO-based Intent Repository 2 users can share their doc in real-time. Any time a user saves, the modificaitons are commited on the CDO Repository, and all clients that have an Intent editor opened see the changes in real-time.

    How long would it take to write your own server with such capabilities?

    6. REST APIs thanks to EMF URIs

    Another useful thing is that EMF allows to provide your own URIHandler, so that you can provide REST APIs. In Intent, you can query the information held by the Intent Documentation thanks to URIs:

    • 'intent:/INTENT_PROJECT' returns the Intent Document contained in the given project
    • 'intent:/INTENT_PROJECT/MyJavaClass' returns the JavaClass represented as a model

    So you can see that the keyword here is absraction: abstraction in storage, representation, generation, validation, comparaison… The Eclipse Modeling Stack is full of tools that you can use for free to provide added value to your software. For instance, I could use the new Sirius project to define graphical modelers allowing to visualize graphically and interact with the Intent documentation.

    Some drawbacks

    If I have to be completely honest, there is still one thing that can be annoying whit EMF, it’s the backward compatibility: if I want Intent 1.0 to be able to work with Intent documents defined in Intent 0.8, I’ll have to write code migrating the old models as instances of the new 1.0 metamodel. It is also the case with CDO.

    But this is an issue you would have had even when writing your own serialization mechanism.

    Please let me know if you have reaction or question, I’ll be glad to answer!


  9. EclipseCon France 2013 - Day 1

    Hi guys! Today started the EclipseCon France in the lovely town of Toulouse. Plenty of interesting things, let me try to share my excitement with a band from Toulouse, “Zebda”. The song is called “Motivated”, which sums up my state of mind pretty well ! http://www.youtube.com/watch?v=dBpLJ4X4vJY


    Like for last EclipseCon Boston, I’ll try to share things I’ve lived and learned during those 2 days. Let’s start with the morning tutorials.

    JavaFX tutorial

    I have to admit that I’m a JavaFX noob, and I wanted to seize the opportunity to learn more about that technology.

    Well the first thing I can say about that tutorial is that Sebastien Bordes is really passionated by JavaFX. He develops JRebirth, a framework for JavaFX (see below). Even his slides were in JavaFX, how cool is that? Check out this link to see how you can make JavaFX-based slides.

    Here are some of the technologies and framework we tried during this tutorial:

    - eFXclipse that allows to create an RCP OSGI or e4-based application in two clicks, pretty impresive.

    - Scene Builder which is a WISIWYG editor allowing to easily design javaFX apps, you can see it as a kind of “Window Builder” for JavaFX. In result you’ll get an fxml file that you will be able to load using the FXMLLoader library, and Bam! you’ve got the App you’ve designed :)

    - JRebirth is a JavaFX framework based on the RIA pattern. It also provides lot of utility class (like Java Builders) and also simplifies multithread development. Architecture seems neat, definitelly want to test that.

    image (Thanks to Fanboy for the picture)

    Then Sebastien showed us an impressive demo of JavaFX power and helped us to revise our multiplication tables with a Game he created :)  Quite impressive rendering, although I did already have a sneak peek of JavaFX-based apps thanks to the EclipseCon Boston’s Family Freud (made by Marcel Bunch, the Code-Recommender leader).

    Then we tried to modify the game to change some parts, and Sebastien shared some insights on the way JavaFX deals with Layout & Bounds (especially when using Rotation or reflection effects), detailled the way notifications are handled, showed us some advance styling with CSS, real-time image transformation and how to create animations.

    So to sum things up, good tutorial, I’ll have to try JavaFX at home. By the way, did you know that EEF 2 provides a free integration with JavaFX? You may want to check it if you’re interested in JavaFX.


    OSLC tool integration tutorial

    Jean-Luc Johson, Olivier Lacroix (EAS) and Matthieu Helleboid (Thales) introduced OSCL to us. Complex systems design still have a lot of issues to tackle, from Collaboration between different domains to be able to handle huge amount of data. In that context, OSCL provides a REST API allowing tools to get data from other tools, so that you can use the right tool for your current task while staying compatible with others.

    The tutorial allowed us to learn how to consume & provide OSLC services.


    Keynote “The Humanist Perspective of Industry 4.0”

    Hans-Jurgen Kugler gave us a truly inspiring keynote, I prefer not to sum it up as you should definitely check the slides. Plenty of interesting ideas and books to read, one of my favorite EclipseCon keynote ever.

    I’ll just repeat one of Kugler’s favorite quote: “Some look at things and ask ‘Why?’, others imagine things and ask ‘Why not?’”

    How beginners took on the RCP Framework!

    Anne-Laure Lugan (EADS Astrium) and Igor Laborie (AKKA) shared their experience about building RCP apps, with no previous experience on the subject (well, Igor did come help the team every month as an RCP expert). They organized their talks around 5 questions that they had to answer during the development of their RCP application.

    1. How to learn the Eclipse RCP Framework?

    - Any developer with some UI experience (even without knowing SWT or JFace) should learn quickly, there is a lot of tutorial regarding SWT UI.

    - The most important and first thing to learn is OSGI. Once you’ll get the major OSGI principles and begin to “think modular”, then you can go on with the UI technologies.

    Igor adviced people to attend to the OSGi talk given by Michael tomorrow.

    2. How to start a project with RCP newbies?

    They used Agile methods, and particulary this item of the Agile Manifesto “The best architectures, requirements, and designs emerge from self-organizing teams”. So they started by not “thinking modular”, keeping core & UI in the same plugins, making this mistake on purpose as they did not feel like doing better. A few months later, they  decided to split everything, but then they were ready to do so and had a better knowledge about OSGI.

    So don’t be afraid of making mistakes first, and refactoring latter.

    3. What are Eclipse RCP benefits?

    Well I think that you already know them: OSGI provides modularity, Eclipse RCP framewok all kinds of usefull frameworks and good practices (logs, preferences…).

    Reuse of existing code is also a major aspect, Eclipse having tons of snippet or open-source code to check before re-inventing the wheel.

    4. How can I prevent my Eclipse RCP app from having bugs?

    Of course, this goes with test automation. They started by making UI functional tests (using Squish as they wanted to be able to test QT-based apps too), but such tests are always very long to execute, and they finally managed to transform UI tests into integration tests. And of course: start writing test at the begining of your project, don’t wait.

    5. 3.x or 4.x?

    Ah, I wondered if they were going to talk about that :) Igor thinks that it is easier to use 3.x, 4.x introducing new concepts (e.g. dependency injection) that are tuff to understand for newcomers.  Moreother, the compatibility layer will make 3.x apps working on Eclipse 4.x.

    There are many other tuff questions to answer (Shall I use EMF? Shall I depend on org.eclipse.ide? …). To answer them, always think about your context, and the skill level of your team. Again, don’t be afraid of making mistakes. As long as you are ready to refactor your code & design, you will get by.

    In conclusion, Igor advices to read Eclipse code (there is plenty of good examples), think simple, and share your experience with your team. I liked this talk, quite refreshing to attend to.


    Software Quality: the Eclipse Way and Beyond

    Software Quality is mandatory for the polarsys project, in which projects must be supported for more than 20 years. In the eclipse context, the whole stack is as strong as its weakest part. However, there is no automatic, objective and unified evaluation shared by all eclipse projects. The maturity assessment working group intends to propose a generic quality model, and enforce the quality requirements for projects included in polarsys.

    There are many definitions and standards already existing for software quality (e.g. iSO 9126 or ECSS), even for open source (OSMM, Qualipso…), but they could not fit the variety of open-source projects. In the Eclipse context, it’s funny to see that there is only few quality guidelines, whereas community processes are fully defined. We could try to define quality with 3 criterias: reusability, analysability and changeability. 

    Data providers were implemented, giving for example the number of posts on the forum, the median time to answer, number of commits, ratio of fix-related commits, number of milestones… Datas are computed for last week, last month and last 3 months. 

    Thanks to all that data, we are able to produce automatically an eclipse quality model from source code, mailing lists and forum, process & SCMs. Then you are able to measure your responsiveness, reusability, support… The quality model will be published on a centralised dashboard. There are still improvments to make (add bugzilla information or download stats to the metrics for example), but I was glad to see this subject coming up and being dealt with very seriously. I’ll definitely follow what is going on with this project and invite you to do so as well.

    Orion deployed: Orion goes from prototype to industrial

    The most common question detractors of Orion ask is “Do developers really want to move to the cloud?”

    John Athorne (IMB Canada) affirms that developers already use browser-based tools (for their mails, tasks)… Moreover, doing so will make social coding easier, and ask yourself how enjoyable was your last IDE setup experience, you should get the point :)

    Orion focuses on embracing modern browser capabilities (get things fast) and goes from creating, editing, self hostring to deployment and source code control. One of its main specificity is to allow plugins from different web server to communicate in the same page. The Orion editor is one of the most popular component, probably because of its great scalability, and because editing files is so fast. But there are many other things in Orion, for instance a command-line shell, git integration, compare wizards… You can both contribute to Orion or just reuse some of its components (e.g. embed the Orion editor inside a blog post).

    The Orion community is growing very fast, Firefox tools heavily use the Orion editor, HP demoed agile development tool using Orion… The downside is that expectations are getting hudge (support 10 000 simultaneous connections…). The Orion server has been improved a lot, from performances to extensibility. In regards to the client integration, they used to use a single specific JS framework, but they now decided to “going native” and use the browser capabilities. They also worked hard on client customization, so that any UI part can be modified. 

    I’m not personnaly a hudge fan on the “coding on the web” approach, but John really conviced me that Orion is taking a new turn and does provide interesting and unique features.

    Ignite talks

    The principle of ignite talks is that speakers had to present their technologies in 20 slides and… 5 minutes! Interesting concept, and in result we learned so much in so few time. Bravo to the speakers, tuff exercice!

    I did not manage to take notes for all talks, here is what was presented in one sentence:

    - Swbot: the most awesome new feature is clearly the swtbot recorder, that allows to record a scenario on your app and generates the code of an swtbot test. Just add the assertions and you’ve got your test in a few minutes. As usual, Mikael made us laugh and managed to make both jokes and his point in 5 minutes :)

    - Coap: in 2020, we estimate that there will be 20 billions of connected devices. Coap (constrained application protocol) is a REST protocol dedicated to M2M. It’s compact, simple to decode, includes a DTLS security protocol and provides a notification mechanism allowing to know when requested ressources change.

    - Collaboro: both an approach and a set of eclipse plugins (available on eclipse labs) allowing to collaborate around DSL definition. On top of a mechanism allowing users and DSL specifiers to propose a solution, there are tools like a voting mechanism, a preview of the resulting DSL…

    - RMF: I won’t talk about the requirement modeling framework as it will be detailled in a talk tomorrow, and that I’m planning on attending.

    - Almathea: a model-based open-source platform for embeeded software development, including modelers and code generators. Wonder if they would be interested by Sirius :)

    And now I’m going back to the hotel to work on my Mylyn Intent and Sirius talks tomorrow, hopping to see you there!

    To sum up this first day: especially dense in interesting talks, as usual great to meet people interested in your projects, wine is better than beer (hoping I won’t start a troll by saying so)…
    In one sentence: Eclipse magic happened in Toulouse too!


  10. Want them to RTFM? WTFM !

    Hi guys, once again it’s been quite a long time but don’t worry we are still working hard on Intent.

    I’ll try to make a more complete post for the official Intent 0.8 release in a few weeks (integrated to the Kepler release train), but I just wanted to give you a sneak peek of what will be in Intent 0.8. 

    Intent 0.8: main new features

    First of all, as you can see in the Intent 0.8 Release Review Document we got busy this year. We tried to adress in priority the features and bugs raised by the community (through bugzilla or during EclipseCons), for example:

    • We simplified the syntax of the formal links, which was juged too complex by some users. To link a piece of documentation with a piece of java code, you now just have to write @ref <JAVA_ELEMENT_PATH> (e.g. @ref “com.my.project/src/MyJavaClass.java”). The old (and more complete) syntax is still available, for those who liked to go further and be able to specify things directly inside documentation.
    • We improved the Intent/Java bridge : by simply droping a java class/method/field inside an Intent document, it is automatically linked to the right doc part. To provide a good end-user experience when synchronizing doc & java code, we also added extensible hyperlink mechanisms, image rendering, quick-fixes…
    • We wrote a basic “Getting Started” documentation & cheat sheet, that will be improved soon (feedbacks are more than welcome).
    • In order to improve the end-user experience for writing pure documentation, we added new completion entries, improved the rendering, added a real-time HTML Boostrap Preview of the Intent document…


    So please, if you have feedback (positive or negative) or ideas for Intent, do not hesitate to spam us on the Intent forum or on the bugzilla, we will take time to answer.

    Intent 0.8: ok but what can I do with it?

    Just for those who might not know what Intent is about, the purpose of Intent is to provide tooling for keeping you documentation synchronized with the changes you make on your code (Java/C++ files, Manifest/plugin.xml files, models…). Whenever you modify your code, Intent is able to detect the litle doc parts that need to be updated, avoiding you a painful and manual search through whole your doc… You could see Intent as an Agile documentation, able to quikcly react to changes. You may want to read this Jaxenter interview about Intent.

    Let’s say you have a document specifying a functional Scenario (Behavior Driven Testing approach), and an acceptance test playing this scenario. You can drop the test method to link it with the doc : 


    Now that doc & java method are linked, you are able to:

    • Use hyperlinks to navigate from doc to code
    • Make semantic searches on your doc to easily retrieve all the doc parts related to a java class/method/field through the quick outline (ctrl + O)
    • Keep the two synchronized: any time you will modify this test method, Intent will raise a synchronization issue (visible from problem views). You can visualize it graphically through a compare editor, to determine how you should update your documentation.

    Everything you need to know about Intent at EclipseCon France

    I’m not giving too much details here as I will make a complete presentation of Intent features & extensibility at EclipseCon France.


    Attend to the Intent talk and discover:

    • How to create a good Intent documentation from scratch
    • How to use Intent tooling to keep doc in sync. with the changes you make on your java code
    • How to customize Intent by plugging custom validation rule (e.g. “Any string displayed to the end-user should be externalized”, “Any Acceptance Test should be named after the functional scenario it covers”…)
    • Plenty of other cool stuff, like real-time collaboration around doc

    I’ll be happy if after this talk you are conviced that if you want your team members & users to RTFM, you must start by making a better FM!

    Once again, please do not hesitate to spam me with questions if you see me at EclipseCon, I’ll be more than happy to answer, even if I seem to be working, I’m most likely faking it :)

    Stay in touch for other Intent news!