Sirius Gallery: 20 cool and noteworthy examples

by Fred Madiot ( at October 24, 2014 02:11 PM

We have added a new Gallery page today on the Sirius web site:

This page presents 20 cool and noteworthy modelers already created with Sirius in various domains: Systems Engineering, Software Development, Business Configuration, etc.

Configuration of plastic products manufacturing

Capella Systems Engineering workbench

Modeling of Android mobile applications

Configuration of home automation systems

The list is not complete ... since we don't know or can't publish all what is done with Sirius, but it will be completed soon with several other examples we have in store.

So, if you also did something that could be published on this page, you can submit a short description and some nice screenshots here :

by Fred Madiot ( at October 24, 2014 02:11 PM

@Flight Conference 2014

by Chris Aniszczyk at October 24, 2014 12:08 PM

I had a great time at @Flight, our first mobile developer conference at Twitter where we announced Fabric. As part of the conference, I helped organized a small run in the morning to start things off, it was nice to see about 20 people show up to run a 5K (ok, it was really more like an 8K with hills).

At the conference, I had the opportunity to talk briefly in the Lightning Theater about some of the open source technology behind tweets, in the context of what happens behind the scenes of a typical API call.

I hope the audience left with some new knowledge and appreciation of what helps power those tweets they see everyday. I posted the slides on Slideshare if anyone is interested. I look forward to us doing this next year, it’s about time that we do more developer focused events at Twitter.

by Chris Aniszczyk at October 24, 2014 12:08 PM

Opportunity to Learn About OSGi in Romania - Nov 21

by Mike Francis ( at October 24, 2014 09:57 AM

The Bucharest JUG with Luminis Technologies and Thales Romania are hosting a free one day event in Bucharest on November 21 (Registration is mandatory, see below). The event is titled "OSGi in One Day" and it will introduce you to OSGi technology and some of the tooling available for developing with OSGi. The expected audience is likely to include a broad range of OSGi experience, from

by Mike Francis ( at October 24, 2014 09:57 AM

Setting up a local p2 mirror for Tycho

by Torkild U. Resheim at October 23, 2014 11:56 PM

Now that EclipseCon Europe is nearing, I decided to do some preparations. As most years some time will be spent on hacking, and this year is no exception especially with regards to the Science Working Group coding session at the Unconference.

These days many Eclipse based projects use Maven and Tycho for building. All my hobby projects are also using this technology. It’s quite nice, but a common problem is having to download artifacts when the network is bad or unavailable. From experience this happens a lot at EclipseCon Europe so I’m planning to avoid it. You can resolve this altogether by setting up a local artifact manager such as Nexus. Nexus supports both Maven and p2 repositories so if you have one of those you won’t need these instructions. I’ve set up Archiva on my NAS and rely on the local cache when the network is unavailable. However this only supports Maven artifacts and when building Eclipse based applications one also need the various dependencies. I’ve resolved this by creating local mirrors of the p2 repositories I often use, and instructed Maven to utilize these.

First you need a running HTTP daemon such as Apache on your system. I’m on OS X so I’m all set – just had to enable user directories after updating to Yosemite. Next you have to create the mirrors. This is done by calling the Eclipse mirror application. Once for the metadata and again for the artifacts. Replace path to eclipse and destination as appropriate.

/Applications/Eclipse\ 4.4/eclipse -nosplash -verbose -application org.eclipse.equinox.p2.metadata.repository.mirrorApplication -source -destination file:////Users/torkild/Sites/mirrors/eclipse-luna

/Applications/Eclipse\ 4.4/eclipse -nosplash -verbose -application org.eclipse.equinox.p2.artifact.repository.mirrorApplication -source -destination file:////Users/torkild/Sites/mirrors/eclipse-luna

Be prepared to wait quite a while for the last one to finish. If you want to speed it up you should try to find a faster mirror of the p2 repository. I repeated the process for SWTBot. Next I altered ~/.m2/settings.xml so it looks like this:

        <!-- Maven repositories -->
        <!-- Eclipse p2 repositories -->
            <name>Local Mirror of Eclipse Luna p2 repository.</name>
            <name>Local Mirror of Eclipse SWTBot p2 repository.</name>

Once again, adjust the URL to suit your needs. Next it’s just a matter of making sure that the repositories referenced in the *.pom files match the mirrors. Just make sure that the identifiers are the same as the mirrorOf attribute in the configuration file or the mirrors will not be used.


That’s it. Happy coding!

by Torkild U. Resheim at October 23, 2014 11:56 PM

Multi-Viewpoints on EclipseCon Program

by Fred Madiot ( at October 23, 2014 10:14 PM

To demonstrate Sirius on short talks, I'm used to create a modeler from scratch, in ten minutes, on a topic that everybody in the audience knows: the conference they are attending.

For Eclipse Con Europe, I decided to extend this demo in order to illustrate one of Sirius' main feature : the possibility to present the same model according to different concerns.

Using Ecore Tools (based on Sirius), I created a small modeling workbench based on this DSL.

Based on this DSL, my new Conference modeling workbench provides four different representations : 3 diagrams and a cross-table.

Track Diagram

This diagram allows me to create tracks and talks, thank to the tools in the palette. For each track, I can define its speakers, the day of the talk, its location and at what hour it will be given.

Here I have created the talks by Obeo and Thales.

The container presenting each talk has a conditional style : its color depends on its duration (green if the duration exceeds 35 mn).

When populating this diagram, Sirius creates EMF objects based on the conference DSL. They can also be seen in the Model Explorer.

I have also defined two optional layers on this diagram: "Sirius" and "Speakers". Each layer allows me to dynamically change the appearance of displayed objects.

When activated, the "Sirius" layer highlights the talks containing Sirius in their title: the Sirius icon is displayed as a to-right decorator on the concerned talks, and the other talks are colored in gray.

When de-activated, the "Speaker" layer hides the speakers.

Location Diagram

This other diagram automatically presents the same talks grouped according to their location.

Days Diagram

This last diagram presents the talks grouped according to the days.

Program Table

Finally, I have also defined this table which shows the program in a classical tabular way:

Behind the scenes

These representations are simply defined without any line of code, thanks to Sirius declarative mode.

The elements of this tree define which instances of the DSL are displayed in each representation and with which graphical style.

For example, the element TalkContainer allows to display all the instances of Talk which can be retrieve through the talks reference of the current track.

Its style is defined by the Gradient white to light green element which sets the shape, the color and the label of the talk.

by Fred Madiot ( at October 23, 2014 10:14 PM

The Importance of Testing Interoperability: MQTT Test Day

by Ian Skerrett at October 23, 2014 06:26 PM

A lot of work is being done developing standards for the Internet of Things (IoT), standards like MQTT, CoAP, etc. A key benefit of these standards is that different implementations should be able to interoperate. However, as most people appreciate, the implementation of a specific standard can be open for interpretation so testing for interoperability is the only way end-users can achieve this benefit.

This is why I am pleased that we will be once again hosting an MQTT Interoperability Test Day. We hosted the first test day last year at EclipseCon. This year the MQTT community has significantly grown and the new MQTT 3.1.1 specification is just about to be ratified so there will be lots to test. Ian Craggs has already started to work on the conformance tests, so it should be an interesting test day.

The Test Day will be March 9, 2015 at the Hyatt Regency San Francisco Airport, same location as EclipseCon 2015. Registration is now open so if you want to participate sign-up now. This event is only for people who have MQTT based products, client, servers or cloud services. We want a good mixture of hardware vendors, IoT platform/middleware vendors,cloud services and of course open source implementations.  You do not need to be using Eclipse Paho, Mosquitto or Moquette to participate.  The cost to participate is $300/person. However, if you are attending EclipseCon on the 4-day pass the fee is waived. If you are a member of the Eclipse IoT Working Group the fee is reduced to $150/person.

One final word, we have limited space for this event so if you want to attend please sign-up now.The success of this event will be a great example of how easy it is for MQTT implementations to inter-operate.  We will have the proof!

by Ian Skerrett at October 23, 2014 06:26 PM

Busy JavaFX Autumn a head – EclipseCon Europe & Democamps & e(fx)clipse 1.1.0

by Tom Schindl at October 23, 2014 12:30 PM

In the Eclipse space autumn is a very busy time of the year because of

but not for me this year. No EclipseCon Europe 2014 (and most likely no EclipseCon NA 2015), no Democamps Autumn 2014 – just family! Our 2nd daughter is due mid/end of November so no traveling for me in the weeks to come.

Anyways I’ve gone through the program of EclipseCon and it’s nice to see multiple talks dealing with JavaFX and e(fx)clipse so if you have a chance to be there make sure you don’t miss them:

I’m sure those guys are building cool stuff with the help or by using e(fx)clipse!

It’s not easy as an opensource project to know who is using it and what they are building, that’s why I enjoy conferences so much! Anyways if you are one of those – get in touch with us so that we can add your project to our reference page.

In case you are building commercial and business critical application think about commercial support or fund features you are missing. Currently there are 110 open tickets (most of them are feature requests) who request things like SceneBuilder integration, MinMax Support for e4+JavaFX applications, … . I think about funding their implementation and/or contribute them

We – the e(fx)clipse team – are busy fixing the last bugs/features for the 1.1.0 release which is happing in about 2 weeks and will bring some cool new APIs like the one I presented last week

by Tom Schindl at October 23, 2014 12:30 PM

EMF Forms 1.4.0 Feature #2: New View Model Elements

by Jonas Helming at October 23, 2014 12:20 PM

In this blog series, I describe the five most notable new features of EMF Forms 1.4.0. EMF Forms is a framework to efficiently develop form-based UIs based on a given data model. Please refer to this tutorial for an introduction to EMF Forms and to this post for an overview of the series.

As notable feature number two in EMF Forms 1.4.0, I pick the new view model elements introduced in EMF Forms 1.4.0: Stack Layout and View Proxy.

A stack layout allows you to define an area within the form-based UI that can show alternative content depending on the current state of the domain model. Therefore, a stack layout is bound to a certain domain value, e.g., an enumeration or a boolean value. In the following example, we bind the stack layout to the enumeration “Gender”.

As shown in the following screenshot, a stack layout contains an arbitrary number of stack items. Each of those stack items is bound to a concrete value of the attribute that the stack layout is bound to. In this example, the first item is bound to “Male”, the second item is bound to “Female”. Both stack item can contain arbitrary elements; in this simple example, they both contain only one control.

image05 EMF Forms 1.4.0 Feature #2: New View Model Elements

The EMF Forms renderer will create an area that shows only the stack item bound to the current value (as shown in the following screenshots). Of course, stack items can also contain more complex layouts instead of only one control.

image09 EMF Forms 1.4.0 Feature #2: New View Model Elements

image01 EMF Forms 1.4.0 Feature #2: New View Model Elements


Leave a Comment. Tagged with eclipse, emf, eclipse, emf

by Jonas Helming at October 23, 2014 12:20 PM

JBoss Tools and Developer Studio for Eclipse Luna

by maxandersen at October 23, 2014 12:00 PM

The day has finally come!

JBoss Tools 4.2 and Red Hat JBoss Developer Studio 8 for Eclipse Luna is now available.

JBoss Developer Studio 8 Splashscreen


JBoss Developer Studio comes with everything pre-bundled in its installer. Simply download it and install it like this:

java -jar jboss-devstudio-{version}-installer-{standalone|eap}.jar

JBoss Tools or JBoss Developer Studio Bring-Your-Own-Eclipse (BYOE) requires a bit more:

This release requires at least Eclipse 4.4 (Luna) but we recommend using the Eclipse Luna SR1 Java EE Bundle since then you get most of the dependencies preinstalled.

Once you have installed Eclipse, you can either find us on Eclipse Marketplace under "JBoss Tools (Luna)" or "JBoss Developer Studio (Luna)".

For JBoss Tools you can also use our update site directly if you are up for it.

What is new ?

There have been many feature additions and a lot of bugfixing polish going into this main release and these have been documented/described in details at What’s New.

The main headlines are:

Where is integration stack tooling ?

The integration stack covers the tooling for Fuse, Drools, jBPM, SwitchYard, JBoss ESB etc.

I’m happy to announce that we for now have made them available as "Early access" in JBoss Tools under JBoss Central Software/Update page.

In the near future it is planned to also show up in JBoss Developer Studio and eventually be available as fully supported.

Thank You!

This release would not have been possible without feedback and contributions from our community and the team(s) around Developer Studio. For that I’m truly grateful. Any contribution counts!

The following people have participated in this release with either code, ideas, feedback and testing:

Alexander Silgidjian, Alexey Pakseykin, Andrei Ivanov, Andy Goldstein, Antonio Goncalves, Asif Kilwani, Axel Wathne, Chris West, Chunyun Chen, Clovis Seragiotto, Cody Lerum, Cojan van Ballegooijen, Daniel Castro, Daniel Cunha, Daniel Dekany, Darren hartford, Darryl Miles, Eduardo de souza, Emily Brand, Ender Wiggin, Eric Barber, Filippo rossoni, Guillaume Jouvelot, Harald Wellmann, Henk de boer, Hermes Waldemarin, Hernán Chanfreau, Igor Jacy Lino Campista, Jeffrey Simpson, Jesper Skov, Jim Boettcher, Joe Guzzardo, Jorge Yagüe París, Josh B, Juergen Zimmermann, Karl Pietrzak, Labdoui labdoui, Luke Maurer, Marcel Neuwohner, Martin Lippert, Masao Kunii, Mikhail Kalkov, Nan wei, Nero M, Nicolas duminil, Oliver Pfau, Palmer Eldritch, Patrick Decat, Paul Richardson, Pei-Tang Huang, Radosław Józwik, Rainer Schön, Randall Smith, Rich DiCroce, Robert Baty, Robert Munteanu, Roman Ilin, Ron Ratovsky, Sebastien Deleuze, Stephen Neal, Suz Dorfield, Sébastien Pinel, Tagir Valeev, Thiago andrade, Thomas Maslen, Weiweijiang jiang, Wolfgang Knauf, Zerr Angelo, Alexander Kurtakov, Alexey Kazakov, Aliaksey Nis, Andre Dietisheim, Andrea Vibelli, Andrej Podhradsky, Arun Gupta, Aslak Knutsen, Barry LaFond, Boleslaw Dawidowicz, Brenton Leanhardt, Brian Fitzpatrick, Burr Sutter, Catherine Robson, Corey Daley, Daniel Azarov, David Chia, David Hladky, David Stephan, Denis Golovin, Denis Maliarevich, Duncan Doyle, Emil Cervenan, Emmanuel Bernard, Eric Rich, Fred Bricon, Gavin King, George Gastaldi, Gorkem Ercan, Ilya Buziuk, Isaac Rooskov, Jakub Niedermertl, James Cobb, Jane Murphey, Jaroslav Jankovič, Jeff Cantrill, Jim Tyrrell, Jiri Pallich, Jiri Peterka, Joshua Wilson, Juraci Paixão Kröhling, Juraj Húska, Karel Piwko, Koen Aers, Konstantin Marmalyukov, Krzysztof Daniel, Lars Heinemann, Len DiMaggio, Lincoln Baxter III, Lucia Jelinkova, Lukáš Fryč, Marek Novotny, Marek Schmidt, Marius Bogoevici, Marián Labuda, Martin Malina, Matthias Wessendorf, Max Rydahl Andersen, Maxim Areshkau, Michelle Murray, Mickael Istria, Mustafa Musaji, Nick Boldt, Paul Leacu, Pavol Srna, Pete Muir, Peter Palaga, Petr Stribny, Petr Suchý, Radim Hopp, Radoslav Rábara, Rafael Benevides, Rastislav Wagner, Rick Wagner, Rob Cernich, Rob Stryker, Robb Greathouse, Ron Šmeral, Sande Gilda, Sebastien Blanc, Snjezana Peco, Stefan Bunciak, Ståle Pedersen, Tadeas Kriz, Takayuki Konishi, Tomas Repel, Tomáš Sedmík, Travis Rogers, Van Halbert, Viacheslav Kabanovich, Victor Rubezhny, Vineet Reynolds, Vitali Yemialyanchyk, Vladimir Vasilev, Vlado Pakan, Vojtech Juranek, Xavier Coulon and Yahor Radtsevich.

Thank you!

If you like to be part of shaping the next update and major release please take a look at JBoss Tools Community Acceptance program! It will start up soon!

Hope you enjoy this release and remember…​

Have fun!

Max Rydahl Andersen+ @maxandersen

by maxandersen at October 23, 2014 12:00 PM

openHAB and Eclipse SmartHome News Flash

by Kai Kreuzer ( at October 21, 2014 07:04 PM

JavaOne and the Valley

Having spent a few days in the Silicon Valley, I feel it is time to share some experiences. The main reason for the my trip was the talk about Smart Homes for the Masses at JavaOne in San Francisco. This was well attended and we had brought a lot of toys with us to do a live demo of Eclipse SmartHome and QIVICON. There were other good talks about home gateways like the one from ProSyt about OSGi on gateways or from Eurotech about the Eclipse Kura project.

Thanks to the Eclipse Foundation, we also had two slots at the Eclipse booth in the exhibition hall to demonstrate Eclipse SmartHome and talk to people about it. Ian Skerrett even did an impromptu video recording of our demo setup.

Besides the very professionally organized conference by Oracle, it is always remarkable, how the "normal" life of IT geeks look like in the valley. I had the chance to present the Eclipse SmartHome based openHAB project at a local MeetUp in Oakland, hosted by ACE Monster Toys. Behind the rather uninviting entrance in an industrial area, there are great tools for the startups of tomorrow: huge CNC-machines, lots of sewing machines, powerful laser cutters etc. Entrepreneurs from all over the valley meet here to discuss latest technologies - such as openHAB in this case! On this occasion, I was given one of the new GE LED light bulbs, which are at less than $15 incredibly cheap in comparison to any other radio controlled light bulb on the market. And what is cool about it: It can be linked to the Philips Hue bridge and is now fully supported by the Eclipse SmartHome Hue binding!

At this MeetUp, I also had the pleasure to meet the creator of the STACK Box, a recently funded Kickstarter project. I really like the concepts this project is following as they are very much in-line with the idea of openHAB: Having an open and extensible software stack for a home gateway that serves as an integration point while protecting the users privacy. Did I actually already mention that I consider myself a home gateway junkie? Over the years I have collected an impressive compilation - and yet I am still missing popular gateways like the SmartThings hub, the Revolv hub, the Ninja Sphere or the Wink hub...

On October 3rd, I was invited to the TWiT studios in Petaluma for an interview - they have a special FLOSS channel and usually broadcast live - as I couldn't arrange the usual time, they made an exception for me and did a pre-recording. Their studio is amazing and they have a very professional crew - well, see the results of the show yourself!

EclipseCon Europe is coming!

Shortly after JavaOne, we had reached an important milestone for Eclipse SmartHome - the very initial release has been published - Eclipse SmartHome 0.7.0! A main feature of it over the initial code base from openHAB is the support of discovery mechanisms for bindings. The first developers are now actively trying this out and thus I am thrilled to already see support for Philips Hue, Yahoo Weather, Sonos, LIFX, Belkin Wemo, MAX!Cube, KNX, IRTrans and others being developed! I will soon do a blog post that shows this in action and should give you a good idea of how solutions that are built on Eclipse SmartHome can look like - so stay tuned!

If you are close to Ludwigsburg end of October, a good chance to see the first results is at my talk at EclipseCon Europe, which I am doing together with my colleague Jochen Hiller from Deutsche Telekom. You can also learn how to implement a binding yourself in 15 minutes or get your hands dirty at the IoT playground. If you are interested in the Eclipse IoT space in general and would like to meet the different people involved in it, the Unconference that is held on Monday, Oct 27th, is a good opportunity to do so - hoping to see you there!

by Kai Kreuzer ( at October 21, 2014 07:04 PM

Writing modules for EASE

by Christian Pontesegger ( at October 21, 2014 04:59 PM

While EASE is shipped with some basic functionality already implemented, the real benefit comes when we provide our own script modules. Today we will see how such modules are provided.

Source code for this tutorial is available on googlecode as a single zip archive, as a Team Project Set or you can checkout the SVN projects directly.

Step 1: Get EASE

To write modules you either need to install EASE into your running IDE, provide a target platform containing EASE, or import the source (core repository is sufficient) directly. At the end of this tutorial we will create help pages automatically. If you want to use that feature directly go for the source code option.

If not sure which option to choose simply install EASE from the update site.

Step 2: A simple module

Modules are simple classes, that are registered using the org.eclipse.ease.modules extension point. Start with creating a new Plug-in Project and create the extension point. Create a new module extension with id, name and a class. visible sets the default module visibility, but can be changed by the user in the preferences anytime.

If you start providing more and more modules it is a good idea to cluster them by using categories. This results in a cleaner UI integration using trees instead of a flat list of modules. Categories are defined under the same extension point and are straight forward, so I will not explain in detail.

The implementation starts with a POJO class:

package com.codeandme.ease.modules;

import org.eclipse.ease.modules.WrapToScript;

* Provides basic mathematics operations.
public class SimpleMathModule {

* Provide sum of 2 variables.
* @param a
* summand 1
* @param b
* summand 2
* @return sum
public double sum(double a, double b) {
return a + b;

* Subtract b from a.
public double sub(double a, double b) {
return a - b;

* Multiply 2 values.
public double mul(double a, double b) {
return a * b;

* Divide a by b.
public double div(double a, double b) {
return a / b;

public void doNothing() {
// not exposed as it lacks the @WrapToScript annotation

The only addition to a plain class is the @WrapToScript annotation, which indicates methods to be exposed to scripting. In case a class does not contain any @WrapToScript annotation, all public methods will get exposed.
As modules are created dynamically, make sure that the default constructor exists and is visible!

Step 3: A more complex module

Our 2nd module will be a bit more complex as we introduce a dependency to the SimpleMathModule. Define the module the same way we did before, but add a dependency to com.codeandme.ease.modules.module.simpleMath.

The implementation now derives from AbstractScriptModule which allows us to retrieve the used script engine and the basic environment module, which keeps track of loaded modules. If you cannot extend your class you may also implement IScriptModule and populate the initialize() method on your own.

package com.codeandme.ease.modules;

import org.eclipse.ease.modules.AbstractScriptModule;
import org.eclipse.ease.modules.WrapToScript;

* High sophisticated mathematics operations.
public class ComplexMathModule extends AbstractScriptModule {

/** PI constant. */
public static final double PI = 3.1415926;

* Get radus from circle area.
* @param area
* circle area
* @return radius
public double getRadius(double area) {
double rSquare = getEnvironment().getModule(SimpleMathModule.class).div(area, PI);
return Math.sqrt(rSquare);

By querying the environment we can retrieve other module instances dynamically and make use of their functionality.

We also expose a constant PI here. Just remember that only constant fields can be wrapped.

Optional: Create documentation

Users typically will request for module documentation. EASE allows to create eclipse help pages automatically by using a special JavaDoc doclet. The doclet is available in source and binary from the EASE core repository. To use it you need to download at least the bin folder content (along with the directory structure).

Now open menu Project / Generate JavaDoc...  , provide the location of the javadoc binary, select your modules project and point to the custom doclet location.

On the 2nd page add a parameter that points to the Plug-in Project root folder:

-root /your/workspace/location/com.codeandme.ease.modules

Hit Finish to build the documentation. The doclet will alter your plugin.xml, MANIFEST.MF and adds a new help folder to your project.

The help pages are located under Scripting Guide/Loadable modules reference/<Category>/<ModuleName>.

If you are interested in building documentation automatically using maven, please ask on the ease-dev mailing list for details.

by Christian Pontesegger ( at October 21, 2014 04:59 PM

Introducing an open plaform for your SCADA project

by Eclipse Foundation at October 21, 2014 03:38 PM

Eclipse SCADA provides a platform independent, comprehensive SCADA solution from the connection to the field devices, through the data enrichment in the SCADA server, and the visualization for the user interface. What is SCADA? The German wikipedia entry to the term SCADA puts it very succinct: SCADA (Supervisory Control and Data Acquisition) is defined as the monitoring and control of technical processes by means of a computer system. This can reach from the nimble control panel of a single machine like a CNC mill or a heater to the large scale control of the electrical grid, oil pipelines and chemical or pharmaceutical factories. A SCADA system therefore has to be able to access a large range of different devices connected in many different ways. The original decision to base the only somewhat vendor independent SCADA technology on Windows has left its legacy. Nearly all of the existing SCADA software, especially anything which has to do with HMIs is tightly bound to the Windows platform. For this reason we decided to make the openSCADA, the predecessor to Eclipse SCADA, platform independent by basing it on the Java platform, so it provides a platform independent solution from the server to the HMI (Human Machine Interface). All the major parts which Eclipse SCADA is made of, are usable independently and can be used on a pick and choose approach. A major part of Eclipse SCADA is the development of industry standard protocols. These protocol implementations are usable completely standalone without reliance on other Eclipse SCADA technology. Altogether it means, Eclipse SCADA might be the optimal solution for your SCADA project!

by Eclipse Foundation at October 21, 2014 03:38 PM

And the Choosen One is…….

by kingargyle at October 21, 2014 02:09 PM

Andmore with 38% of the vote.  Final voting results are below.

Screen Shot 2014-10-21 at 10.07.02 AM

This still needs to go through trademark approval.  If Andmore doesn’t pass then it will be Eldon, followed by Reuben, and then finally Origami.

by kingargyle at October 21, 2014 02:09 PM

Connecting developer tools across desktop and web with Project Flux

by Eclipse Foundation at October 21, 2014 01:39 PM

In recent years there has been a steady migration of tools to the web, starting with bug trackers and other collaboration tools. More recently core coding tools have started moving to the web as well, with the rise of web code editors such as Eclipse Orion. However when developers make this leap to web-based tools, they must leave behind their existing tools because there is no way to for tools on the web to connect back to tools on the desktop. This talk introduces Flux, a new project that aims at bridging this gap between existing desktop-class IDEs and future cloud-based developer tooling. It is built around a new cloud-based architecture for developer tooling that integrates with todays desktop IDEs (like Eclipse, IntelliJ, or even Sublime Text). This new architecture takes existing IDEs explicitly into account, but allows developers to move towards cloud- and browser-based tooling at the same time. It provides, for example, real Java reconciling and compilation information, content-assist and navigation support in the browser, in real-time, without forcing developers to discard their desktop IDEs. The talk explains the architecture behind this new project and shows several live demos using the latest prototypes and alpha versions implemented so far. Slides from this talk are available at

by Eclipse Foundation at October 21, 2014 01:39 PM

Code Matters - Eclipse Hacker's Git Guide

by Eclipse Foundation at October 21, 2014 01:38 PM

Links: Want to learn Git and use it within Eclipse? You already work with Git since a while and don't know how to use some of the more advanced concepts? You are already a proficient Git user but don't use code review ? Or you want to contribute some improvement to EGit or another Eclipse project using Gerrit (for example Eclipse Platform or Code Recommenders) and don't know how ? In this tutorial you will learn through hands-on exercises how to use EGit, Gerrit and a code review workflow to help your team focus on better code. Find the training material here. If you want to prepare before the tutorial starts follow the installation and configuration instructions. Download a shrink-wrapped demo Gerrit server here and install it following Starting Demo Gerrit in order to be able to do the exercises in case the wifi doesn't work. We will also distribute the material and needed installations on USB sticks during the training for those who can't prepare in advance.

by Eclipse Foundation at October 21, 2014 01:38 PM

Story of Android Web View -Part 1

by Saurav ( at October 21, 2014 11:04 AM

This is a story about a very funny creature in Android called Web View. Take deep caution while plunging into the deep waters of Web View. If you have a simple requirement of showing static content with some html then Web View is very fine. But if you have a full blown web page, using a web browser is the best option.

But if you have a requirement to use web view only with your web content, then brace yourself, you are in for a ride.

Web View to summarize is a nice browser like rendering UI which Android provides to render your web content. Web View was initially based on the open source Web Kit project. From Android 4.4 Kit Kat release it is now based on the chromium project on which the Google chrome is also based on. So that means behavior of Chrome and Android Web View (in 4.4 +) will be quite consistent.

Some links for Android web view could be read

If you migrating to web view in Android 4.4 then would be useful because Android web view's underlying system has changed.

Web View has a very nice security model, it by default comes with a bare bone Web view capable of only displaying html and static resources. No active content like Java Script can be executed at the beginning.

Below is how you can create a web view.

First of all you will need a layout file to render the web view.

<RelativeLayout xmlns:android=""
    tools:context=".WebViewActivity" >

Important thing to note is  the web view UI element.
Now lets come to an activity which will initialize the web view and show it.

String Uri = "";
WebView webView = (WebView) findViewById(;

The Web view loads into its web view.
You can either user loadURl or loadData method to load your content. A content can be typed into a string to have the full html content.
You might have a requirement to pass custom http headers apart from what the usual headers are sent. In this case  public void loadUrl(String url, Map<String, String> additionalHttpHeaders) method of Web View comes handy. The key value pair of headers can be passed for execution to the server.

The above code snippet is of  a very basic web view.
NowWeb View's flexibility and features can be increased by working with APIs , WebSettings, WebViewClient and WebChromeClient.
Web settings of web view can be controlled by the Web Settings object which is part of the Web View instance. it can be fetched by

WebSettings settings = webView.getSettings;
//Java script execution can be enabled like this
//If you want auto play to happen with your vidoes
webViewSettings.setMediaPlaybackRequiresUserGesture(false); //Only from API level 17

The second line helps you to execute Java script in the web view.
The third line becomes useful when you have a video in your web view which needs auto play. By default Android does not enable auto play of videos.

Its best advised to go through the java docs of Web View at the beginning to get aware of the full usage of Web View
In the next post  i will go through WebViewClient and WebChromeClient and display more advanced features of Web View.

My code could be tracked through my github account

by Saurav ( at October 21, 2014 11:04 AM

Explore Git Internals with the JGit API

by Rüdiger Herrmann at October 20, 2014 09:05 AM

Written by Rüdiger Herrmann

Have you ever wondered how a commit and its content is stored in Git? Well, I have, and I had some spare time over the last rainy weekend, so I did a little research.

Because I feel more at home with Java than with Bash, I used JGit and a couple of learning tests to explore the Git internals of commits. Here are my findings:

Git – an Object Database

Git at the core is a simple content-addressable data store. This means that you can insert any kind of content into it and it will return a key that you can use to retrieve the data again at a later point in time.

In the case of Git, the key is the 20 byte SHA-1 hash that is computed from the content. The content is also referred to as an object in Git terminology and consequently the data store is also called an object database.

Let’s see how JGit can be used to store and retrieve content.


In JGit, the ObjectInserter is used to store content into the object database. It can be seen as the rough equivalent to git hash-object in Git.

With its insert() method you can write an object to the data store whereas its idFor() methods only compute the SHA-1 hash of the given bytes. Hence the code to store a string looks like this:

ObjectInserter objectInserter = repository.newObjectInserter();
byte[] bytes = "Hello World!".getBytes( "utf-8" );
ObjectId blobId = objectInserter.insert( Constants.OBJ_BLOB, bytes );

All code examples assume that the repository varaible points to an empty repository that was created outside of the snippet.

The first parameter denotes the object type of the object to be inserted, a blob type in this case. There are further object types as we will learn later. The blob type is used to store arbitrary content.

The payload must be given in the second parameter, as a byte array in this case. An overloaded method that accepts an InputStream is also available.

And finally, the ObjectInserter needs to be flushed to make the changes visible to others accessing the repository.

The insert() method returns the SHA-1 hash that is computed from the type, the content length and the content bytes. In JGit, though, a SHA-1 hash is represented through the ObjectId class, an immutable data structure that can be converted to and from bytes, ints, and strings.

Now you can use the returned blobId to retrieve the content back and thus ensure that the above code actually wrote the content.

ObjectReader objectReader = repository.newObjectReader();
ObjectLoader objectLoader = blobId );
int type = objectLoader.getType(); // Constants.OBJ_BLOB
byte[] bytes = objectLoader.getBytes();
String helloWorld = new String( bytes, "utf-8" ) // Hello World!

The ObjectReader’s open() method returns an ObjectLoader that can be used to access the object identified by the given object ID. With the help of an ObjectLoader you can get an object’s type, its size and of course its content as a byte array or stream.

To verify that the object written by JGit is compatible with native Git you can retrieve its content with git cat-file.

$ git cat-file -p c57eff55ebc0c54973903af5f72bac72762cf4f4
Hello World!
git cat-file -t c57eff55ebc0c54973903af5f72bac72762cf4f4

If you look inside the .git/objects directory of the repository, you’ll find a directory named ‘c5′ with a file named ‘7eff55ebc0c54973903af5f72bac72762cf4f4′ in it. This is how the content is stored initially: as a single file per object, named with the SHA-1 hash of the content. The subdirectory is named with the first two characters of the SHA-1 and the filename consists of the remaining characters.

Now that you can store the content of a file, the next step is to store its name. And probably also more than just one file, since a commit usually consists of a group of files. To hold this kind of information, Git uses so called tree objects.

Tree Objects

A tree object can be seen as a simplified file system structure that contains information about files and directories.

It contains any number of tree entries. Each entry has a path name, a file mode and points to either the content of a file (a blob object) or another (sub) tree object if it represents a directory. The pointer of course is a SHA-1 hash of either the blob object or the tree object.

To start with, you can create a tree that holds a single entry for a file named ‘hello-world.txt’ that points to the above stored ‘Hello World!’ content.

TreeFormatter treeFormatter = new TreeFormatter();
treeFormatter.append( "hello-world.txt", FileMode.REGULAR_FILE, blobId );
ObjectId treeId = objectInserter.insert( treeFormatter );

The TreeFormatter is used here to construct an in-memory tree object. By calling append() an entry is added with the given path name, mode and the ID under which its content is stored.

Fundamentally, you are free to chose any path name. However, Git expects the path name to be relative to the working directory without a leading ‘/’.

The file mode used here indicates a normal file. Other modes are EXECUTABLE_FILE, which means it’s an executable file, and SYMLINK, which specifies a symbolic link. For directory entries, the file mode is always TREE.

Again, you will need an ObjectInserter. One of its overloaded insert() methods accepts a TreeFormatter and writes it to the object database.

You can now use a TreeWalk to retrieve and examine the tree object:

TreeWalk treeWalk = new TreeWalk( repository );
treeWalk.addTree( treeId );;
String filename = treeWalk.getPathString(); // hello-world.txt

Actually, a TreeWalk is meant to iterate over the added trees and their subtrees. But since we know that there is exactly one entry, a single call to next() is sufficient.

If you look at the just written tree object with native Git you will see the following

$ git cat-file -p 44d52a975c793e5a4115e315b8d89369e2919e51
100644 blob c57eff55ebc0c54973903af5f72bac72762cf4f4    hello-world.txt

Now that you have the necessary ingredients for a commit, let’s create the commit object itself.

Commit Objects

A commit object references the files (through the tree object) that constitute the commit along with some meta data. In detail a commit consists of:

  • a pointer to the tree object
  • pointers to zero or more parent commits (more on that later)
  • a commit message
  • and an author and committer

Since a commit object is just another object in the object database, it is also sealed with the SHA-1 hash that was computed over its content.

To form a commit object, JGit offers the CommitBuilder utility class.

CommitBuilder commitBuilder = new CommitBuilder();
commitBuilder.setTreeId( treeId );
commitBuilder.setMessage( "My first commit!" );
PersonIdent person = new PersonIdent( "me", "" );
commitBuilder.setAuthor( person );
commitBuilder.setCommitter( person );
ObjectInserter objectInserter = repository.newObjectInserter();
ObjectId commitId = objectInserter.insert( commitBuilder );

Using it is straightforward, it has setter methods for all the attributes of a commit.

The author and committer are represented through the PersonIdent class which holds the name, email, timestamp and time zone. The constructor used here applies the given name and email and takes the current time and time zone.

And the rest should be familiar already: an ObjectInserter is used to actually write the commit object and returns the commit ID.

To retrieve the commit object from the repository, you can again use the ObjectReader:

ObjectReader objectReader = repository.newObjectReader();
ObjectLoader objectLoader = commitId );
RevCommit commit = RevCommit.parse( objectLoader.getBytes() );

The resulting RevCommit represents a commit with the same attributes that were specified in the CommitBuilder.

And once again – to double-check – the output of git cat-file:

$ git cat-file -p 783341299c95ddda51e6b2393c16deaf0c92d5a0
tree 4b825dc642cb6eb9a060e54bf8d69288fbee4904
author me <> 1412872859 +0200
committer me <> 1412872859 +0200

My first commit!


The chain of parents form the history of a Git repository and model a directed acyclic graph. This means that the commits ‘follow’ one direction

A commit can have zero or more parents. The first commit in a repository does not have a parent (aka root commit). The second commit in turn has the first as its parent, and so on.

It is perfectly legal to create more than one root commit. If you use git checkout --orphan new_branch a new orphan branch will be created and switched to. The first commit made on this branch will have no parents and will form the root of a new history that is disconnected from all other commits.

Git Internals: Merge Commit
If you start branching and eventually merge the divergent lines of changes, this usually results in a merge commit. And such a commit has the head commits of the divergent branches as its parents.

In order to construct a parented commit, the ID of the parent commit needs to be specified in the CommitBuilder.

commitBuilder.setParents( parentId );

A RevCommit class, which represents a commit within the repository, can also be queried about its parents. Its getParents() and getParent(int) methods return all or the nth parent RevCommit.

Be warned however, that though the methods return RevCommits these are not fully resolved. While their ID attribute is set, all other attributes (fullMessage, author, committer, etc.) are not. Thus, an attempt to call parent.getFullMessage() for example will throw a NullPointerException. In order to actually use the parent commit you need to either retrieve a full RevCommit by means of the ObjectReader like outlined above or use a RevWalk to load and parse the commit header:

RevWalk revWalk = new RevWalk( repository );
revWalk.parseHeaders( parentCommit );

All in all, keep in mind to treat the returned parent commits as if they were ObjectIds instead of RevCommits.

More on Tree Objects

If you are to store files in sub-directories you need to construct the sub-trees yourself. Say you want to store the content of a file ‘file.txt’ in folder ‘folder’.

First, create and store a TreeFormatter for the subtree, the one that has an entry for the file:

TreeFormatter subtreeFormatter = new TreeFormatter();
subtreeFormatter.append( "file.txt", FileMode.REGULAR_FILE, blobId );
ObjectId subtreeId = objectInserter.insert( subtreeFormatter );

And then, create and store a TreeFormatter with an entry that denotes the folder and points to the just created subtree.

TreeFormatter treeFormatter = new TreeFormatter();
treeFormatter.append( "folder", FileMode.TREE, subtreeId );
ObjectId treeId = objectInserter.insert( treeFormatter );

Git Internals: Tree Object
The file mode of the entry is TREE to indicate a directory and its ID points to the subtree that holds the file-entry. The returned treeId is the one that would be passed to the CommitBuilder.

Git requires a certain sort order for entries in tree objects. The ‘Git Data Formats’ document that I found here states that

Tree entries are sorted by the byte sequence that comprises the entry name. However, for the purposes of the sort comparison, entries for tree objects are compared as if the entry name byte sequence has a trailing ASCII ‘/’ (0x2f).

To read the contents of the tree object you can again use a TreeWalk. But this time, you need to tell it to recurse into subtrees if you which to visit all entries. And also, don’t forget to set the postOrderTraversal to true if you whish to see entries that point to a tree. They would be skipped otherwise.

The whole TreeWalk loop will look like this in the end:

TreeWalk treeWalk = new TreeWalk( repository );
treeWalk.addTree( treeId );
treeWalk.setRecursive( true );
treeWalk.setPostOrderTraversal( true );
while( ) {
  int fileMode = Integer.parseInt( treeWalk.getFileMode( 0 ).toString() );
  String objectId = treeWalk.getObjectId( 0 ).name();
  String path = treeWalk.getPathString();
  System.out.println( String.format( "%06d %s %s", fileMode, objectId, path ) );

…and will lead to this output:

100644 6b584e8ece562ebffc15d38808cd6b98fc3d97ea folder/file.txt 
040000 541550ddcf8a29bcd80b0800a142a7d47890cfd6 folder 

Although I find the API not very intuitive it gets the job done and reveals all the details of the tree object.

Concluding Git Internals

No doubt, that for common use cases the high-level Add- and CommitCommands are the recommended way to commit files to the repository. Still, I found it worthwhile digging in to the deeper levels of JGit and Git and hope you did so, too. And in the – admittedly less common – case that you need to commit files to a repository without a working directory and/or index, the information provided here might help.

If you like to try out the examples listed here for yourself, I recommend to setup JGit with access to its sources and JavaDoc so that you have meaningful context information, content assist, debug-sources, etc.

The complete source code is hosted here:

For brevity, the samples shown here omit the code to release allocated resources. Please refer to the complete source code to get all the details.

The post Explore Git Internals with the JGit API appeared first on Code Affine.

by Rüdiger Herrmann at October 20, 2014 09:05 AM

Eclipse Icons for your Presentations

by Jérémie Bresson at October 20, 2014 05:55 AM

I am giving a lot of trainings lately. Some of them are for our co-workers at BSI (topics around Java and Eclipse). And some of them for external clients, mostly related to the Eclipse Scout framework.

For these trainings, I often have to prepare slides on short notice. As an example, the slide below explains the location of the tests in an Eclipse Scout RT project:

Where are the tests?

Frequently, a lot of icons representing the Eclipse IDE elements are needed in such slides. Unfortunately the icons of the IDE itself are too small (16×16 pixels) to be used on the slides, but luckily I found this page (UI Graphics > Design > Common Elements > Wizard elements) on the Eclipse wiki. This page also contains an Adobe Illustrator file including the wizard Icons. And those icons are exactly what I needed for my slides. From this Illustrator file, I could extract all icons with or without background and save them into individual files for both PNG and SVG formats.

Wizard icons

I checked with the Eclipse Foundation and got an answer from Mike Milinkovich: the icons I have created are licensed under EPL because they are a derivated work of the original file.

Hoping that this exercise may be useful to others, I have made my code and approach available on GitHub: common_wizard_elements (or just download the to get the SVG and PNG files).

Disclaimer: I am not a graphic designer and I have limited knowledge of the SVG file format. Feel free to give me feedback (as comment on this blog or on the GitHub project).

And just in case: should you be interested in Eclipse Scout trainings, please let us know.

Scout Links

Project Home, Forum, Wiki, Twitter

by Jérémie Bresson at October 20, 2014 05:55 AM

Why Your IoT Product Strategy Needs to Include Open Source

by Ian Skerrett at October 17, 2014 04:43 PM

For the last two years, I have been talking about why open source will be critical to the success of the Internet of Things.  The current state of IoT/M2M is a lot of propriertary platforms and protocols. This can’t last and won’t win in the long term.

This week during a webinar about the new Vorto IoT project from Bosch, I saw the best illustration of why companies that don’t include open source in their product strategy will eventually fail.  Check out this slide about the Bosch IoT Platform Strategy:

Bosch Product Strategy


Bosch is one of the leading industrial companies in the IoT industry. They definitely get it and their analysis of the market is definitely worth considering. Consider each of their assumptions very carefully:

1. 2-5 major IoTS platforms (in next 5-7 years) – At the start of every new technology innovation there are lots of different platforms that are developed. However, overtime the industry consolidates around 2-5 key providers, ex databases, web servers, Java servers, etc.   This will happen in IoT.

2. At least one of them will be Open Source – Open source has proven to be a provider of production quality software. In many markets, open source is the dominant supplier.  There is no reason to believe that this will not be the case in IoT.

3. Bosch not able to develop one of these proprietary platforms alone and customers/partners would not accept it – Developing a proprietary platform takes a LOT of development resources but more importantly a LOT of marketing, sales, and business development resources. Even a company as large as Bosch recognizes this fact. Companies like Google, Apple, IBM, SAP, Oracle, Salesforce, Microsoft plus some others may have the resources and skills to compete but most companies don’t. Most companies will need to identify their key value add for IoT. Providing a platform is not going to be a value add that is sustainable in the long-term.

4. No risk/dependency on proprietary 3rd party platform – Bosch and other companies still need an IoT platform, so they are making a make vs buy decision. If they decide to not Make  (see #3) then the buy decision comes down to a proprietary platform or an open source platform. Considering #2, deciding to go with an open source platform provides a lot more flexibility and less risk of being dependent on another company.

If you are setting a product strategy for an IoT product, you will be faced with a Make vs Buy decision.  I think Bosch makes a pretty compelling case for open source. More importantly, Bosch has decided to be a leader in open source, ensuring they have a significant role and stake in the success.

Reason #2

The other reason open source is going to win is captured in by Matt Asay in his recent article. The answer of course is: Developers.  As Matt points out ‘Developers aren’t going to go for proprietary standards.’  And as Matt points out, developers are attracted to code:

But let’s be clear: None of these companies lining up to join this or that foundation will prove dispositive in cementing any particular standard as theopen source standard. Developers do that.

And developers are attracted by tools and platforms that make them more productive, fast. Getting a marquee list of donors to a foundation is meaningless if the foundation doesn’t generate code that appeals to developers.

This is why what we are doing at Eclipse IoT is so important. We have code, sandbox servers and tutorials to make it easy for developers to get start with IoT.

It is clear code and openness will win in IoT. Join us in creating an amazing IoT open source community.

by Ian Skerrett at October 17, 2014 04:43 PM

Little Known Things about the Eclipse Infocenter: Debugging Information (5/5)

by howlger at October 17, 2014 03:18 PM

This is the last of the five well-hidden features of the Infocenter. The Eclipse Infocenter is the Eclipse help system launched as a web application which can of course also be remotely debugged like any other Java application. But in situations when you cannot easily access the server on which the Infocenter is running you can still get hold of a list of active plug-ins and some help-specific configuration information. Furthermore, you can display any file of an active plug-in. This debugging information, which is similar to the Configuration Details in the About Dialog of your Eclipse IDE, can be accessed not by following a link or by clicking a button but by opening specific URLs.

Infocenter About page

For a table of active plug-ins just open the page about.html. You can sort the rows by clicking on a column header. This list can be used to get the source code of the plug-ins, which is required for a remote debugging session. Or you can check if there are any known security vulnerabilities (e. g. cross-site scripting vulnerability) that need to be fixed by updating the Infocenter. You should use Eclipse 3.8 or newer just to be on the safe side. Two weeks ago I found three pretty old Infocenters with security issues which are certainly not the only ones. I informed the operators but nothing has happened so far. For this reason I even waited until today with publishing this post.

Infocenter About Preferences page

To get help-specific preferences you have to open about.html?show=preferences. But this page shows only the basic help configuration. To get a file such as plugin.xml, toc.xml or META-INF/MANIFEST.MF of a specific plug-in you have to open rtopic/, for example:

This was the final episode of the series on five little known things about the Eclipse Infocenter. I hope that you liked it. How many of the well-hidden features did you already know?

  1. Basic and Bot Mode
  2. Deep Linking
  3. Search Links
  4. Language Switching
  5. Debugging Information

Flattr this

by howlger at October 17, 2014 03:18 PM