Archive for the ‘Eclipse’ Category

Eclipse DemoCamp Nov 2009 in Berlin

After the Eclipse DemoCamp in Leipzig a few days ago I went to the Berlin DemoCamp and presented emf.observables a second time. “Prezing” is fun! But step by step…

We arrived just early enough to get one seat of around 60 seats and see Ralph Müller with his key note. He incited us to become a Eclipse Foundation member and to visit the Eclipse Summit Europe 2010. He hadn’t any free tickets… :-(

Ralph Müller | Key note

Kristian Duske showed us a really cool use case for GEF3D. He used it to work with GMF mapping models (which can get really complex) in a very intuitive way. This is completly different way of handling GMF complexity in comparison to GenGMF.

Kristian Duske | GEF3D based GMFMap editor

Nothing is impossible! Arc lines between connections in a GMF based editor have been implemented! For a variability editor it is an essential feature and I know from my diploma thesis that such features are really hard to achieve with GMF.

Martin Esser | Variability Editor with GMF

Xtext is a project presented since the early days of Eclipse DemoCamps and this time done by Peter Friese. There are some new features on the roadmap for the next 0.8 release.

Peter Friese | Xtext

Break: During the breaks we talked about what we have seen and raided the delicious buffet.

Despite the original order we’ve got the one and only double feature now — two presenters using two beamers. Joachim Hänsel and Jaroslav Svacina made us aware of EVOTest a framework for evolutionary testing. It uses optimization search algorithms for finding problematic input parameter.

Joachim Hänsel and Jaroslav Svacina | EvoTest
(The second beamer was too dark for the picture.)

Do I have created a good model? How does it conform to the guidelines? Answers to such queries can give Metrino which has been presented by Marcus Engelhardt. There is also an adapter for the EMF validation framework so you could see the results in the problems view.

Marcus Engelhardt | Metrino

Matthias Köster created an IDE for Clojure and used the DLTK to do that. He showed us how easy it is to get fast results with the DLTK.

Matthias Köster | DLTK based IDE for Clojure

Break: Do I have said already that the food was delicious? Thanks to Tom for organizing the DemoCamp!

Stephan Herrmann showed ObjectTeams and a adapted version of EclipseLink to persist next to the objects the associated teams and roles.

I’m sorry, the is no picture available

SMILA is system for extracting semantic information from arbitrary media. It e.g. extracts images from PDF files and makes them searchable. You can also search for similar images like with google! Presented by Igor Novakovic.

Igor Novakovic | SMILA

Now it was my turn to present emf.observables. It is my last project and generates IObservable wrapper classes for EMF model classes. The wrappers provide an easy and type save access to the EMFObservables hierarchies.

Enrico Schnepel | emf.observables

I have used “prezi” instead of some slide based software and presenting it was much fun. Creating a prezi is relative easy and intuitive but the software to do that is very feature-limited.

All in all it was a very nice evening where I have seen many interesting projects and talked to many interesting people during the breaks.

Many thanks to Lars for giving me a lift to Berlin and to Martin for the short stay.

Check also Jevopi’s blog with his retrospective!

Eclipse DemoCamp Nov 2009 in Leipzig

Yesterday itemis had organized an Eclipse DemoCamp in Leipzig once again. Like in the many Eclipse DemoCamps I have seen before – it was once again a happening with many interesting projects.

emf.observables

The planned first presenter had some technical problems with the beamer so I filled in and showed my “prezi” instead. “emf.observables” is a new project of mine and can be used to aid in the programming of RCP applications. It generates type safe wrapper classes for IObservable Objects. It was the first time that I used Prezi for my presentation and I have to admit that presenting it was fun. From the questions I had to answer and the personal chats afterwards I got the impression that it was interesting to the audience.

“Und heute generier’ ich” by Alexander Nittka

Alex showed a nice demo from a RCP application he uses for his voluntary work at the Deutscher Go Bund. He uses a DSL developed with Xtext for entering and validating withdrawals and their rejects for all associated members. It was interesting to see Xtext in an application without the generation of source code.

Break

During the break we had some time to chat to each other while eating delicious Soljanka as well as potato soup.

JPA (EclipseLink) in OSGI Anwendungen” by Karsten Voigt

Karsten got the beamer working and showed us how easy it is to use the Java Persistence API 2.0 reference implementation “EclipseLink” in an OSGI context. The Eclipse JPA tooling allows you to generate the complete JPA infrastructure from an existing SQL database and to administrate it. OSGI declarative services are used to wrap queries. It was quite interesting but I can’t use it in my current projects because they don’t use a database.

FeatureMapper by Florian Heidenreich

The FeatureMapper is a tooling to connect arbitrary existing EMF based models with features in a product line context. The existing EMF, GMF and EMFText editors are extended by the tooling and display which model objects a selected feature configuration covers. They also want to implement support for Xtext.

Konsistente Software-Dokumentation by Andreas Bartho

The DEFT (Development Environment For Tutorials) project is really interesting because it allows you to keep your documentation current as you change your code. Code snippets are copied into your documentation with code formatting. The Tuba project does the same but for models which is also very neat. They want to combine both projects and want to support screen shots from RCP applications running in a JUnit context.

I am looking forward to the next Eclipse DemoCamp in Berlin where I will talk about emf.observables too. See you there!

Eclipse Stammtisch

I can’t ressist to attend on a new Eclipse Stammtisch on Modelling which will take place in Berlin on the 19th August as mentioned by Ed. If you are interested in Modelling or not – it will be a happening and you are welcome to mark your attendance (preferably “Yes”) and get a eclipse-foundation driven beer (or other drinks as you like) for free as promised by Ralph. See you there…

Eclipse DemoCamp Galileo Review

The DemoCamp which has been organized by b+m (my self) in cooperation with FOKUS (Tom Ritter) was a full success. We had seven talks – each about 20 minutes:

  1. Ralph Mueller gave us some infos about the Eclpse Foundation and the Eclipse eco system in Europe (PDF)
  2. Alex Koderman talked about the verinice project, an open source solution for Information Security Management (PDF)
    Break
  3. Tom Ritter spoke about Model Sharing in a Distributed Model-Driven Development (PDF)
  4. Martin Flügge showed us Dawn, a web-based collaborative extension for GMF editors (PDF)
  5. Eike Stepper gave us a talk about the Net4j signalling platform (PDF)
    Break
  6. My talk was about how to COPE with long term metamodel evolution (PDF) and
  7. Max Bureck spoke about a graphical QVT/R-Editor (PDF)

There was some kind of running gag due to the unawareness of the speakers to actually show a demo because of miscellaneous technical reasons.

In the beginning and during the breaks we had the opportunity to have nice chat and the advantage of a delicious buffet. Thanks to the sponsors.

After the camp some of us moved into a timeless restaurant for celebrating an Eclipse Stammtisch which was also very nice.

All together it was a long but very nice day.

Please note: There will be a second Eclipse Stammtisch on the 16th June where you will have the possibility to meet some members of the Eclipse Board of Directors. Please have a look at Eikes post announcing the Stammtisch. If you want to participate please enter your name into the Doodle poll.

Eclipse DemoCamp Galileo

Like in the previos year I am one of the two organizers of the Eclipse DemoCamp Galileo 2009 in Berlin. It will take place on the 9th June here. I will give a talk about COPE and how to use it to evolute a meta model and migrate the corresponding instance models (as I have done it for GenGMF). If you don’t have the time to visit the Berlin DemoCamp you will get a second chance to hear my voice in Leipzig on the 23rd June. Sorry, I can’t be in Leipzig on this day because I will be in Kiel… But if you would like to chat with me and some members of the Eclipse Board of Directors at an Eclipse Stammtisch have a look at Eikes Post. See you there!

Copying EMF objects accross namespaces

I am currently preparing a new release for my GenGMF project. Because the new meta model contains important but incompatible changes I have migrated the GenGMF tooling to a new name space and created a migration script for converting the specific editor models. The new meta model is much smaller than the old one which results in smaller models — I’ve eliminated the need for the mapping elements in the templates. To make the migration as easy as possible I’ve created some helper functions to move corresponding attributes and references. Only the “real” changes in the meta model are migrated using a Xtend script.

To demonstrate the facilities of the CrossNamespaceCopier I’ve created a small meta model…

Demo meta model

As you see the Class2 from the “http://source.namespace” has been eliminated in the “http://target.namespace” and both attributes have been moved – attribute2 to Class1 and attribute3 to Class3. In order to migrate a model instance one has to call the CrossNamespaceCopier which copies the objects while migrating the name spaces according to rules previously set. OtherClass objects from the “http://other.namespace” will be copied as they are. All references and attributes which could not be automatically migrated need to copied in a small script manually.

extension CrossNamespaceCopier;

namespace::target::Class1 migrate(namespace::source::Class1 sc1)
:   let tc1 =
    // initialization for the copier, but the
    // let statement needs to be in the beginning
    (   crossNsInitStaticInstance()
    ->  crossNsSetupNamespaceMapping(
            "http://source.namespace",
            "http://target.namespace")
    // the content for the tc1 variable
    ->  (   (namespace::target::Class1)
            crossNsCopy(sc1)))
    // skipping Class2 in source
:   tc1.setClass3Reference(
            (namespace::target::Class3)
            sc1.class2Reference.class3Reference
            .crossNsCopy())
    // pull up attribute2
->  tc1.setAttribute2(
            sc1.class2Reference.attribute2)
    // pull down attribute3
->  tc1.class3Reference.setAttribute3(
            sc1.class2Reference.attribute3)
    // uninitializing
->  crossNsReleaseStaticInstance()
->  tc1
;

You will find the CrossNamespaceCopier as well as the demo files contained in a zip file.

GMF toolkits

GMF, the Graphical Modeling Framework supports the creation of graphical editors. For beginners it is very hard to learn. The included wizard has a lot of disadvantages, but it is o.k. for a start. Furthermore the GMF models are very complex and hard to handle. There are different solutions to shorten the time needed for creating a graphical editor:

EuGENia
… supports the development of GMF based editors using annotations in your metamodel (*.ecore) – preferably generated using Emfatic. Dimitrios Kolovos has written a nice tutorial and created a screencast.
ATLflow
Like in EuGENia – annotations in the metamodel are used to create a graphical editor. It is part of a complete tool chain for model transformations based on ATL. It is used for bootstrapping parts of ATLflow itself.
GenGMF
… uses a completely different approach. The GMF models are created from template-like tree structures. A template consist of GMF elements – just ready for duplicating for each metamodel element it is associated with. It is recommended to have some experience with the GMF models, before starting with GenGMF. I developed it to support the creation of editors with a lot of metamodel elements.

Both annotation based solutions are not able to cover all the features possible with GMF, because the GMF models are created using the information stored in the metamodel. The template based approach GenGMF offers a lot more flexibility at the cost of a more complex model.

xtext with external references

I have just seen, that by now xText supports external references out of the box. This is a long awaited and really useful feature. Thanks a lot.

MDSD in 5 minutes

Step 1 (real live): You have the wish to get a cup of tea of “Pai Mu Tan”.

Step 2 (model): You are creating a wish-model containing an element of type “Cup” which has an attribute named “content” of type string and the value “Pai Mu Tan”. The model is the digital representation of a real-life-wish.

Step 3 (metamodel): You want to create other wishes too and you are designing a metamodel. The wish-metamodel contains a the root element “Wishes” containing a many-containment reference “wishes” to the type “Wish”. The abstract type “Wish” is derived by the types “Cup”, “Book”, “FreshAir” and “OtherWish”. “Cup” has an attribute “content” while “Book” has an attribute “title” of type String. “FreshAir” does not need an attribute and “OtherWish” has no meaningful attributes. Using the wish-metamodel you could express a lot of wishes.

Step 4 (editor): You want others to express their wishes. Let’s create an editor, they could use to do that. Using Eclipse and your metamodel it is really simple to create an EMF based tree editor. You are happy.

Step 5 (great models): Your models grow (you have extended your metamodel with other wish-types) and you want to group your wishes by occasion (Birthday, Christmas, other) if they are of long-term, short-term or just-now. You are doing that by extending the metamodel with other types (AbstractOccasion, Birthday, Christmas, AbstractWhen, LongTerm, ShortTerm, JustNow) and some connection types connecting your wish with when they should be active. it is hard to keep the overview about all your wishes – you want a better editor (which is a wish-type of it’s own).

Step 6 (graphical editor): You have chosen GMF as your editor framework. It is great – you could express all you want – your wishes, the occasions and whether your wishes are more short- or long-term in a model driven way and without writing one single line of java-code. Now you have the overview about all the wishes.

Step 7 (more wish-types): Every time you create a new wish-type in your metamodel you have to copy-and-paste-and-change some parts of the GMF-models to express the editor object for your new type. You want more abstraction like a templating engine for GMF-models.

I am currently developing such a model-templating engine called GenGMF. You could create a template-tree for the GMF-Graph and for the GMF-Map models having place-holders for the type-names you want to instantiate (e.g. “__TYPENAME__NodeFigure”) and some modelled instructions how to instantiate the tree in the GMF-models. It is even possible to change the instantiated trees on-the-fly. For example – I reengineered the sample editor from one of my last posts. The rectangle and the elliptic nodes are instantiated from the same template (which only knows rectangles). A XTend-based creation Filter changes the Rectangle to Ellipse – the rest of the tree is the same. Post processing (also via XTend) is also available to insert more stuff into the generated models.

Diving

I am currently diving into the secrets of GMF - and it's cool