Hi,
Ed and I are organizing the Modeling Symposium for EclipseCon North America (see here). Thank you for all the interesting submissions so far. To notify people early enough about the acceptance of their submission, we need to set a final deadline to February 8th. Please make sure to send me your submission before this deadline.
Looking forward to your submissions!
Jonas
Ed and I are organizing the Modeling Symposium for EclipseCon North America. It is scheduled for the first day of the conference, i.e., Monday, March 23rd at 1pm. The symposium aims to provide a forum for community members to present a brief overview of their work. We offer 10 minute lightning slots (including questions) to facilitate a broad range of speakers. The primary goal is to introduce interesting, new technological features. This targets mainly projects which are otherwise not represented at the conference. Additionally we offer a number of 1 minute “teaser slots” (no slides, no questions) for advertising other conference sessions.
If you are interested in giving a talk, please send a short description (a few sentences) to jhelming@eclipsesource.com. Depending on the number, we might have to select among the submissions. Please adhere to the following guidelines:
Looking forward to your submissions!
Jonas
This has been blogged about before by me and other guys, but as I still constantly experience this problem, a little repetition won’t hurt 
In many projects you see the result of System.out.println() statements on the console: statements such as “here I am” or “this should not happen”. These are often left-overs from debugging sessions and flood the log. Although, I personally think there are almost no use cases where you would use sysouts over breakpoints or conditional breakpoints, you cannot just forbid the use of them. In fact, there are good use cases I know for sysouts, e.g. debugging drag and drop where you do not want the debugger to suspend on a drag over. However, polluting the code with sysouts should be a no go. A better solution is to put the sysout statement into the break point’s condition like this:
In this way you do not pollute the code and, if you want to persist your sysouts, you can export the breakpoints.
We had a great Democamp and birthday party in Munich. Thanks go to all the speakers, volunteers and attendees!
The evening started with a keynote by Ed Merks. He summarized 10 very interesting years. Some of the events he mentioned were already known, some were surprising, e.g. when Ian Bull started to use EMF in 2003
The second speaker, Kai Toedter showed a real working demo of how to use Java web start to start an Eclipse RCP application. To make it even more interesting, he started his demo application using the internet connection from Sven`s phone. You can download his slides here.
Manuel Bork presented the new Mylyn-GMF integration that allows the use of task focus on diagrams. This feature is also integrated into UML Lab.
Frank Appel showed how to create dynamic Web-Applications with RAP and OSGi. It was quite impressive to see him turning parts of a web application on and off using an OSGi console. At the end, he also demonstrated the same application running on an iPhone using the native RAP client for iOS. You can find his slides here.
Maximilian Koegel and me did a short “KINECT with Eclipse” demonstration. If you’re not familiar with this demo, you can see more here.
Then we had a short break with beer and of course a birthday cake. It must have been good - I wasn’t even able to take a picture of the whole cake:-)
After the break, Andre presented the tool, Ceno. It can help to avoid conflicts in projects by showing who is working on which class in real-time. You can download his slides here.
Tom Schindl presented his project “e(fx)clipse” Eclipse Tooling and Runtime for JavaFX. The styling options and the DSL to declarativly create the UI were especially great. You can find his slides here.
Ekke presented his first experiences with Eclipse PlugIns for BBX Native SDK. This enables the development of applications for the next generation platform for Blackberry smartphones and tablets.
Maximilian presented what’s new in EMFStore. He showed an example of a tool based on EMFStore and also showed an integration of EMFStore with the e4 workbench model. With this integration, the e4 model can be versioned between developers using EMFStore. The changes can even be pushed to a deployed application. As an example, one can switch off a certain feature for maintenance. See here for more information.
Sven Efftinge gave an introduction to Xtend and why it can and should be used daily. Xtend is a very thin layer above Java offering some innovations such as closures, which are not available in Java. Later, Sven also showed how to develop a very simple DSL with Xtext in 10 minutes. You can find more information here.
Ed presented Xcore, a textual syntax for Ecore created with Xtext. Xcore allows the definition of EMF models with the same ease as writing Java code. It also makes it very easy to embed Operations written in Java.
Thomas Schütz presented “Developing Embedded Systems with eTrice.” To me, the most interesting feature was that events on the target can be logged to create Message Sequence Charts(MSC) of the running application. You can find his slides here.
Thanks to all the speakers, the attendees and the volunteers for making this a great event and see you at the next democamp!
Munich Democamps have always been fun! Need proof? See here!
We are looking forward to celebrating Eclipse’s 10th birthday at the Democamp in Munich on November 15th. This time the Democamp will be located at the EclipseSource office (Agnes-Pockels-Bogen 1). The seats are limited to 100 so if you plan to attend, please register soon. If you want to present, please send me a description of the demo (jhelming@eclipsesource.com). Depending on the number of submissions, we might have to adapt the slots a bit. Please also register as a presenter.
In addition, I am happy to announce that we will have a keynote at the Democamp. To make it a little more exciting, I will not post the name yet. Instead, there will be a small challenge. This is how it works: I will answer one Yes/No question per day. You can follow this with the twitter tag #demoriddle. You can suggest new questions via twitter and I will pick and answer one every day. The first person with the right answer will get a Bavarian present at the Democamp. (Please do not participate if you happen to know already who it will be.) Each person is allowed only one guess, so take your time and choose wisely.
In Munich, we are currently looking forward to two events: The last week-end at the Oktober Fest and even more important the Eclipse Stammtisch on upcoming Tuesday 6pm. We have already over 20 registrations including the legendary Mr. Eclipse Foundation Europe, Ralph Müller.
Furthermore, we will have interesting demonstrations. Arno will present the Loggifier, a tool that inserts code into Java class files for logging, and the CVSTools. Maximilian and Edgar will present new features of the EMFStore including GIT Integration. Ekke will demonstrate the development of LocationBased Services with the BlackBerry Eclipse PlugIn. And finally I will try to get the KINECT running at Sappralot
However, if you are not in the mood to look at any demonstrations, just drop by for a chat and a drink.
If you have not registered for the Stammtisch yet, please do so: http://eclipsestammtisch.eventbrite.com/
I will update our reservation on Friday.
Looking forward to meet you there!
Sorry for the eye catcher, I meant “München”
To shorten the time until EclipseCon Europe, we cordially invite you to the Eclipse Stammtisch München on October 4th. The Stammtisch is always a good opportunity to meet the community in your region and talk about Eclipse and of course, non-Eclipse topics.
If you would like to attend, please register for this event, as we will make a reservation based on the number of registered people. Currently, we plan to meet at Sappralott. But, as the location might change, please provide a valid mail address so that we can notify you about the details.
Based on your feedback from the last Stammtisch, we would like to give people a forum to present interesting things. However, since this is not a democamp, there will be no stage or agenda. People who want to show something can bring their laptop. We will distribute the presenters around the tables and people can walk around to see what they are showing. That means you can present something, you can watch something, but if you are not in the mood, you can just sit there, have a conversation and drink beer
If you want to present, please register as a presenter and send me a short description of what you are planning: jhelming@eclipsesource.com
Some of you may have seen Yoxos 5 at EclipseCon 2011. For those who aren’t familiar with it, Yoxos 5 is a tool that enables the creation of a profile that describes your Eclipse installation. Another developer can start the same Eclipse installation by clicking on a .yoxos file. Yoxos will download and install all necessary plugins, set the preferences, connect to the source code repository and even show you the tasks from your bug tracker. These items are continuously updated with changes. For example, if you add a new plugin to your daily development environment, all team members will automatically get an update. Ian’s talk at EclipseCon 2011 showed how this can be used to get developers working on an open-source project quickly, e.g. for a “bugday”. The full team service is freely available for open-source projects.
In the latest release, we’ve added another much-requested feature: the provisioning of target platform definitions. The basic idea is that you can provision target platform definitions with Yoxos and set one target platform to activate by default. The target platform itself can be on an update site, in your workspace or anywhere else. Using a local folder or an Eclipse installation may not make too much sense, unless these sources can be downloaded by other users. You can configure the target definition in the normal way, using the PDE UI. Once you have added it to your profile, it can be used by all developers on the team.
You can activate Target Provisioning in the launcher from the tab “Workspace Provisioning”
Then, you’ll see a new tab in the application:
Once you have set your target platform definitions, you can import them from your IDE into a profile (via the magnet button).
By checking one of the target definitions in the table, you’ve set the default that will be activated on start-up of the installation.
Note that you should remove the target platform definition file from plugins that are provisioned by the team provider. Otherwise you will get the the same target platform twice, once provisioned by the SCM, once provisioned by Yoxos. The Yoxos provisioned target definition always has a postfix “provisioned by Yoxos” to distinguish them. In general, moving the target definition out of your workspace might be good practice, as changes to the target platform can then be managed by the same person who configures the Yoxos profile.
You can give Yoxos 5 a test drive – visit http://eclipsesource.com/yoxos5. Let us know what you think about Yoxos and target provisioning.
The results of the evaluations for the EclipseCon 2011 talks and tutorials is out. I thought it would be interesting to know which talks and tutorials were rated best. So I took the data from the PDF and did a little calculation.
Disclaimer / Government Health Warning: Any of these calculations may or may not be statistically significant. They may include huge biases such as time of day, my personal decisions on how to do it and there might be errors in the data. So be forewarned, this is not an official ranking.
What I did was to count the +1′s, ignore the 0′s and substract the -1′s. The result was divided by the total number of votes resulting in an average value between -1 and 1. A very important decision is the cut point for being excluded from the sample, as there were a lot of sessions with very few votes. Some of them have an average of 1, but with very few votes this is quite arbitrary. So I decided to ignore sessions with less then 25 votes. That does not mean they were not great, I just don’t think it makes sense to include them from a statistical point of view. Further, if the average only differed 1%, I rated sessions equally to the next higher one.
To make a long story short, here are the results:
Keynotes
Top Five Talks
After the first 5 places there is a huge group of almost equally great talks between 0.9 and 0.8. So this is really only the tip of the iceberg.
Top Five Tutorials
I would also like to mention the following sessions, which had very close to 25 attendees and had a very high ranking:
Congratulations to the speakers who gave these great talks. I hope no one feels offended at not being listed and I’d be glad to hear from you if you think there is something wrong or unfair with regards to the method. And, don’t forget to hold to the disclaimer
Here is the raw data:
This is the second part of the tutorial presented at EclipseCon. We’ll be building on the model created in the first part of the tutorial, which you can find here. We’ll give you an overview of available technologies through links to several Ignite talks that introduced various frameworks building on EMF. If you would like to have your framework included, please let me know.
In this part of the tutorial, we will explore EMF’s API, including the generated code, as well as EMF’s utility classes. Let’s have a look at the generated code first. In the model plugin from our tutorial org.eclipse.example.bowling you will find interfaces and implementations for all entities of the model. A look at the outline of an entity’s interface reveals that it contains getters and setters for the attributes we have defined in the model, as well as access to the references. All entities of the generated EMF model are sub-classes of EObject. EObject contains basic functionality – for example, a change notification mechanism. 
The model plugin contains factories to create model element entities. Please note that the constructor of EObjects is usually not public. Please also note, that factories are used by many frameworks for their functionality, e.g. deserialization. Changing these methods successfully requires some careful planning. Let’s use the factories to programmatically create some entities and use their API to modify them. We will use the pre-generated test plugin to run this example code. In this very simple example, we use the BowlingFactory to create a Matchup and a Game, adding a reference to the Matchup and checking the bi-directional update on the Game. 
The super class EObjects offers many methods to access an entity in a more generic way. As an example, we will test the containment between Matchup and Game by accessing the EContainer instead of the getMatchup() method. 
EObjects offer reflective access to their attributes using the methods eSet() and eGet(). This can be useful in modifying an entity in a generic way. 
Information about the available EAttributes and EReferences, as well as all additional concepts we have modeled before, can be accessed either through the EClass or through the EPackage. The following test checks whether the only EReference of League is a multiplicity greater than one. 
EMF also supports the validation of model instances. As an example, we can validate the constraint of the model that a matchup must always consist of two games: 
Finally EMF provides a lot of utility classes. A very important one is EcoreUtil. It is worthwhile browsing through the available methods of EcoreUtil. As an example, we will use the copy method to create a copy of an EObject. 
Before we continue with the tutorial, please import the sample solution. Please switch to an empty workspace (File => Switch Workspace), select “Import” => ”General” => ”Existing Projects into Workspace”. Please select “exampleSolution.zip” and import all projects. 
For the next steps of the tutorial it is important to understand the concept of AdapterFactories. We will give a quick introduction and you can see this documentation for more information. The basic idea of AdapterFactories is to provide you with an interface IX you need for an arbitrary purpose, e.g. a LabelProvider needed in the UI. EMF generates a lot of these classes for you. To retrieve the right class you can use an AdapterFactoryX, which implements the interface you need. The AdapterFactoryX will retrieve the generated classes using an AdapterFactory. 
In the previous sections we have shown how to generate a structured data model with EMF. In a typical application, these data models have to be stored and maybe even versioned or distributed. There are a couple of frameworks that support different use cases. By default EMF provides the ability to serialize EObjects to XMI files. In the following example, we will load EObjects from a file and save them afterwards. EMF also offers commands to make modifications on the model. Commands can be easily undone. In the example we will load a XMI file containing a Tournament. The user can add new Matchups to that Tournament and undo these changes. At the end, the user can save the changes back to the file. For the tutorial, we have prepared an example dialog in the plugin org.eclipse.example.bowling.tutorial, which should be imported from the example solution. You can open this dialog by right-clicking a file and selecting “Tutorial”=>”Open Example Dialog”. After implementing the following two parts of the tutorial, it will look like this: 
Everything that is not relevant for this tutorial is implemented in an abstract base class called AbstractExampleDialog. In the subclass ExampleDialog, there are empty method stubs to be implemented in this tutorial. The dialog can be shown in the runtime Eclipse instance by right-clicking on a file and selecting “Open Tournament Example view”. (Please note that for the tutorial we have focused on simplicity over perfect design.)
Please open the class ExampleDialog. We will implement the loadContent method, which is triggered by opening the example view. The purpose of this method is to get a Tournament from the file which is then displayed in the example view. To keep it simple, we assume that the file contains a Tournament and this Tournament is the first element in the file. You can easily create a file like this with the generated example editor. First we create an editing domain. An editing domain manages a set of interrelated models and the commands that are run to modify them. For example, it contains the stack of all former commands. An editing domain can create a resource, which is a container for storing EObjects. Resources can be saved and loaded and contents can be added to them. In the example we get the first EObject in the resource, assume it is a tournament and make it a member of our superclass. 
After loading the content, we will implement a save. This will be triggered by pressing OK in the dialog and will serialize the model and apply all changes to the file. 
Now we want to implement the addition of a matchup to a tournament. We will use a command for this. First we create a matchup using the appropriate factory. The factory, by convention has the name of the base package of the model. Then we create a command which adds the newly created matchup to the existing tournament that we retrieve from our superclass. Finally, we run the command on the command stack of the editing domain. 
At this point, the changes will not be reflected in the UI of the dialog, but we will implement the necessary code in the next step of the tutorial. To implement undo, we just need to call undo on the command stack of the editing domain, this will undo the last command. 
Now, start the bowling application and create a XMI file with the example editor. It should contain a Tournament and several Matchups and Games. Please right-click the file and select “Tutorial” => ”Open Example Tournament View”. In this view you can add new Tournaments, undo this operation and save by clicking on “OK”. You can validate the result by opening the file in the Ecore editor. Please note again, that the UI of the View will not be updated yet, but we will initialize the UI also in the next step of the tutorial.
Ignite Talks on Persistency Frameworks: EMFStore, CDO (coming soon)
In this step we will fill the example view with two basic UI elements. First, we will bind the Label on top showing the number of Matchups in the opened Tournament to the model. We will use the notification mechanism to update the Label whenever the number of Matchups changes. Second we will fill the TreeViewer with a list of the Matchups also displaying their Games as children. For updating the Label we will register a listener on the Tournament EObject, which is opened in the view. This listener will always be notified by the EMF runtime if there is a change in the Tournament EObject. 
In the second step we implement the listener itself. In the notify method, we check first whether the change was on the EReference to Matchups and therefore influences the number of Matchups. If this is the case, we update the Label (implemented in the AbstractExampleView). 
Please note that this is how you manually implement listeners. For creating UIs with bi-directional updates between UI elements and data-models, we recommend using data-binding that’s also available for EMF. In Eclipse databinding, you can bind a certain UI element to a certain EAttribute or EReference and it will take care of bi-directional updates.
Finally, we will initialize the TreeViewer to display the Matchups of the current Tournament and their Games as children. A TreeViewer needs three things to be initialized. The ContentProvider is responsible for the structure of the Tree by providing the method getChildren(). The LabelProvider is called to get an Icon and the displayed text for one node. The input of a TreeViewer is the invisible root element of the Tree. The elements displayed in the root of the tree are the children of that element. In our case, the input is the Tournament.
ContentProvider and especially LabelProvider usually depend on a certain EClass. EMF generates providers for several purposes including Content- and LabelProvider. We will use the AdapterFactory concept explained previously to retrieve the right provider for every element. Finally we set the Input to the Tournament which is currently open.
Now you’ll need to re-start the bowling example application to test the implemented UI features. To modify the appearance of a Label you can simply modify the ItemProvider of the respective class. Let’s modify the LabelProvider for Matchup. To modify the appearance of EObjects in the TreeViewer you can adapt the generated ItemProvider GameItemProvider. In the example, we will show the number of Games contained in a Matchup Game. Mark the method as “generated NOT” to prevent it from being overridden during the next generation.
In the running application, the new LabelProvider is displayed in the Example view as well as in the Ecore Editor:
As a last step, you should remove all listeners when closing the view. Please note that LabelProvider and ContentProvider are registered listeners on the model, so you should delete them.
There are several frameworks for displaying data from an EMF model instance. In this tutorial, the following were introduced in Ignite talks:
In this last part of the tutorial we want to give you a short overview of additional EMF-based technologies for different purposes:
I hope you found the tutorial helpful. In case you have any feedback or you are missing a certain framework or part, please feel free to contact me or leave a comment.
(18) (4) (120) (57) (8) (54) (121) (35) (9) (11) (3) (17) (11) (12) (8) (14) (3) (20) (5)