Eclipse Community Awards 2015 Finalists

March 04, 2015 05:56 PM

Congratulations to the finalists! The winners will be annouced at EclipseCon 2015.

March 04, 2015 05:56 PM

Case Study MQTT: Why Open Source and Open Standards Drives Adoption

by Ian Skerrett at March 04, 2015 05:26 PM

For the last 3 years, we have been talking about why IoT needs open source and open standards to be successful. We are now seeing great examples of why this is so true and why open communities will lead IoT adoption.

MQTT is a perfect case study. This past month Eclipse Paho and Eclipse Mosquitto released new versions of their MQTT clients (Paho) and  MQTT broker (Mosquitto). I believe this is an important milestone for these projects and the adoption of MQTT by IoT solution providers. It seems to me that MQTT has now become a defacto `must be supported standard`for any serious IoT solution provider. And any smart IoT solution provider is using Paho and/or Mosquitto to implement MQTT.

Google Trends   Web Search interest  mqtt   Worldwide  2004   present

MQTT Google Trend

A quick look at the Google Trends report for MQTT makes it pretty clear interest in MQTT has taken off since Eclipse Paho was created and MQTT was submitted to OASIS for standardization. Now, if you follow the Paho and Mosquitto mailing lists you can see the community is fully engaged and developers are creating real solutions with Paho and Mosquitto.

A perfect example of why open source and open standards drive adoption. We are also seeing this with other standards like Lightweight M2M and CoAP.  Open is definitely winning in IoT

by Ian Skerrett at March 04, 2015 05:26 PM

Unit Testing in RAP 3.0

by Ralf Sternberg at March 04, 2015 04:06 PM

When you test components of a RAP application, you have to simulate the environment that RAP UI code normally runs in. Thanks to a new API, this becomes easier in RAP 3.0.

In an earlier post, my colleague Johannes explained how to write unit tests for RAP 2.x. This approach required more boilerplate code to set up and tear down the RAP environment in every single test case. To make it worse, this setup code had to use internals. The class Fixture had been created to test RAP itself and thus had a lot of methods that are not relevant for application development. Hence, it was explicitly excluded from the public API.

In RAP 3.0, we decided to clean up and provide real API. We moved all internal classes out of the public package and replaced it with a simple JUnit Rule. Instead of calling Fixture.setUp() and Fixture.tearDown(), you only need to include the following line in your JUnit test cases:

public TestContext context = new TestContext();

This will simulate a new test context (including UI thread, UISession, ApplicationContext etc.) for every test method and also enable event propagation (there’s no need for calling Fixture.fakePhase( PROCESS_ACTION ) anymore). TestContext is contained in the bundle org.eclipse.rap.rwt.testfixture.

When you write tests for custom widgets, you may need to inject mocked RemoteObjects. To do so, you can replace the Connection with your own implementation like so:

context.replaceConnection(new Connection() {
  public RemoteObject createRemoteObject(String remoteType) {
    return mockRemoteObject;

RAP 3.0 will be released together with Eclipse Mars in June 2015. The TestContext is already available in the latest stable build.


Leave a Comment. Tagged with eclipse, junit, rap, testing, eclipse, junit, rap, testing

by Ralf Sternberg at March 04, 2015 04:06 PM

Red Hat at EclipseCon 2015

by maxandersen at March 04, 2015 01:53 PM

Next week EclipseCon US is on.

It is going to be a busy week and Red Hat is a silver sponsor this year.

Here are some of the highlights related to Red Hat and JBoss.


CDT Summit about using Eclipse for C/C++, Linux tools etc.

Docker and Linux Tools with Jeff Johnston

18:00 - 19:00 Docker in Eclipse - BOF hosted by Red Hat


Hackathon where Mickael and I will be to work on Easier & smart import of projects


Red Hat will also have a booth this year, come and say Hi!

oh..and we might have a surprise :)

Other EclipseCon

If you are near Burlinggame, SFO then be aware there are other Theme Days such as ioT, Science, polarsys and XText, these you can get into for $200.

EclipseCon is also co-loated with the FOSS4G conference if you are into location technology.

See you there!

Have fun!

Max Rydahl Andersen

by maxandersen at March 04, 2015 01:53 PM

New Release of Eclipse Paho and Eclipse Mosquitto Continue Momentum of the Growing Open Source IoT Community and MQTT

March 04, 2015 01:18 PM

The Eclipse Foundation is pleased to announce the release of Eclipse Paho 1.1 and Eclipse Mosquitto 1.4.

March 04, 2015 01:18 PM

The Tree Layout Secret

by admin at March 04, 2015 11:42 AM

A recurring problem when developing a graphical modeler is providing the right layout. The advantage with Sirius is it provides you with a default algorithm that performs an automatic layout of all the elements on a diagram.

To illustrate the Sirius’ layout capabilities imagine that we want to visualize the hierarchy of characters in the US TV series House Of Cards. To do this we define the following metamodel:

First, we used Sirius to create a diagram representing the Persons.

Each person is represented by a white square with his or her name on it.

By default Sirius lays out nodes from left to right and what we now have is a flat diagram, with each person on exactly the same level.

However what we want to see is the White House organizational hierarchy so we need to represent the subordination link. This link is modeled using the dependsOn reference in the metamodel.
Second we define a new relation based edge mapping. This edge will connect Persons, and to find the subordinate we just use the dependsOn reference.

The default layout will automatically present an ordered tree diagram of the White House hierarchy with president Garrett Walker at the top of the diagram and Congressman Peter Russo at the bottom. When you define a relation based edge, Sirius then automatically lays out the elements as an ordered tree diagram by using the dependsOn reference to find the children.

That looks all very well and good. However, supposing that now we want to retain and be able to view our subordination link but also order our nodes according to a different relation. In our metamodel we add another reference influences that represents the influence one person can exert over another. We need to create another kind of diagram with the most influencial person at the top and the most influenced person at the bottom whilst still retaining the former subordination links between the persons.

Great news! This is really easy to implement with Sirius!
If the Sirius default algorithm does not fit your particular needs, you can configure some of the parameters or request alternative algorithms directly within the Sirius specification editor.
You can define either of:

  • A Composite Layout : this must be used to show containment relations. It enables you to specify padding between the different elements and the direction for the default algorithm.
  • An Ordered Tree Layout : this must be used so as to lay nodes as an ordered tree.

These layout algorithms manage only nodes connected by edges, other nodes are lay out from left to right as usual.

The Ordered Tree Layout is what we need for our case.
We defined a new Influence diagram with a Person mapping and a DependsOn mapping. These mappings are exactly the same as with the Hierarchy diagram. The only difference being that we have produced an Ordered Tree Layout.

The Children Expression is used to specify how to retrieve children for each node. In our example we use the influences reference to progress through the model.

Your Node Mapping must specify the mapping that the tree order algorithm is to operate on. In our example we want the algorithm to operate on Person.

Note: the ordered tree layout only works if you have only defined a single kind of node mapping in your diagram specification.

And… Ta-daaah! By defining this new layout you can see the person influencing every other player in the White House is… Frank Underwood, but Shh! That’s a secret ;)

Finally, if you need to go further, you can also provide your own layout algorithm programmatically.

The sample code from this example is available on github :

by admin at March 04, 2015 11:42 AM

Sirius posts are coming!

by admin at March 04, 2015 10:27 AM

Just to announce that we (I and some Sirius commiters from Obeo) will start a series of posts about some features available in Sirius. For the ones who don’t know, Sirius is an Eclipse project to quickly define multi view workbenches based on DSL with dedicated representations. Sirius is part of the release train since Luna and its version 3.0 will be available with Mars.
A modeling workbench created with Sirius is composed of a set of Eclipse editors which allow the users to create, edit and visualize EMF models.
In the next weeks, you will discover posts about diagram customization, tree layout, SVG images…

Stay tuned!

by admin at March 04, 2015 10:27 AM

SCT - Seamless Integration with C and Java type systems

by Andreas Mülder ( at March 04, 2015 10:02 AM

Yakindu Statechart Tools is shipped with a powerful expression language to model the reactive behavior of a state machine. It is a statically typed programming language that is familiar to everyone who knows C or Java. It provides all basic expressions  like logical expressions,arithmetic expressions, bitwise arithmetic and bit shifting.

The language is built on a default, platform-independent type system that supports the primitive types Integer, Real, Boolean, String and Void out of the box. During code generation, these built in types are then mapped to reasonable platform specific types. For example, a String is mapped to a java.lang.String in Java and a char * in C/C++.

However, this platform-independence comes at a price: You can't leverage all the captabilities of the underlying technologie in your state machine and you have to write glue code to integrate the generated code with your platform. These issues are well illustrated when it comes to the definition of operations. In SCT, it is possible to define operations, which can be called from an expression:

operation max(int1: integer, int2: integer): integer 
entry / myVar = max(1,2) 

The Java code generator then generate interfaces for all defined operations that must be implemented by the user. For example, the Java generator creates an interface with a corresponding java method signature. This interface has to be implemented by the client and passed to the statemachine, which is shown in the following code snippet:

DefaultSMStatemachine statemachine = new DefaultSMStatemachine();

SCInterfaceOperationCallback callback = new SCInterfaceOperationCallback() {
public int max(int param1, int param2) {
return Math.max(param1, param2) // Delegate the call to the Java Lib


But what if you want to develop a statemachine for the Java platform only? This is where Statechart Domains come into play. Select the Java Domain in the 'New Model Wizard' and get access to Java native types. For example, import java.util.Math in your statechart and access all methods like max, min or random directly from the statechart model!

Statechart Tools for Java

This integration is illustrated by the following example, a simple statechart that receives events with a value and puts them onto a Stack for later processing.

in event inEvent : Message
var stack : java.util.Stack<Message>

Note the definition of the event inEvent. The special feature about this is that the type of the event is the complex type Message - a Plain Old Java Object defined in a local Java Project containing a timestamp of type java.util.Date and a message of type String. Those fields can be accessed as properties from the statechart.

The variable stack is of type java.util.Stack with the type argument Message - the Java Type Integration even supports generic types! All (public) methods provided by java.util.Stack can be accessed directly from the Statechart, as you can see in the State MessageReceived when the currentMessage is pushed onto the stack. With Statechart Tools for Java you can develop your state machine in an object-oriented way like you are used to it from Java!

Statechart Tools for Embedded C

When creating a new statemachine model for the C Domain, it is possible to import C-header files and get access to all of the declared functions.The following example is a simplyfied version of a header from our Yakindu Smart Car.

After importing the C-Header (import: car_api.h), all defined complex types like Structs, Unions and Enumerations as well as TypeDefs and Functions become accessible directly from the Statechart model. The generated code integrates well with the imported headers so there is no need to write a bunch of glue code anymore!

Current implementation state

This is work in progress and still a lot of work to do. Although it is already possible to edit C and Java specific statecharts and generate code out of it, we still have to adopt the simulation engine to handle complex types. We expect to have a first version available in Q3/2015.

by Andreas Mülder ( at March 04, 2015 10:02 AM

FYI: Open Source Initiative (@OpenSourceOrg)

by Chris Aniszczyk at March 03, 2015 03:27 AM

If you aren’t aware of the Open Source Initiative (OSI), you should be. They are fantastic not-for-profit organization responsible for the Open Source Definition (which everyone should read once in their lives), they maintain a a list of compliant license definitions on top of promoting open source across the world.

They are also membership driven organization, which is supported by individuals and affiliates. As far as I know, they are the only organization that brings together a variety of open source individuals/institutions to cross-promote ways to work together improve the adoption of open source software:


They are also in the last month of their membership drive, so if you’re interested in supporting their cause, I highly recommend you consider joining as a member:

Also more selfishly, the OSI currently has nominations open for the board of director election which I’m partaking in. The current group of nominations include a great group of folks from all over the open source ecosystem and I’d love to have the opportunity to serve, my plans include expanding corporate membership and more.

So please consider supporting the OSI and vote your interests, they really make the greater open source community a better place.

by Chris Aniszczyk at March 03, 2015 03:27 AM

Docker and WildFly Part 2 - Deployment over management API

by robstryker at March 02, 2015 04:23 PM

If you’ve already gotten started with trying out Docker and JBoss Tools, and want to see what other options are available, this blog post will explain how to run Wildfly in a Docker container and configure it for management tasks and managed deployments.

Customizing your Dockerfile

Since the default jboss/wildfly Docker configuration doesn’t expose the management port by default, we’ll need to customize it, and this means writing your very first Dockerfile. Our goals here are to add a management user to the Dockerfile, and also to expose the management ports when running the container.

First, you’ll want to make a folder on your filesystem that you can play around in. I’ll name mine docker_jbds_wf_mgmt - Inside this folder, we’ll make a new file named Dockerfile and give it the following content:

FROM jboss/wildfly:latest
      USER jboss
      RUN /opt/jboss/wildfly/bin/ admin Admin#70365 --silent
      CMD ["/opt/jboss/wildfly/bin/", "-b", "", "-bmanagement", ""]

You can see that we’re extending the original jboss/wildfly container. In the above RUN command, we’re also adding a management user. Feel free to customize the password as you wish.

Exposing actual or sensitive passwords in a publicly accessible Dockerfile is dangerous. Make sure to only use example credentials in publicly available Dockerfiles.

Finally, we’re making sure that when the Docker container runs, it is also making sure to bind the management port to all possible hosts, helping to expose it for use.

Building your new Dockerfile

You can give your new configuration any name you want when building it. I’ll build mine here, and give it the name wildfly-mgmt :

docker build --tag=wildfly-mgmt .

Running your new Dockerfile

To run your new configuration, run the following command, replacing the last parameter with what name you chose when building the Dockerfile.

docker run -it -p 8080:8080 -p 9990:9990  wildfly-mgmt

Note that, unlike the previous post, we do not need to launch with custom volume mappings. All we need is the addition of the management port.

Configuring a Server in JBoss Tools

local fs 0

When creating the server remember to set the host to be dockerhost ( at least on OSX and Windows ) as shown above.

remote mgmt 1

Since we’ve configured the server to be remote, and for communication with the server to be handled over the management port, we mark it as Remote and controlled by Management Operations in the second page of the New Server wizard. We also don’t require a runtime here, though we may need one later when creating a functional web project with classes. For now, we won’t create one. You’ll also note that we have marked that the Server lifecycle is externally managed, which means we won’t be starting or stopping the server via JBoss Tools, since you’ll be controlling that via Docker on your own.

remote mgmt 2

On the next page, you’ll note that our remote runtime details are optional. Since the server is configured only for management operations, we have no real need to know where the filesystem is located or how to access it. We can safely ignore this page and just proceed through it.

Now, your server is created, but we still need to set the management credentials. First, double-click your Server in the Servers View to open the Server Editor. Then, set your credentials as you did in your Dockerfile as shown below. You’ll note that some default values are already there, and so you’ll need to delete them and set your own values.

remote mgmt credentials

Creating Your Web Project

In this example, we can create a very simple web project by browsing to File → New → Dynamic Web Project, Once the web project is created, we can create a simple index.html in the WebContent folder.

Starting the Server

Now that everything’s set up in Eclipse, we can start our Docker container as we mentioned before:

docker run -it -p 8080:8080 -p 9990:9990  wildfly-mgmt

Starting the Server Adapter

In Eclipse, we can now right-click our server, and select Start. This shouldn’t launch any commands, since we marked the server as Externally Managed. The server adapter is configured to check over the management port at dockerhost:9990 to see if the server is up or not, so it should quickly move to a state of [Started, Synchronized].

Deploying the Web Application

We can now right-click on our index.html project, and select Run As → Run On Server and follow the on-screen directions to deploy our web application. We should then notice the Eclipse internal browser pop up and display the content of our index.html files.


In this second example, we’ve seen how to install and configure a Wildfly Docker image customized for management operations in JBoss Tools.

To summarize, here are the steps needed:

  1. Create your own 'Dockerfile` that uses the existing jboss/wildfly configuration, but also adds a management user and starts server with the management port exposed

  2. Start Docker with 8080 and 9090 mapped

  3. Configure the server to run on dockerhost, using Remote management settings and have lifecycle externally managed

As you hopefully noted, this kind of setup is much more straightforward (no messing with paths); unfortunately it does have a downside since all publishes are full publishes over the management API. Because of this, incremental updates will not work in this case.

In a future example, I hope that we’ll see how to create an image customized for SSH access, which will allow starting and stopping the server and support incremental updates.

Rob Stryker

by robstryker at March 02, 2015 04:23 PM

Docker and WildFly Part 1 - Deployment via Docker volumes

by robstryker at March 02, 2015 04:23 PM

So you’ve heard the buzzwords and all the hype around Docker, but you haven’t had the chance to play around with it yet or see if it fits your needs. You’re already an avid user of JBoss Tools, and are fairly familiar with starting and stopping your local or remote Wildfly installation, and deploying web applications to it.

If this describes you, and you’re interested in trying out Docker, then this blog is targeted to you.

Docker Installation

Docker’s installation method differs based on your platform. You’ll want to review Docker’s Installation guides for your respective platforms.

To make things unified across the various platform, we recommend you go and map dockerhost to the ip of where your docker instance is running.

By default on Linux that will be, so you would add the following line to your /etc/hosts file: dockerhost

But on OSX and Windows it will be a unique IP you can get by running boot2docker ip (i.e. In that case the following should be added: dockerhost

From now on you can use dockerhost in all your applications and get to it no matter what OS you are running on.

Running the default wildfly image

Wildfly has published their docker images for public consumption. You can browse them at the docker registry, or go to for more information.

These images are JBoss' standard Docker images and they do not expose more features than just the bare minimum for production and reuse. This first blog will show how to use them as-is, but going forward we will show how to configure them to be a bit more useful for development use cases.

To make sure your docker installation has worked, and that Wildfly can start without any errors, you can do the following:

docker run -it -p 8080:8080 jboss/wildfly

This command will run the Docker image for jboss/wildfly in its default state, no customizations and map port 8080 on your dockerhost to 8080 of the running jboss/wildfly container.

Once this is run, the command will not only start up your container, but also launch the server in standalone mode, and connect a terminal to it so you can see the output.

terminal wf docker

You should also now be able to see WildFly default startup page on http://dockerhost:8080.

Assuming you see the console output, and the server runs with no errors and you can access the welcome browser via dockerhost then you’re set up and ready for the next step.

To terminate the container, you can simply press Ctrl+C. If, for some reason, your image has frozen, and Ctrl+C isn’t working, you can also run the following commands to kill it forcefully.

First list running containers:

[root@localhost docker]$ docker ps
      CONTAINER ID        IMAGE                  COMMAND                CREATED             STATUS              PORTS                    NAMES
      f70149043400        jboss/wildfly:latest   "/opt/jboss/wildfly/   58 seconds ago      Up 58 seconds>8080/tcp   ecstatic_darwin

Here I only have one container running; you might have more. But to kill any container, you execute docker kill f70149043400, replacing the given hash with your value from CONTAINER ID column.

Externally Managed Local Server With Deployment Folder Mapping

Since the Docker image in this example does not have SSH enabled, and the Wildfly server is not exposing the Management port, we will need to configure JBoss Tools to use custom filesystem deployments. The way to do this is to map in a local folder from our host into our container.

And since we start Wildfly via the Docker image, on the command-line. we’ll want to configure our Server Adapter in JBoss Tools to be an externally managed server, so it will not manage the start nor stop of the server.

Mapping a deployment folder

For this example, we’ll make a temporary directory somewhere on our host, and tell our Docker container to treat that as the standalone/deployments folder inside the container. In this way, changes made to the folder can be visible in both the host and container.

Mapping Folders may cause IO errors for SELinux!* To ensure your container can actually read and write to the folder, you’ll need to run setenforce 0 to disable SELinux, or, alternatively, give Docker the permissions and exceptions in SELinux. See this stackoverflow post for more information.
[root@localhost jbds_wf_external]$  mkdir /home/rob/tmp/dockertest1
      [root@localhost jbds_wf_external]$  docker run -it -p 8080:8080 \
      -v /home/rob/tmp/dockertest1:/opt/jboss/wildfly/standalone/deployments/:rw  jboss/wildfly

The ':rw' at the end is important, since without it the docker container cannot write to it, only read.

If you were to now place a .war file inside /home/rob/tmp/dockertest1, it will be picked up by the deployment scanner, and visible in a web browser. Take note of the folder, since we’ll use that in the configuration of the Server Adapter.

Making your Server Adapter

The final step of this example is to create your Wildfly 8.2 server adapter in JBoss Tools, and to create and deploy a web application to your temporary folder, which in my case is /home/rob/tmp/dockertest1

First, we’ll open the Servers View and create a new Wildfly 8.x server adapter. Since we’re exposing our container’s ports on dockerhost, we need to set the host to dockerhost.

local fs 0

The server should still be marked as Local and Controlled by Filesystem and shell operations as shown below.

local fs 1

Since we’re hacking a Local Filesystem server adapter to work for Docker, we’ll still need a local runtime in this example, so point it to any locally installed WildFly server you have.

In JBIDE-19388 we are looking at ways to avoid requiring this step.

Configuring your Server Adapter

Once your server is created, you’ll find it in the Servers View, where we can double-click it to open the Server Editor. From here, we can make what configuration changes we’ll need. First, we’ll need to make sure the server is Externally Managed. This means JBoss Tools will not attempt to start and stop it from Eclipse, it is expecting you the user handles that via Docker.

local fs externally managed

Next, we’ll need to disable the tooling for keeping deployment scanners in sync with the locations JBoss Tools expects to be deploying. Since we’ve already mapped the folder in via the Docker command line, we won’t need any additions to the deployment scanners at all.

local fs scanners

And finally, on the Deployment tab of the Server Editor, we’ll want to mark the default deploy folder to be a Custom location, and choose the folder that we previously mapped in via Docker’s command line, as shown below:

local fs deploy

Once all this is done, we can save the editor, and our server adapter is configured properly.

Make a Web Project

In this example, we can create a very simple web project by browsing to File → New → Dynamic Web Project, Once the web project is created, we can create a simple index.html in the WebContent folder.

Starting the Server

Now that everything’s set up in Eclipse, we can start our Docker container as we mentioned before:

docker run -it -p 8080:8080 -v /home/rob/tmp/dockertest1:/opt/jboss/wildfly/standalone/deployments/:rw  jboss/wildfly

Starting the Server Adapter

In Eclipse, we can now right-click our server, and select Start. This shouldn’t launch any commands, since we marked the server as Externally Managed. The server adapter is configured to check dockerhost:8080 to see if the server is up or not, so it should quickly move to a state of [Started, Synchronized].

Deploying the Web Application

We can now right-click on our index.html project, and select Run As → Run On Server and follow the on-screen directions to deploy our web application. We should then notice the Eclipse internal browser pop up and display the content of our index.html files.

Congratulations - you just used JBoss Tools to deploy a local running Docker hosted WildFly server.

What could be better ?

The default docker image is restricted by default. This means it does not have the Management port exposed, nor JMX nor file system access via SSH.

All this means that currently you have to go through some setup to use them from existing tools, but luckily we are doing two things:

  1. we will post more blogs explaning how to enable some of these features to use todays tools (not just JBoss Tools) with 'raw' docker.

  2. we are working on making the steps simpler when using Docker 'raw'


In this first example, we’ve seen how to install and configure the default Wildfly Docker images.

To summarize, here are the steps needed:

  1. Start Docker with 8080 mapped and with /opt/jboss/wildfly/standalone/deployments mounted as volume

  2. Configure server to run on dockerhost, be externally managed and Custom deploy to the volume above

In future examples, we’ll see how to extend those images for Management or SSH/SCP usecases.

Rob Stryker

by robstryker at March 02, 2015 04:23 PM

Release Engineering special issue now available

by Kim Moir ( at March 02, 2015 02:48 PM

The release engineering special issue of IEEE software was published yesterday. (Download pdf here).  This issue focuses on the current state of release engineering, from both an industry and research perspective. Lots of exciting work happening in this field!

I'm interviewed in the roundtable article on the future of release engineering, along with Chuck Rossi of Facebook and Boris Debic of Google.  Interesting discussions on the current state of release engineering at organizations that scale large number of builds and tests, and release frequently.  As well,  the challenges with mobile releases versus web deployments are discussed. And finally, a discussion of how to find good release engineers, and what the future may hold.

Thanks to the other guest editors on this issue -  Stephany Bellomo, Tamara Marshall-Klein, Bram Adams, Foutse Khomh and Christian Bird - for all their hard work that make this happen!

As an aside, when I opened the issue, the image on the front cover made me laugh.  It's reminiscent of the cover on a mid-century science fiction anthology.  I showed Mr. Releng and he said "Robot birds? That is EXACTLY how I pictured working in releng."  Maybe it's meant to represent that we let software fly free.  In any case, I must go back to tending the flock of robotic avian overlords.

by Kim Moir ( at March 02, 2015 02:48 PM

EclipseCon 2015 - 1 week away

March 02, 2015 07:33 AM

The conference is practially here! Don't forget to register.

March 02, 2015 07:33 AM

Announcing Orion 8.0

by John Arthorne at February 27, 2015 08:04 PM

The Orion Project is pleased to announce the release of Orion 8.0. You can check out the new release now on OrionHub, or grab your own copy of the Orion server from the download page. The Orion Node.js implementation matching this release is orion 0.0.35 on NPM. The Orion 8.0 release includes over 1000 commits from 36 unique contributors, and fixing 280 bugs. The major themes for this release were building higher value tools for JavaScript/CSS/HTML development, and in making the Orion server highly scalable.

In language tools, Orion 8.0 introduces Quick Fixes for automatically resolving common coding problems, semantic file to file navigation, smart language tool hovers, and many more smaller enhancements. For complete details on the extensive web tooling improvements, read Orion 8.0 Language Tooling Enhancements Part 1 and Part 2

On the server side, the main focus for Orion 8.0 has been on clustering support. For a site with heavy traffic, it is useful to have multiple Orion instances operating on the same Orion workspace content. This also allows you to have a running standby instance for fail-over and upgrade without any site downtime. To support this, Orion 8.0 has introduced file-based locking to manage contention across multiple instances. In addition, persistent state has been divided between instance-private and shared locations, to prevent sharing of the server’s own internal state that is not designed for sharing across instances.

A final major change on the server side was completely rewriting our search infrastructure. The new Orion search implementation provides global search and replace based on a server side search crawler, rather than indexing. This means searches take a little longer, but they have perfect accuracy. Server side search now also supports regular expressions and case-sensitive search, making this kind of search much faster than before. This implementation also simplifies Orion server management for large-scale Orion installs, because it saves Orion server admins from having to deal with search index sharding and Solr clustering. This server side global search is currently only available on the Java implementation of the Orion server, but there is a team in the community working on a Node.js implementation for this as well.


by John Arthorne at February 27, 2015 08:04 PM

WTP 3.6.3 Released!

February 27, 2015 03:05 PM

The Web Tools Platform's 3.6.3 Release is now available! Installation and update can be performed using the Luna Update Site at Releases 3.6.3, 3.6.2 and 3.6.1 fix issues that occur in prior releases or have been reported since 3.6's release. WTP 3.6.3 is featured in the Luna SR2 Eclipse IDE for Java EE Developers, with selected portions also included in other packages. Adopters can download the build itself directly.

More news

February 27, 2015 03:05 PM

Gimp 2.8 – Eclipse Splash

by eselmeister at February 27, 2015 08:19 AM

I was wondering why the splash screen is not visible anymore after using Gimp 2.8 to create the *.bmp file. It’s the color profile option that needs to be deactivated. Here’s the workflow:

Create a splash design with Inkscape:

Width: 455 px
Height: 295 px

Export the design to *.png format (90 dpi).

Splash Inkscape

Then open the *.png file with Gimp and export it to *.bmp format.

Splash Gimp

Use the options:

> Don’t write color information
24 Bit
> R8 G8 B8

That’s it :-).

by eselmeister at February 27, 2015 08:19 AM

New Eclipse Chain Completion Improvements and Hippie Privacy Settings

by Simon Laffoy at February 26, 2015 09:15 AM

Codetrails has just released Eclipse Recommenders 2.1.12 and Codetrails Connect 1.3.0. So what’s new? Let’s have a look ...

by Simon Laffoy at February 26, 2015 09:15 AM

Eclipse N!

by waynebeaton at February 26, 2015 04:29 AM

The Eclipse Planning Council—with help from the community—is trying to sort out the name for our eleventh named simultaneous release in 2016. We had some trouble with the first set of names that we selected, and so we’re into the second round.

The Lynn Lobby has significant momentum.

The “Eclipse Lynn” Lobby has significant momentum.

We started following the alphabet a few years ago, naming our fifth release “Helios“, and now we’re up to the letter N. We’ve been bouncing around some N names on Twitter; I quite like the idea of just going with “N”, and stated as much.

I originally put in the exclamation mark to make it seem more exciting, but then it occurred to me that the exclamation mark has special meaning in Lisp. In a functional programming language like Lisp, you generally avoid changing state, so Lisp functions that make changes are marked with a cautionary exclamation point (spoken as “bang”). When you invoke a bang function, things are going to change:

It seems appropriate. Change is in the air. I’m excited by the prospect of having an actual installer. I’m excited by our vision of the future of the developer’s platform.

With Mars, our June 2015 release, we’re making a subtle shift to put more focus on the user experience. This takes the form of our Every Detail Matters for Mars effort which aims to tackle a handful of “little things” like getting more of the default preferences right in our packages, standardizing naming conventions, providing reasonable and useful package-specific new and noteworthy documentation, improving the story for adding simultaneous release plug-ins into an Eclipse-based IDE, and more. I’m pretty excited about some bits of the “and more” part, but I’ll save that discussion for another day.

Of course, we’re also trying to tackle some pretty big things. We’ve come a long way towards having a proper installer for Eclipse. I’m also optimistic that we’ll be including Gradle support in Eclipse (more on this later).

We need your help and so we’ve started the Great Fixes for Mars skills competition. To enter, all you need to do is take responsibility for a bug, mark it as “greatfix”, and submit a patch. We’ve even provided a list of great suggestions where you can make the biggest impact. There’s prizes. Cool prizes.

Enter the Great Fixes for Mars skills competition; there'll be prizes!

Enter the Great Fixes for Mars skills competition; there’ll be prizes!

This shift in momentum will build through Mars and into the 2016 release. I’m certain that N-bang will usher in even bigger changes.

But what do I know? I’m just an Old Dude Who Knows Smalltalk (and Lisp).

EclipseCon 2015

by waynebeaton at February 26, 2015 04:29 AM

You can Fork & Clone a Repo from Fork Visualisation View

by Its_Me_Malai ( at February 26, 2015 12:24 AM

Having added the functionality of visualising Repositories that are online thru Fork Visualisation View, the next usecase was allowing them to the forked into our login and also clone into our eclipse git perspective.

We have now fixed this requirement. You may Fork a Repository from the Fork Visualisation View to your login and also clone it to add to your Git Repositories.

Screenshots as shown below

A new button is available on the Action Bar of the View. Select the repo that you want to Fork and click on this Fork and Clone action.

On successful Forking, this message would he sbown asking for Clone Confirmation. If clicked on YES, it opens the Clone dialog with the required URL filled as it is done on Paste in Git Repositories view.

It is available for download from MarketPlace :
Code is available on

Enjoyin Eclipsing until we meet next time.


by Its_Me_Malai ( at February 26, 2015 12:24 AM