Skip to main content

Show Your Support for Open Source IoT at the Eclipse Foundation

November 14, 2019 04:35 PM

The Eclipse IoT working group is launching a campaign to identify the adopters of Eclipse IoT open source projects. Companies — whether or not they are working group members — can be listed as adopters.

Adopters are organizations that voluntarily show their support for the Eclipse IoT projects they have adopted (i.e. shipping commercial products based on the projects and/or using the projects for non-commercial or internal reasons).

You can add your organization logo to our list of adopters by submitting a pull request or by creating an issue. You can attach files to an issue by dragging and dropping them in the text editor of the form.

If you plan on submitting a pull request, you will need to make the following changes to the website codebase:

  1. Add a colored and a white organization logo to static/assets/images/adoptors. We expect that all submitted logos to be transparent svg.
  2. Update the adopter data file: data/adopters.yml If your organization wishes to express support for multiple projects, you will need to add your organization’s YAML definition to the adopters list of each of the relevant project nodes.

Your participation in this initiative will publicly show your support for open source innovation.

List Eclipse IoT adopters on an Eclipse project website

Eclipse projects can showcase the logos of their adopters on their project websites. We built a JavaScript plugin to make this process easier. If you are a project committer, here are quick instructions on how to use the eclipsefdn-adopters.js on your Eclipse project website:


Include the plugin’s JS in the section of the page:

<script src="//"></script>

Load the plugin:

project_id: "[project_id]"

Create an HTML element containing the chosen selector:

<div class="eclipsefdn-adopters"></div>
  • By default, the selector’s value is eclipsefdn-adopters.


project_id: "[project_id]",
selector: ".eclipsefdn-adopters",
ul_classes: "list-inline",
logo_white: false
Attribute Type Default Description
project_id String Required: Select adopters from a specific project ID.
selector String .eclipsefdn-adopters Define the selector that the plugin will insert adopters into.
ul_classes String Define classes that will be assigned to the ul element.
logo_white Boolean false Whether or not we use the white version of the logo.

November 14, 2019 04:35 PM

Eclipse IP Policy: Reviewing Third Party Content

by waynebeaton at November 13, 2019 09:33 PM

I’ll start this discussion with some background…

Under the original Eclipse Foundation Intellectual Property (IP) Policy, every bit of third party content needed to be thoroughly reviewed before it could be used by an Eclipse project. And the reviews were thorough: license scan, provenance check, scan for anomalies, … Reviews of third party content literally took days, weeks, and months. All of that review needed to be complete before the project team could commit any code that made any reference to that third party content.

As you might imagine, the time required to engage in all of that analysis was somewhat inconvenient for project teams, so we introduced the notion of Parallel IP. The idea behind the introduction of Parallel IP was that the IP Team could perform a cursory check of the content and grant checkin, thereby authorizing the project team to commit code into their repository that leverages the content, while the IP Team engaged in their more thorough review in parallel. The project team needed to wait until that thorough review was complete before engaging in a release. Initially, Parallel IP was available only to Eclipse projects in the Incubation Phase; it was later extended to Eclipse projects in the Mature Phase, but only for new versions of third party content that had already been reviewed and approved.

Parallel IP made the process better. Committers only had to wait for a day or two before they could leverage new third party content. It worked well for those Eclipse projects that engaged in annual releases, but as more and more Eclipse projects increased their release frequency, the time required to complete reviews of third party content (and the lead time required to engage with the IP due diligence process ahead of a release) became a problem (it’s likely more accurate to say that the existing problem became more acute).

To accommodate those projects that needed to move quickly, we introduced the notion of license check only IP due diligence and gave Eclipse project teams the ability decide what sort of IP due diligence they’d like to engage. We helpfully labeled the new type of IP due diligence as Type A (license check only) and the classic thorough IP due diligence as Type B (license check, provenance check, and anomolies scan). We introduced some automation that leveraged open source tools to scan and automatically approve third party content submitted for Type A review. Based on the rate of adoption, Type A was very successful.

It’s worth pointing out that our Type A, even though it is less thorough than our Type B IP due diligence, it is still far more than any other open source organization does. In fact, our Type A provides a far more thorough review of third party content than most organizations engage in.

While the introduction of Type A made the IP due diligence process flow faster for Eclipse project teams, it didn’t address the underlying problem: that the process required that every single bit of third party content must be reviewed before it can be used in any capacity.

The October 2019 updates that we introduced to the Eclipse Foundation’s IP Policy changes an important definition that lets us turn the process around. The definition of the term Distributed Content had previously forced us to implement a process that required the review of all third party content before any use or reference to it could be committed to an Eclipse project’s source code repository. By narrowing the definition of Distributed Content to refer only to content that is included in a release, Eclipse project teams may now push commits that reference third party content without first checking with the IP Team during a development cycle. It’s only when it comes time to release that we need to certify that the third party content included in and referenced by the release is license compatible.

This change shifts some of the onus onto the project team. Before pushing a commit that leverages third party content, a committer will need to (at least informally) check to see if the license on that content is compatible with the project license. We’re not expecting that project committers do any sort of deep analysis, only that they review the licensing terms on the content (if the third party content’s license in on the Eclipse Foundation’s Approved Licenses list, then you’re probably okay). If there’s any question, or a committer feels that shenanigans might be afoot, they can engage with the Eclipse Foundation’s IP Team for help. Primarily, committers need to provide some scrutiny to the license of the content that they adopt to avoid surprises when it comes time to certify compliance ahead of a release.

With no requirement to review content in advance, there is no requirement to engage with the Eclipse IP Team via contribution questionnaires (CQs) for every single piece of third party content. Instead, we can leverage the vast database of intellectual property metadata that we’ve assembled over the years to validate an entire dependency list as a unit (I posted about this a couple of weeks ago). For those readers who have been part of our community for a while, this means that there is no longer any requirement to create piggyback CQs. Further, we’re leveraging other sources of intellectual property metadata (e.g., ClearlyDefined), which means that there is generally no longer any requirement to create CQs of any kind. In practice, we will continue to use CQs to engage the Eclipse IP Team to research and vet content for which information is not already available, or to investigate content when we detect shenanigans (we will also continue to use CQs to track project code and third party content that includes cryptography).

Our intent is to make as many of the changes work as possible using the process and infrastructure that we currently have in place. In 2020, we will start researching and evaluating new tools; our hope is that we will be able to implement our updated process using existing open source tools. In the meantime, we have some tools that we’ve been using internally to validate license compliance of third party content and are working on making these tools available in a form they can be leveraged by committers (we’ve just started capturing requirements on, and will track progress using Bug 553016).

We’ve only just gotten approval for the policy changes and have only just started implementing process changes. We appreciate your patience and we work to make all of this happen. We’re tracking our progress on Bug 552967.

by waynebeaton at November 13, 2019 09:33 PM

Update to the Eclipse IP Policy

by waynebeaton at November 12, 2019 04:39 PM

Sharon Corbett drafted this message that the IP Team has been posting on some of our CQs. I’d like to share it more broadly.

The Eclipse Board of Directors approved changes to the Eclipse Intellectual Property Policy on October 21, 2019.  The most significant change relates to how we will perform due diligence of leveraged Third Party Content (Section IV B).

Motivation and Background:

The Eclipse IP Policy and Procedures date back to 2004.  While we have made significant changes over time, we cannot support agile development nor continuous delivery.  Further, it’s impossible to scale to modern day technology such as Node.JS, Electron, NPM, etc.  Additionally, our process for third party content is burdensome and lacks automation.

License Compliance of Third Party Content:

The change removes the requirement to perform deep copyright, provenance and scanning of anomalies for Third Party Content unless it is being modified and/or if there are “special” considerations regarding the package. Instead, the focus for this content will be on license compliance only, which many of you know today as Type A. Reminder, please note that this will not impact how we handle project code and/or modified third party code.  Full due diligence review will remain in place for this content.  This change applies to THIRD PARTY Content only.


We are currently working on tooling to provide to Eclipse projects so that in the near future, Eclipse projects will perform these license compliance checks allowing projects to only check in with the IP Team to file a CQ when/if the project encounters IP violations or restrictions with respect to its Third Party Content.  We estimate this tooling will be available by the end of the year. 

We ask for your patience while we use existing infrastructure to roll out these changes with further automation being planned.  We will need to change documentation, front end changes, etc.  More information will be forthcoming on this topic.

These efforts are in support of our community and we will work with you as we continue to move forward with this new modernization effort.

by waynebeaton at November 12, 2019 04:39 PM

New features in Red Hat CodeReady Studio 12.13.0.GA and JBoss Tools 4.13.0.Final for Eclipse 2019-09

by Jeff Maury at November 11, 2019 07:30 AM

JBoss Tools 4.13.0 and Red Hat CodeReady Studio 12.13 for Eclipse 2019-09 are here and waiting for you. In this article, I’ll cover the highlights of the new releases and show how to get started.


Red Hat CodeReady Studio (previously known as Red Hat Developer Studio) comes with everything pre-bundled in its installer. Simply download it from our Red Hat CodeReady Studio product page and run it like this:

java -jar codereadystudio-<installername>.jar

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

This release requires at least Eclipse 4.13 (2019-09), but we recommend using the latest Eclipse 4.13 2019-09 JEE Bundle because then you get most of the dependencies pre-installed.

Once you have installed Eclipse, you can either find us on the Eclipse Marketplace under “JBoss Tools” or “Red Hat CodeReady Studio.”

For JBoss Tools, you can also use our update site directly:

What’s new?

Our main focus for this release was improvements for container-based development and bug fixing. Eclipse 2019-06 itself has a lot of new cool stuff, but I’ll highlight just a few updates in both Eclipse 2019-06 and JBoss Tools plugins that I think are worth mentioning.

Red Hat OpenShift

OpenShift Container Platform 4.2 support

With the new OpenShift Container Platform (OCP) 4.2 now available (see the announcement), even if this is a major shift compared to OCP 3, Red Hat CodeReady Studio and JBoss Tools are compatible with this major release in a transparent way. Just define your connection to your OCP 4.2 based cluster as you did before for an OCP 3 cluster, and use the tooling!

CodeReady Containers 1.0 Server Adapter

A new server adapter has been added to support the next generation of CodeReady Containers 1.0. Although the server adapter itself has limited functionality, it is able to start and stop the CodeReady Containers virtual machine via its crc binary. Simply hit Ctrl+3 (Cmd+3 on OSX) and type new server, which will bring up a command to set up a new server.

crc server adapter

Enter crc in the filter textbox.

You should see the Red Hat CodeReady Containers 1.0 server adapter.

Select Red Hat CodeReady Containers 1.0 and click Next.

All you have to do is set the location of the CodeReady Containers crc binary file and the pull secret file location, which can be downloaded from

Once you’re finished, a new CodeReady Containers server adapter will then be created and visible in the Servers view.

Once the server is started, a new OpenShift connection should appear in the OpenShift Explorer view, allowing the user to quickly create a new Openshift application and begin developing their AwesomeApp in a highly replicatable environment.

Server tools

Wildfly 18 Server Adapter

A server adapter has been added to work with Wildfly 18. It adds support for Java EE 8 and Jakarta EE 8.

EAP 7.3 Beta Server Adapter

A server adapter has been added to work with EAP 7.3 Beta.

Hibernate Tools

Hibernate Runtime Provider Updates

A number of additions and updates have been performed on the available Hibernate runtime providers.

The Hibernate 5.4 runtime provider now incorporates Hibernate Core version 5.4.7.Final and Hibernate Tools version 5.4.7.Final.

The Hibernate 5.3 runtime provider now incorporates Hibernate Core version 5.3.13.Final and Hibernate Tools version 5.3.13.Final.


Views, Dialogs and Toolbar

The new Quick Search dialog provides a convenient, simple and fast way to run a textual search across your workspace and jump to matches in your code. The dialog provides a quick overview showing matching lines of text at a glance. It updates as quickly as you can type and allows for quick navigation using only the keyboard. A typical workflow starts by pressing the keyboard shortcut Ctrl+Alt+Shift+L (or Cmd+Alt+Shift+L on Mac). Typing a few letters updates the search result as you type. Use Up-Down arrow keys to select a match, then hit Enter to open it in an editor.

Save editor when Project Explorer has focus

You can now save the active editor even when the Project Explorer has focus. In cases where an extension contributes Saveables to the Project Explorer, the extension is honored and the save action on the Project Explorer will save the provided saveable item instead of the active editor.

“Show In” context menu available for normal resources

The Show In context menu is now available for an element inside a resource project on the Project Explorer.

Show colors for additions and deletions in Compare viewer

In simple cases such as a two-way comparison or a three-way comparison with no merges and conflicts, the Compare viewer now shows different colors, depending on whether text has been added, removed, or modified. The default colors are green, red, and black, respectively.

The colors can be customized through usual theme customization approaches, including using related entries in the Colors and Fonts preference page.

Editor status line shows more selection details

The status line for Text Editors now shows the cursor position, and when the editor has something selected, it shows the number of characters in the selection as well. This also works in the block selection mode.

These two new additions to the status line can be disabled via the General > Editors > Text Editors preference page.

Shorter dialog text

Several dialog texts have been shortened. This allows you to capture important information faster.



Close project via middle-click

In the Project Explorer, you can now close a project using middle-click.


Improved usability of Environment tab in Launch Configurations

In the Environment tab of the Launch Configuration dialog, you can now double-click on an environment variable name or value and start editing it directly from the table.

Right-clicking on the environment variable table now opens a context menu, allowing for quick addition, removal, copying, and pasting of environment variables.

Show Command Line for external program launch

The External Tools Configuration dialog for launching an external program now supports the Show Command Line button.


Close editors automatically when reaching 99 open editors

The preference to close editors automatically is now enabled by default. It will be triggered when you have opened 99 files. If you continue to open editors, old editors will be closed to protect you from performance problems. You can modify this setting in the Preferences dialog via the General > Editors > Close editors automatically preference.

In-table color previews for Text Editor appearance color options

You can now see all the colors currently being used in Text Editors from the Appearance color options table, located in the Preferences > General > Editors > Text Editor page.

Automatic detection of UI freezes in the Eclipse SDK

The Eclipse SDK has been configured to show stack traces for UI freezes in the Error Log view by default for new workspaces. You can use this information to identify and report slow parts of the Eclipse IDE.

You can disable the monitoring or tweak its settings via the options in the General > UI Responsiveness Monitoring preference page as shown below.

Themes and Styling

Start automatically in dark theme based on OS theme

On Linux and Mac, Eclipse can now start automatically in dark theme when the OS theme is dark. This works by default, that is on a new workspace or when the user has not explicitly set or changed the theme in Eclipse.

Display of Help content respects OS theme

More and more operating systems provide a system-wide dark theme. Eclipse now respects this system-wide theme setting when the Eclipse help content is displayed in an external browser. A prerequisite for this is a browser that supports the prefers-color-scheme CSS media query.

As of the time of writing, the following browser versions support it:

  • Firefox version 67
  • Chrome version 76
  • Safari version 12.1

Help content uses high-resolution icons.

The Help System, as well as the help content of the Eclipse Platform, the Java Development Tooling, and the Plug-in Development Environment, now uses high-resolution icons. They are now crisp on high-resolution displays and also look much better in the dark theme.

Improved dark theme on Windows

Labels, Sections, Checkboxes, Radio Buttons, FormTexts, and Sashes on forms now use the correct background color in the dark mode on windows.

General Updates

Interactive performance

Interactive performance has been further improved in this release and several UI freezes have been fixed.

Show key bindings when command is invoked

For presentations, screencasts, and learning purposes, it is very helpful to show the corresponding key binding when a command is invoked. When the command is invoked (via a key binding or menu interaction) the key binding, the command’s name and description are shown on the screen.

You can activate this in the Preferences dialog via the Show key binding when command is invoked checkbox on the General > Keys preference page. To toggle this setting quickly, you can use the Toggle Whether to Show Key Binding command (e.g., via the quick access).

Java Developement Tools (JDT)

Java 13 Support

Java 13 is out, and Eclipse JDT supports Java 13 for 4.13 via Marketplace.

The release notably includes the following Java 13 features:

  • JEP 354: Switch Expressions (Preview).
  • JEP 355: Text Blocks (Preview).

Please note that these are preview language features; hence, the enable preview option should be on. For an informal introduction of the support, please refer to Java 13 Examples wiki.

Java Views and Dialogs

Synchronize standard and error output in console

The Eclipse Console view currently can not ensure that mixed standard and error output is shown in the same order as it is produced by the running process. For Java applications, the launch configuration Common tab now provides an option to merge standard and error output. This ensures that standard and error output is shown in the same order it was produced but also disables the individual coloring of error output.

Java Editor

Convert to enhanced ‘for’ loop using Collections

The Java quickfix/cleanup Convert to enhanced ‘for’ loop is now offered on for loops that are iterating through Collections. The loop must reference the size method as part of the condition and if accessing elements in the body, must use the get method. All other Collection methods other than isEmpty invalidate the quickfix being offered.

Initialize ‘final’ fields

A Java quickfix is now offered to initialize an uninitialized final field in the class constructor. The fix will initialize a String to the empty string, a numeric base type to 0, and, for class fields, it initializes them using their default constructor if available or null if no default constructor exists.

Autoboxing and Unboxing

Use Autoboxing and Unboxing when possible. These features are enabled only for Java 5 and higher.

Improved redundant modifier removal

The Remove redundant modifier now also removes useless abstract modifier on the interfaces.

For the given code:

You get this:

Javadoc comment generation for module

Adding a Javadoc comment to a Java module ( will result in automatic annotations being added per the new module comment preferences.

The $(tags) directive will add @uses and @provides tags for all uses and provides module statements.

Chain Completion Code Assist

Code assist for “Chain Template Proposals” will be available. These will traverse reachable local variables, fields, and methods, to produce a chain whose return type is compatible with the expected type in a particular context.

The preference to enable the feature can be found in the Advanced sub-menu of the Content Assist menu group (Preferences > Java > Editor > Content Assist > Advanced).

Java Formatter

Remove excess blank lines

All the settings in the Blank lines section can now be configured to remove excess blank lines, effectively taking precedence over the Number of empty lines to preserve setting. Each setting has its own button to turn the feature on, right next to its number control. The button is enabled only if the selected number of lines is smaller than the Number of empty lines to preserve; otherwise, any excess lines are removed anyway.

Changes in blank lines settings

There’s quite a lot of changes in the Blank lines section of the formatter profile.

Some of the existing subsections and settings are now phrased differently to better express their function:

  • The Blank lines within class declarations subsection is now Blank lines within type declaration.
  • Before first declaration is now Before first member declaration.
  • Before declarations of the same kind is now Between member declarations of different kind.
  • Before member class declarations is now Between member type declarations.
  • Before field declarations is now Between field declarations.
  • Before method declarations is now Between method/constructor declarations.

More importantly, a few new settings have been added to support more places where the number of empty lines can be controlled:

  • After last member declaration in a type (to complement previously existing Before first member declaration setting).
  • Between abstract method declarations in a type (these cases were previously handled by Between method/constructor declarations).
  • At end of method/constructor body (to complement previously existing At beginning of method/constructor body setting).
  • At beginning of code block and At end of code block.
  • Before statement with code block and After statement with code block.
  • Between statement groups in ‘switch.’

Most of the new settings have been put in a new subsection Blank lines within method/constructor declarations.


JUnit 5.5.1

JUnit 5.5.1 is here and Eclipse JDT has been updated to use this version.


Enhanced support for –patch-module during launch

The Java Launch Configuration now supports patching of different modules by different sources during the launch. This can be verified in the Override Dependencies…​ dialog in the Dependencies tab in a Java Launch Configuration.

Java Build

Full build on JDT core preferences change

Manually changing the settings file .settings/org.eclipse.jdt.core.prefs of a project will result in a full project build, if the workspace auto-build is on. For example, pulling different settings from a git repository or generating the settings with a tool will now trigger a build. Note that this includes timestamp changes, even if actual settings file contents were not changed.

For the 4.13 release, it is possible to disable this new behavior with the VM property: -Dorg.eclipse.disableAutoBuildOnSettingsChange=true. It is planned to remove this VM property in a future release.

And more…​

You can find more noteworthy updates in on this page.

What is next?

Having JBoss Tools 4.13.0 and Red Hat CodeReady Studio 12.13 out we are already working on the next release for Eclipse 2019-12.


The post New features in Red Hat CodeReady Studio 12.13.0.GA and JBoss Tools 4.13.0.Final for Eclipse 2019-09 appeared first on Red Hat Developer.

by Jeff Maury at November 11, 2019 07:30 AM

Getting to the Source

by Ed Merks ( at November 08, 2019 09:04 AM

As a Java developer using JDT, no doubt you are intimately familiar with Ctrl-Shift-T to launch the Open Type dialog.  You might not even realize this is a shortcut accessible via the Navigate menu.  So you probably will not have noticed that this menu also contains Open Discovered Type:

Eclipse has a huge variety of open source projects maintained in a bewildering collection of Git repositories.  Many are hosted at Eclipse:
Others are hosted at Github:

Finding the Git repository that contains a particular Java class is like finding a needle in a haystack.  This is where Open Discovered Type comes to the rescue.  Once a week, Oomph indexes every *.java file in every Git repository hosted by and  The Open Discovered Type dialog loads this information to populate a tree view of all these packages and classes.

Please read the help information the first time you use it.  It was written to help you get the most out of this dialog.  Also be patient the first time you launch the dialog; there's a lot of information to download.

Suffice to say, you can use the dialog much like you do Open Type.  So here we search for JavaCore and discover all the classes with that name:

We can select any one of them and discover all the Git repositories containing that class and we can use the context menu for each link for each repository or for the specific file in that repository to open the link where we want it opened.  From that link, you can of course see the full history of the repository or specific file.

As a bonus, if this repository provides an Oomph setup, you can easily use that Oomph setup to import the sources for this project into your workspace. If there is no Oomph setup, you'll have to do that manually.

In any case, contributing to Eclipse open source projects has never been easier.

by Ed Merks ( at November 08, 2019 09:04 AM

Eclipse startup up time improved

November 05, 2019 12:00 AM

I’m happy to report that the Eclipse SDK integration builds starts in less than 5 seconds (~4900 ms) on my machine into an empty workspace. IIRC this used to be around 9 seconds 2 years ago. 4.13 (which was already quite a bit improved used around 5800ms (6887ms with EGit and Marketplace). For recent improvements in this release see Thanks to everyone who contributed.

November 05, 2019 12:00 AM

Announcing Ditto Milestone 1.0.0-M2

November 04, 2019 05:00 AM

The second and last milestone of the upcoming release 1.0.0 was released today.

Have a look at the Milestone 1.0.0-M2 release notes for what changed in detail.

The main changes and new features since the last release 1.0.0-M1a release notes are

  • invoking custom foreign HTTP endpoints as a result of events/messages
  • ability to reflect Eclipse Hono’s device connection state in Ditto’s things
  • support for OpenID Connect / OAuth2.0 based authentication in Ditto Java Client
  • configurbale throttling of max. consumed WebSocket commands / time interval


The new Java artifacts have been published at the Eclipse Maven repository as well as Maven central.

The Docker images have been pushed to Docker Hub:


The Eclipse Ditto team

November 04, 2019 05:00 AM

Setup a Github Triggered Build Machine for an Eclipse Project

by Jens v.P. ( at October 29, 2019 12:55 PM

Disclaimer 1: This blog post literally is a "web log", i.e., it is my log about setting up a Jenkins machine with a job that is triggered on a Github pull request. A lot of parts have been described elsewhere, and I link to the sources I used here. I also know that nowadays (e.g., new Eclipse build infrastructure) you usually do that via docker -- but then you need to configure docker, in which

by Jens v.P. ( at October 29, 2019 12:55 PM

LiClipse 6.0.0 released

by Fabio Zadrozny ( at October 25, 2019 06:59 PM

LiClipse 6.0.0 is now out.

The main changes is that many dependencies have been updated:

- it's now based on Eclipse 4.13 (2019-09), which is a pretty nice upgrade (in my day-to-day use I find it appears smoother than previous versions, although I know this sounds pretty subjective).

- PyDev was updated to 7.4.0, so, Python 3.8 (which was just released) is now already supported.


by Fabio Zadrozny ( at October 25, 2019 06:59 PM

Running a CI system is hard? It doesn't have to be.

by Denis Roy at October 23, 2019 09:44 AM

At EclipseCon Europe 2019 I attended a very interesting talk entitled "CI systems need care, too! Here's how we improved ours over the years". It was an eye opener! Here's what I gathered.

  • New developer comes to a Company
  • Company sells a software product built by a CI system
  • The CI system is a cobbled hack
  • Developer raises awareness that
    • CI is important
    • Fast CI feedback loop is important
    • CI is on the criticali path to profit (delivering the product)
  • Developer becomes an IT sysadmin and a Release Engineer to fix the CI, thus distracted from the actual task of improving the product.

The Eclipse CBI project (Common Build Infra) has been solving these problems for over 12 years. If you can relate to the unfortunate scenario above, here's what I can suggest:

  • Host your code at the Eclipse Foundation.
    • With IT and Release Engineers on staff, you can focus on code, not the build.
    • With Best Practices, we can help with your build so you can focus on code.
  • If you must fix your CI system yourself:
    • Come to EclipseCon. Seriously, we'll save you so much more than the price of admission.
    • Check out the Eclipse CBI project
    • Browse the Foundation's YouTube channel, there are a number of CBI talks that can be beneficial.


We've all been guilty of reinventing the wheel. Let's not do that. We're here to help (slides to come).

by Denis Roy at October 23, 2019 09:44 AM

Qt World Summit 2019 Berlin – Secrets of Successful Mobile Business Apps

by ekkescorner at October 22, 2019 12:39 PM

Qt World Summit 2019

Meet me at Qt World Summit 2019 in Berlin


I’ll speak about development of mobile business apps with

  • Qt 5.13.1+ (Qt Quick Controls 2)
    • Android
    • iOS
    • Windows 10


Qt World Summit 2019 Conference App

As a little appetizer I developed a conference app. HowTo download from Google Play Store or Apple and some more screenshots see here.


sources at GitHub

cu in Berlin

by ekkescorner at October 22, 2019 12:39 PM

Send web requests and assert results with vertx-junit5-web-client

by slinkydeveloper at October 22, 2019 12:00 AM

In last Vert.x 3.8 release we added a new module called vertx-junit5-web-client, that brings Vert.x Web Client injection into tests and provides an API called TestRequest to simplify the creation and assertions on WebClient requests:

import static io.vertx.junit5.web.TestRequest.*;

  VertxExtension.class, // VertxExtension MUST be configured before VertxWebClientExtension
public class TestRequestExample {

  public void test1(WebClient client, VertxTestContext testContext) {
    testRequest(client, HttpMethod.GET, "/hello") // Build the request
        queryParam("name", "francesco"), // Add query param
        requestHeader("x-my", "foo") // Add request header
        // Assert that response is a JSON with a specific body
        jsonBodyResponse(new JsonObject().put("value", "Hello Francesco!")),
        // Assert that response contains a particular header
        responseHeader("x-my", "bar")
      .send(testContext); // Complete (or fail) the VertxTestContext


testRequest() will use Vert.x Web Client to send the request. When the response is received, It succeds the test or it correctly propagates assertion failures, if any.

You can also send multiple requests using Checkpoint:

import static io.vertx.junit5.web.TestRequest.*;

  VertxExtension.class, // VertxExtension MUST be configured before VertxWebClientExtension
public class MultiTestRequestExample {

  public void test2(WebClient client, VertxTestContext testContext) {
    Checkpoint checkpoint = testContext.checkpoint(2); // Create the Checkpoint to flag when request succeds

        client    // Create the test request using WebClient APIs
          .addQueryParam("name", "francesco")
          .putHeader("x-my", "foo")
        jsonBodyResponse(new JsonObject().put("value", "Hello Francesco!")),
        responseHeader("x-my", "bar")
      .send(testContext, checkpoint); // Pass the checkpoint to flag

          .addQueryParam("name", "julien")
          .putHeader("x-my", "foo")
        jsonBodyResponse(new JsonObject().put("value", "Hello Julien!")),
        responseHeader("x-my", "bar")
      .send(testContext, checkpoint);


Look at Vert.x JUnit 5 Web Client documentation for more details

by slinkydeveloper at October 22, 2019 12:00 AM

A nicer icon for Quick Access / Find Actions

October 20, 2019 12:00 AM

Finally we use a decent icon for Quick Access / Find Actions. This is now a button in the toolbar which allows you to trigger arbitrary commands in the Eclipse IDE.

October 20, 2019 12:00 AM

Eclipse Vert.x 3.8.3

by vietj at October 18, 2019 12:00 AM

We have just released Vert.x 3.8.3, a bug fix release of Vert.x 3.8.x.

Since the release of Vert.x 3.8.3, quite a few bugs have been reported. We would like to thank you all for reporting these issues.

Vert.x 3.8.3 release notes

The artifacts have been deployed to Maven Central and you can get the distribution on Bintray.

You can bootstrap a Vert.x 3.8.3 project using

The event bus client using the SockJS bridge are available from NPM, Bower and as a WebJar:

Docker images are also available on the Docker Hub. The Vert.x distribution is also available from SDKMan and HomeBrew.

Happy coding and see you soon on our user or dev channels.

by vietj at October 18, 2019 12:00 AM

A Tool for Jakarta EE Package Renaming in Binaries

by BJ Hargrave ( at October 17, 2019 09:26 PM

In a previous post, I laid out my thinking on how to approach the package renaming problem which the Jakarta EE community now faces. Regardless of whether the community chooses big bang or incremental, there are still existing artifacts in the world using the Java EE package names that the community will need to use together with the new Jakarta EE package names.

Tools are always important to take the drudgery away from developers. So I have put together a tool prototype which can be used to transform binaries such as individual class files and complete JARs and WARs to rename uses of the Java EE package names to their new Jakarta EE package names.

The tools is rule driven which is nice since the Jakarta EE community still needs to define the actual package renames for Jakarta EE 9. The rules also allow the users to control which class files in a JAR/WAR are transformed. Different users may want different rules depending upon their specific needs. And the tool can be used for any package renaming challenge, not just the specific Jakarta EE package renames.

The tools provides an API allowing it to be embedded in a runtime to dynamically transform class files during the class loader definition process. The API also supports transforming JAR files. A CLI is also provided to allow use from the command line. Ultimately, the tool can be packaged as Gradle and Maven plugins to incorporate in a broader tool chain.

Given that the tool is prototype, and there is much work to be done in the Jakarta EE community regarding the package renames, I have started a list of TODOs in the project' issues for known work items.

Please try out the tool and let me know what you think. I am hoping that tooling such as this will ease the community cost of dealing with the package renames in Jakarta EE.

PS. Package renaming in source code is also something the community will need to deal with. But most IDEs are pretty good at this sort of thing, so I think there is probably sufficient tooling in existence for handling the package renames in source code.

by BJ Hargrave ( at October 17, 2019 09:26 PM

Integration of HTTP endpoints/webhooks

October 17, 2019 04:00 AM

By adding another connectivity type - HTTP - to Ditto’s connectivity, it is now (to be released in the next Ditto milestone 1.0.0-M2) possible to to publish twin events, messages, live commands and events to existing HTTP servers/endpoints.

That is especially useful for invoking existing APIs (which are most of the time HTTP based) whenever e.g. a digital twin was modified.

One example on how to benefit from this new feature is to invoke a custom IFTTT (if-this-than-that) webhook via a HTTP POST request which then may trigger other IFTTT follow-up-actions (e.g. send a chat message to a Slack room).

For IFTTT “webhooks” the address would be POST<your-event-name>/with/key/<your-key> and the expected JSON body:

  "value1": "...",
  "value2": "...",
  "value3": "..."

In combination with payload mapping, the value1 to value3 fields requested by the IFTTT API can be extracted from the Ditto Protocol and could contain the changed value.

In combination with filters for targets you can even specify to only publish e.g. twin events, where the temperature of a twin exceeded a certain threshold:

  "address": "POST:/trigger/<your-event-name>/with/key/<your-key>",
  "topics": [

Get creative on which HTTP APIs to trigger based on twin events. E.g. invoke a “function-as-a-service” API or invoke the Twitter API and let your digital twin tweet whenever it detects, that it is getting too warm in your office.


The Eclipse Ditto team

October 17, 2019 04:00 AM

I’ll never forget that first EclipseCon meeting with you guys and Disney characters all around and…

by Doug Schaefer at October 16, 2019 01:18 AM

I’ll never forget that first EclipseCon meeting with you guys and Disney characters all around and the music. And all the late nights in the Santa Clara bar and summits and meetings talking until no one else was left. Great times indeed. Until we meet again Michael!

by Doug Schaefer at October 16, 2019 01:18 AM

Missing ECE already? Bring back a little of it - take the survey!

by Anonymous at October 15, 2019 09:22 PM

We hope you enjoyed the 2019 version of EclipseCon Europe and OSGi Community Event as much as we did.

Please share your thoughts and feedback by completing the short attendee survey. We read all responses, and we will use them to improve next year's event.

Speakers, please upload your slides to your session page. Attendees really appreciate this!

by Anonymous at October 15, 2019 09:22 PM

Eclipse Collections 10.0 Released

by Donald Raab at October 14, 2019 09:53 PM

README: The features you want with the collections you need

Thank you to the contributors

Eclipse Collections 9.2 was released in May 2018. The 9.x releases were extremely feature rich and had many contributions from the community. The 10.0 release is even more so. There were 18 contributors in the 10.0 release. This is outstanding! Thank you so much to all of the contributors who donated their valuable time to making Eclipse Collections more feature rich and even higher quality. Your efforts are very much appreciated.

Too many features for one blog

There are so many features included in Eclipse Collections 10.0, that it is going to take me a bit longer to write good examples leveraging all of them. So I have decided to break this release blog into a few parts. This part will purely be a summary.

Update: Detailed Feature Blogs

The Feature Summary

  1. Specialized Interfaces for MultiReaderList/Bag/Set
  2. Implement Stream for Primitive Lists
  3. Implement toMap with target Map
  4. Implement MutableMapIterable.removeAllKeys
  5. Implement RichIterable.toBiMap
  6. Implement Multimap.collectKeyMultiValues
  7. Implement fromStream(Stream) on collection factories
  8. Implement LazyIterate.cartesianProduct
  9. Add updateValues to primitive maps
  10. Implement MutableMultimap.getIfAbsentPutAll
  11. Implement Bag.collectWithOccurrences
  12. Add reduce and reduceIfEmpty for primitive iterables
  13. Add <type1><type2>To<type1>Function for primitives
  14. Add ofInitialCapacity to primitive maps
  15. Implement countByEach on RichIterable
  16. Implement UnifiedSetWithHashingStrategy.addOrReplace
  17. Implement UnmodifiableMutableOrderedMap
  18. Implement withAllKeyValues on mutable primitive maps.
  19. Add ability to create PrimitivePrimitive/PrimitiveObject/ObjectPrimitiveMap from Iterable
  20. Implement ofInitialCapacity and withInitialCapacity in HashingStrategySets
  21. Implement getAny on RichIterable
  22. Revamp and standardize resize/rehash for all primitive hash structures
  23. Implement factory methods to convert Iterable<BoxedPrimitive> to PrimitiveStack/Bag/List/Set
  24. Implement ImmutableSortedBagMultimapFactory in Multimaps
  25. Implement a Map factory method that takes a Map parameter.
  26. Wildcard type in MultableMultimap.putAllPairs & add methods

Check out the latest JavaDoc for the new features.

Other Improvements

  1. Improved Test Coverage
  2. Many build improvements
  3. Remove duplicate code
  4. Removed some deprecated classes
  5. Improved generics
  6. Some new benchmark tests
  7. And much more!

Thank you

From all the contributors and committers… thank you for using Eclipse Collections. We hope you enjoy all of the new features and improvements in the 10.0 release.

I’ll be publishing detailed examples for the new features in the 10.0 release in a few blogs. Stay tuned!

Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.

Eclipse Collections 10.0 Released was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

by Donald Raab at October 14, 2019 09:53 PM

Participate in the 2019 IoT Commercial Adoption Survey!!

October 10, 2019 03:30 PM

According to McKinsey, the Internet of Things (IoT) will have a total potential economic impact of up to $11.1 trillion a year by 2025.

October 10, 2019 03:30 PM

A Committer’s View of Our New ECD Tools Working Group

by Thabang Mashologu at October 10, 2019 01:48 PM

When you look at the very impressive list of founding members for our new Eclipse Cloud Development (ECD) Tools Working Group, it’s clear that world-leading technology companies strongly believe that open source, cloud native development tools are needed. Our Eclipse Foundation developer community has also enthusiastically embraced the initiative.

To get an insider’s view of why the ECD Tools Working Group initiative is so important, I recently talked to Carlos Andres De La Rosa, an active Eclipse Foundation committer, about why he is getting involved in the Working Group. Here’s an edited version of our conversation.


Q. How did you first become involved in the open source communities at the Eclipse Foundation?

 A. I was looking for something interesting from which I could learn something new related to cloud technologies. I found the Eclipse MicroProfile project about two years ago. That was a very interesting topic for me, especially the fault tolerance spec. I added my email address to the mailing list and started joining weekly calls. After a while, I started to contribute to the spec with different things, like improving the spec testing, adding and modifying documentation, and also debating about how to evolve the spec. I became a committer and an entire technological world opened up for me. Jakarta EE was another interesting project that got my attention, so then I became involved with the Jakarta EE community.

I like the fact that Eclipse projects are from the people, for the people, so anyone can learn and contribute to solve problems that can help a lot of developers around the world. It’s shared knowledge and that’s the most important thing for me.


Q. Why did you expand your involvement to include the ECD Tools Working Group?

 A. When you’re part of the community, you have access to beta versions of the specifications and projects. I was looking around and I learned about this new project for cloud development tools. I saw the charter and what people were trying to achieve and I knew I wanted to be part of it. It was that simple.

I think cloud technologies will be the biggest and most important topic for the next 10 years. Everything is moving to the cloud, so every day we have more applications, from banking to AI medical analysis services. And, people have easy access to all this thanks to the cloud. I want to be there at the forefront and be working for the community when cloud really starts to grow.


Q. What benefits do you expect to gain from your participation in the ECD Tools Working Group?

A. It’s a huge opportunity to learn from the best engineers in the world because there are a lot of great professionals at the Eclipse Foundation and they have a lot of experience driving technology forward. If you’re new to this field and you’re trying to learn new things, this is a big chance to do it. Also, I’m currently working as a cloud consultant and this project is very related to my day-to-day job, so I can use what I learn in this project to improve my consultancy services.


Q. What impact do you think the ECD Tools Working Group will have on open source, cloud native development?

A. I think the impact will be huge because this group will deliver all of the tools that will be used every day in cloud development. From deploy, scale, debug, and manage, to Cloud Foundry applications, everything is integrated with the Eclipse IDE making the job of developers more productive.


Q. How does your participation in the ECD Tools Working Group fit with the other cloud-related projects you’re involved with at the Eclipse Foundation?

A. Everything is related. MicroProfile provides implementations and specs for capabilities such as fault tolerance that are needed in a microservices architecture to make it easier for developers to create microservices. And the Jakarta EE specs are basically the foundation for the MicroProfile framework because MicroProfile depends on the Java enterprise specs. The Eclipse Cloud Development Tools is a complementary project that helps to complete the framework for cloud native applications. So, they are all part of the cloud ecosystem. 

I really think that MicroProfile, Jakarta EE, and now the Eclipse Cloud Development Tools Working Group are the three most important projects at the Eclipse Foundation right now. They will drive the future of cloud technologies and everything that is handled and developed by the community.


Q. What would you say to people who are considering joining the ECD Tools Working Group?

A. I would say “join now!” The most important thing I can tell people is get involved if you want to learn about a cutting-edge technology that will be driving peoples’ lives for a long time. And contribute to help create something meaningful. It’s a community, so it’s for everyone.

by Thabang Mashologu at October 10, 2019 01:48 PM

Jakarta EE Community Update October 2019

by Tanja Obradovic at October 09, 2019 05:07 PM

Welcome to the latest Jakarta EE community update. In this edition, we highlight key opportunities to participate in upcoming community events, explore the Jakarta EE 8 release, and learn more about the very bright future of cloud native Java.

EclipseCon Europe 2019: Register for Community Day

Community Day, which will be held Monday, October 21 at EclipseCon Europe, is a must for everyone who’s interested in our cloud native projects. The day is dedicated to community-organized meetings to discuss projects and technologies, provide workshops and coding sessions, hold working group gatherings, and more. Lunch and breaks are included, and the day ends with a casual reception.

There’s already a gathering planned for anyone interested in Jakarta EE, MicroProfile, Eclipse Jemo, Eclipse Che, Eclipse Codewind, and other cloud-related topics. To see the agenda so far, and add your ideas for discussion topics, check the EclipseCon Europe Community Day wiki.

 And, don’t forget to attend our new event this year — Community Evening on Tuesday, October 22. This is your opportunity to participate in more casual, interactive events and enjoy a beverage with your community colleagues. A bar offering beer, wine, water, and juice will be available. 

To register for EclipseCon Europe and for Community Day, click here.


 JakartaOne Livestream Wrap-Up

The first-ever JakartaOne Livestream event was a huge success with more than 1,400 registered attendees. The online conference, held September 10, marked the release of the first vendor-neutral, Java EE 8-compatible release of Jakarta EE following the new Jakarta EE Specification Process.

We first knew this event would be bigger than expected when several well-respected leaders in the Java EE community graciously and enthusiastically agreed to join the JakartaOne Livestream Program Committee. Led by Committee Chair, Reza Rahman, committee members Adam Bien, Ivar Grimstad, Arun Gupta, Josh Juneau, along with Tanja Obradovic from the Eclipse Foundation, put in a huge effort to plan the conference.

One of the committees’ toughest jobs was selecting 16 conference papers for presentation from among the more than 50 high-quality submissions. Participants enjoyed a great mixture of introductory and overview sessions, including sessions on particular specifications, cloud native topics, keynotes from Mike Milinkovich and James Gosling, as well as industry keynotes from Jakarta EE Working Group Steering Committee members IBM, Fujitsu, Oracle, Payara, Red Hat, and Tomitribe. Demos, panel discussions, and Q&A sessions rounded out the 18 hours of program material that were delivered.

To see a list of the topics presented and access the session recordings, visit    


Jakarta EE 8 Release Highlights

The Jakarta EE 8 release is now available with 43 projects, more than 60 million lines of code, and full compatibility with Java EE 8.

 With the delivery of the Jakarta EE 8 Platform, the entire ecosystem — from software vendors to developers and enterprises — has all of the pieces needed to shape the future of cloud native Java and meet the modern enterprise’s need for cloud-based applications that resolve key business challenges.

To ensure that cloud native Java applications are portable, secure, stable, and resilient, product compatibility certifications are underway. We already have three products that are certified as compatible with the full Jakarta EE 8 platform:

·      Eclipse GlassFish application server, version 5.1

·      IBM Open Liberty server runtime, version 19.0

·      Red Hat WildFly application server, version 17.0

Eclipse GlassFish and Open Liberty are also certified as Jakarta EE 8 web profile-compatible products.

Almost three dozen Jakarta EE specifications are also available. Jakarta projects are listed here and are included in our main project repository. It’s time for everyone to get involved in the cloud native Java community and engage in turning the huge potential for cloud native Java into reality.


Our Free Cloud Native Java E-Book Is Now Available

To mark the significance of the Jakarta EE 8 release, we also released a free e-book, Fulfilling the Vision for Open Source, Cloud Native Java, on September 10. The e-book includes insights from some of the leading voices in enterprise Java and the Jakarta EE Working Group. It explores:

·      Why the world needs open source, cloud native Java

·      The common vision for cloud native Java that has emerged

·      The many benefits of cloud native Java for software vendors, developers, and enterprises

·      Why it’s time for all Java stakeholders to get involved in the Jakarta EE Working Group

·      Priorities for evolving cloud native Java in the short- and long-term

·      The vital role of the Eclipse Foundation in supporting cloud native Java evolution

 Download the e-book today.


A Look Back at September Events

September was a busy month for Jakarta EE and cloud native Java events as we participated in the JakartaOne Livestream event, described earlier, as well as Oracle Code One and HeapCon. Check out the blogs about Oracle Code One by Payara and Tomitribe.

 A quick note about Oracle Code One: Everyone at the Eclipse Foundation was extremely proud when our executive director, Mike Milinkovich, accepted the Duke’s Choice Award on behalf of the Jakarta EE community at the conference.


Stay Connected With the Jakarta EE Community

The Jakarta EE community promises to be very active and there are a number of channels to help you stay up to date with all of the latest and greatest news and information. Tanja Obradovic’s blog offers a sneak peek at the community engagement plan, which includes:

·      Social media: Twitter, Facebook, LinkedIn Group

·      Mailing lists: and

·      Newsletters, blogs, and emails: Eclipse newsletter, Jakarta EE blogs, monthly update emails to, and community blogs on “how are you involved with Jakarta EE”

·      Meetings: Jakarta Tech Talks, Jakarta EE Update, Jakarta Town Hall, and Eclipse Foundation events and conferences, such as EclipseCon Europe

Subscribe to your preferred channels today. And, get involved in the Jakarta EE Working Group to help shape the future of open source, cloud native Java. To learn more about Jakarta EE-related plans and check the date for the next Jakarta Tech Talk, be sure to bookmark the Jakarta EE Community Calendar.

by Tanja Obradovic at October 09, 2019 05:07 PM

Payara Server is Jakarta EE 8 Compatible!

October 09, 2019 03:00 PM

Payara Services and the Eclipse Foundation, Inc. today announced the application server ,Payara Server, a Jakarta EE 8 compatible implementation.

October 09, 2019 03:00 PM

Open Source Gerrymandering

by Chris Aniszczyk at October 08, 2019 06:20 PM

Over the years, I have spent a lot of time thinking about and working on open source communities… from bootstrapping projects out of corporations (or broken communities), to starting brand new open source foundations.

I was recently having a conversation with an old colleague about bringing an open source project out of a company into the wild and how to setup the project for success. A key part of that discussion involved setting up the governance for the project and what that means. There was also discussion how neutral and open governance under a nonprofit foundation can be good for certain projects as research has shown that neutral foundations can promote growth and community better than other approaches. Also the conversation led to a funny side discussion on the concept of gerrymandering and open source.

For those who aren’t familiar with the term, it’s become popular in the US political lexicon as a “practice intended to establish a political advantage for a particular party or group by manipulating district boundaries.� A practical example of this is from my town of Austin TX which is in district 35 which snakes all the way from Austin to San Antonio for some reason.

The same concept of gerrymandering can apply to open source communities as open source projects can act like mini political institutions (or bigger ones in the case of Kubernetes). I shared some of my favorite examples with my friend so I figured I’d write this down for future reference and share it with folks as you really need to read the “fine print� to find these at times.

Apache Cassandra

The Apache Software Foundation (ASF) is a fantastic open source organization that has been around for a long time (they celebrated their 20th anniversary) and has had a lot of impact across the world. The way projects are governed in the ASF are through the Apache Way, which places a lot of emphasis on “community over code� amongst some other principles which are great practices for open source projects to follow.

There have been some interesting governance issues and lessons learned over the years in the ASF, in particular it can be challenging when you have a strong single vendor associated with a project as was with the case with Cassandra awhile ago:

As the ASF board noted in the minutes from its meeting with DataStax representatives, “The Board expressed continuing concern that the PMC was not acting independently and that one company had undue influence over the project.” There was some interesting press around the time this happened:

“Jagielski told me in an interview, echoing what he’d said on the Cassandra mailing list, that undue influence conflicts with project leadership obligations established by the ASF. As he suggested, the ASF tried many times to get a DataStax-heavy Project Management Committee (PMC) to pay attention to alleged trademark and other violations, to no avail. Whatever DataStax’s positive influence on the development of the project—in other words—it failed to exercise equivalent influence on governing the project in ASF fashion.â€�

The ASF basically forced a reorganization of the Cassandra PMC to be in more in lines with its values and then caused the primary vendor behind the project to pull engineers off the open source project.


The containerd project is an industry-standard container runtime with an emphasis on simplicity, robustness and portability. The history of the project comes from being born at Docker where their open source projects had a governance policy essentially aligned with the BDFL philosophy with one of their project founders.

In CNCF, (which containered is a project of), project governance documents aren’t considered static and evolve over time to meet the needs of their community. For example, when containerd joined the CNCF their governance was geared towards a BDFL approach but over time evolved to a more neutral approach that spread authority across maintainers.

Cloud Foundry

Cloud Foundry is an open source community that has a large and mature ecosystem of PaaS focused projects. In the Cloud Foundry Foundation (CFF), they have a unique governance clauses in regards to how affiliates are treated and voting.

Pivotal Platinum Director Voting Power. The Platinum Director appointed by Pivotal (“Pivotal Director�) shall have five (5) votes on any matter submitted to a vote of the Board. (i) On a date one (1) year after the incorporation date set forth in the Certificate, the number of Pivotal Director’s votes will be reduced to three (3). (ii) On a date two (2) years after the incorporation date set forth in the Certificate, the number of Pivotal Director’s votes will be reduced to one (1)

To bootstrap the foundation, the originating company wanted a little bit of control for a couple of years, which can make sense in some situations as the beginning of a foundation can be a tumultuous time. In my opinion, it’s great to see the extra vote clause expire after 2 years, however, it’s still very unfair to the early potential members of the organization.

Another example of open source gerrymandering can be how votes are represented by member companies that are owned by a single entity:

At no time may a Member and its Affiliates have more than one Director who is an employee, officer, director, or consultant of that Member, except that Pivotal, EMC, and VMware, though Affiliates, shall each have one (1) Director on the Board).

This is an interesting tidbit given that Dell owns Pivotal, EMC and VMWare. In some organizations, usually there is legal language that collapses owned entities into one vote.

I personally I’m not the biggest fan of this approach as it makes things unfair from the beginning and can be an impediment to wide adoption across the industry. There can definitely be reasons of why you need to do this in the formation phase but it should be done with caution. If you saw the recent news that Pivotal was being spun back into VMWare and their woes with adoption, it shouldn’t come as a surprise in my opinion as one company was bearing too much of the burden in my opinion and not building a diverse community of contributors.

Cloud Native Computing Foundation (CNCF)

If you remember the early days of the container and orchestration wars, there was a lot different technologies, approaches and corporate politics. When CNCF was founded, the original charter included a clause that upgraded certain startup members from Silver to Platinum that were important in the ever evolving cloud native ecosystem.

“The Governing Board may extend a Platinum membership at the Silver Membership Scale rates on a year-by-year basis for up to 5 years to startup companies with revenues less than $50 million that are deemed strategic technology contributors by the Governing Board.�

In my opinion, that particular piece in the charter was important in bringing together all the relevant startups to the table along with the big established companies at the time.

In terms of projects, the CNCF Technical Oversight Committee (TOC) defines a set of principles to steward the technical community. The most important principle is around a minimum viable governance that enables projects to be self-governing. TOC members are available to provide guidance to the projects but do not control them. 

Unlike Apache and the Apache Way, CNCF does not require its hosted projects to follow any specific governance model. Instead, CNCF specifies that graduated projects need to “explicitly define a project governance and committer process.� So in reality, CNCF operates under the principle of subsidiarity, encouraging decisions to be made at the lowest project level consistent with their resolution.


GitLab is a fantastic open source project AND company that I admire deeply for their transparency. The way the GitLab project is structured is that it’s wholly owned by the GitLab company (they also own the trademark). To the credit of GitLab, they make this clear via their stewardship principles online and discuss what they consider enterprise product work versus project work.

I’d love for them in the future to separate the branding from the company, project and the product as I believe it’s confusing and dilutes the messaging, but that’s just my opinion 🙂


Istio is a popular service mesh project originated at Google. It has documented its governance model publicly:

However, as you can see, it’s heavily tilted towards Google and there seems to be no limits on the number of spots on the steering committee from one company which is a common tactic in open governance approaches to keep things fair. On top of that, Google owns the trademark, domains and other project assets so I’d consider Istio to be heavily gerrymandered in Google’s versus the community’s interest.


I had the pleasure of serving on the Java Community Process (JCP) Executive Committee for a few years while I was at Twitter. It’s a great organization that drives standardization across the Java ecosystem, some of the fine print is interesting though:

“The EC is composed of 25 Java Community Process Members whose seats are allocated as follows: 16 Ratified Seats, 6 Elected Seats, and 2 Associate Seats, plus one permanent seat held by Oracle. (Oracle’s representative must not be a member of the PMO.) The EC is led by a non-voting Chair from the PMO.â€�

This essentially gives Oracle a permanent seat on the Executive Committee.

Here’s another fun clause:

Ballots to approve Umbrella JSRs that define the initial version of a new Platform Edition Specification or JSRs that propose changes to the Java language are approved if (a) at least a two-thirds majority of the votes cast are “yes” votes, (b) a minimum of 5 “yes” votes are cast, and (c) Oracle casts one of the “yes” votes. Ballots are otherwise rejected.

This essentially gives Oracle a veto vote on any JSR.

Note: The coolest thing the JCP has done is contribute the EE specification work to the Eclipse Foundation and form the Jakarta project over there to steward things in an open way.


Knative, like Istio mentioned above, is an open source project that was born at Google and controlled by Google. There have been a lot of discussion lately about this as Google recently decided to not openly govern the project and move it to a neutral foundation:


Kubernetes operates under the auspices of the CNCF and openly governed by the Kubernetes Steering Committee (KSC). The Kubernetes project has grown significantly over time, but has done a great job of keeping things openly governed and inclusive in my opinion, especially compared to its project size these days. The KSC governs the project along with a variety of sub working groups. Also, the Kubernetes trademark is neutrally owned by the CNCF and openly governed via the Conformance Working Group which decides how certification works for the community, which there are nearly 100 certified solutions out there!


The Spinnaker project was originally born at Netflix and recently spun out into the Continuous Delivery Foundation (CDF) as an openly governed project. The project assets, from domains to github to trademarks are all neutrally owned by the community through the CDF.


Vault is a fantastic and widely used secrets management tool from Hashicorp. It’s a single vendor controlled open source project that has an open core model with an open source and enterprise versions (see matrix). What this essentially means is that the buck stops at the single vendor on what features/fixes end up in the open source version, most likely that won’t include things that they sell in their enterprise offering.


I hope you learned something new about open source projects, foundations and communities as these things can be a little bit more complicated as you dig into the details. It’s really important to note that there is a difference between open source and open governance and you should always be skeptical of a project that claims it’s truly open if only one for profit company owns all the assets and control. While there’s nothing wrong with this approach at all, most organizations don’t set expectations up front which can lead to frustrations down the road. Note, there’s nothing wrong with single vendor controlled open source projects, I think they are great but I think they need to be upfront, similar to what GitLab stewardship principles on what they will put in open source versus their enterprise version.

In conclusion, as with anything in life, you should always read the fine print of an open source communities charter or legal paperwork to understand how it works. The lesson here is that every organization or project has its own rules and governance and it’s important that you understand how decisions are made and who has ownership of project assets like trademarks.

by Chris Aniszczyk at October 08, 2019 06:20 PM

JShell in Eclipse

by Jens v.P. ( at October 08, 2019 12:16 PM

Java 9 introduced a new command line tool: JShell. This is a read–eval–print loop (REPL) for Java with some really nice features. For programmers I would assume writing a test is the preferred choice, but for demonstrating something (in a class room for example) this is a perfect tool if you are not using a special IDE such as BlueJ (which comes with its own REPL). The interesting thing about

by Jens v.P. ( at October 08, 2019 12:16 PM

Re-Defining Cloud Development Tools

by Mike Milinkovich at October 08, 2019 10:30 AM

The Eclipse community is seriously on a roll these days. Hot on the heels of the Eclipse Che 7 release, we just announced the Eclipse Cloud Development (ECD) Tools Working Group, a vendor-neutral, open source collaboration that will focus on the evolution of development tools for, and in, the cloud.

I haven’t seen an initiative with the potential impact on the development tools industry since the founding of the Eclipse Foundation back in 2004, when we hosted around 12 projects related to the Eclipse IDE.

When the first Eclipse IDE was launched, it fulfilled the need for a vendor-neutral development environment that would help developers adapt to rapidly changing middleware technologies and business priorities including enterprise Java and Web services. Those were the megatrends at the time. And the impact of the Eclipse IDE was massive, as it drove a decade of enormous adoption and industry consolidation around developer tools.

While the Eclipse IDE is still extremely relevant, better than ever, and is actively used by more than four million developers, today the megatrend is cloud development. And, the world needs open source technologies and tools to drive the development of cloud native applications. The purpose of the ECD Tools group is to deliver modern, extensible, web-based developer tool platforms that can be used by everyone to enable their own cloud enablement strategies.

Huge Demand for Open Source Cloud Development Technologies

We know from the responses to our developer surveys and the enthusiastic responses to our recent Jakarta EE 8 release that there’s huge demand for open source cloud development technologies. More than 80 percent of the Java developers we surveyed earlier this year told us they either are already or plan to create cloud native applications within the next 12-18 months.

However, many developers are well beyond the planning stage. The growth and explosion of the Kubernetes container orchestration platform confirms the urgency to deliver open source cloud development technologies is very real today.

Che 7 is the world’s first Kubernetes-native IDE that’s built from the ground up for cloud native application development. It simplifies and accelerates cloud development by allowing developers who are not Kubernetes experts to immediately contribute to cloud native application development efforts. In turn, Che 7 relies upon Eclipse Theia, which provides a highly modular and extensible IDE platform built on modern web technologies that runs on both your desktop or in your browser.

Accelerating Open Source, Cloud Native Development

The ECD Tools Working Group takes our open source cloud development initiatives to the next level.

The Working Group will drive the evolution and widespread adoption of emerging standards for cloud-based developer tools, including language support, extensions, and developer workspace definition. These efforts will accelerate adoption of a Cloud IDE and container-based workspace management.

With such a broad scope, it will come as no surprise to learn that the ECD Tools Working Group encompasses a wide range of open source cloud development projects, including Eclipse Che, Eclipse Theia, Eclipse CodeWind, Eclipse Dirigible, Eclipse Sprotty, and others.

Big-Name Support and Involvement

We could not create a working group of this magnitude and with this potential without the incredible level of support we’ve received from the founding members of this group.

When companies such as Broadcom, EclipseSource, Ericsson, IBM, Intel, Red Hat, SAP, Software AG, Typefox, and others support an initiative so strongly from its earliest days, you get a sense of just how important it is considered to be. Every one of our founders is a respected leader in their space, and we have a mix of large corporations and smaller companies, which is always great to see.

Unstoppable Momentum

I want to thank everyone who has helped us create and launch the ECD Tools Working Group. With the incredible groundswell of interest, engagement, and participation we’re seeing from both world-leading corporations and passionate developers, I truly believe we are standing on the doorstep of a very exciting open source future for cloud development tools. And, I have no doubt this community will continue to grow and thrive.

To learn more about getting involved with the ECD Tools Working Group, view the Charter and ECD Tools Working Group Participation Agreement (WPGA), or email us at You can also join the ECD Tools mailing list and follow @ECDTools on Twitter.


by Mike Milinkovich at October 08, 2019 10:30 AM

Participate in the 2019 IoT Commercial Adoption Survey!

by Thabang Mashologu at October 07, 2019 06:26 PM

According to McKinsey, the Internet of Things (IoT) will have a total potential economic impact of up to $11.1 trillion a year by 2025. 

What are the leading industrial IoT use cases that will contribute to that impact? You tell us!

The Eclipse IoT Working Group has launched the 2019 IoT Commercial Adoption Survey to help IoT ecosystem stakeholders get a better understanding of the IoT industry landscape and gain insights into the requirements, priorities, and challenges faced by organizations who are deploying and using commercial IoT solutions.

Take just a few minutes to complete the survey. Survey responses will be collected until November 29, 2019 and the results will be published in January. 

Thank you in advance for your participation!

Take the survey now!

by Thabang Mashologu at October 07, 2019 06:26 PM

Removing “Contact Us

by tevirselrahc at October 07, 2019 02:17 PM

Unfortunately, because of the larger amount of spam, I now have to remove off the “Contact Us” page.

If you want to contact us, I would recommend you go through our twitter account.

by tevirselrahc at October 07, 2019 02:17 PM

As a matter of factory, factories matter

by Donald Raab at October 07, 2019 03:08 AM

We create collections all the time in Java, so making it easy was a priority in Eclipse Collections.

Factories have plural names in Eclipse Collections

Facts about the Factories

I published three blogs on the factories available in Eclipse Collections. There are static factories for each type in Eclipse Collections for both object and primitive types. The following blogs have examples of mutable, immutable and method chaining factories.

Preposition Preference

Some developers prefer factory methods named “of”. Some developers prefer factory methods named “with”. Eclipse Collections provides support for both, except when it comes to method chaining, where “with” is the only option. Read the following blog to understand how symmetry helps validate that decision.

Preposition Preference

Code Examples

Here’s a Gist showing various examples of Object and Primitive factories in Eclipse Collections.

Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.

As a matter of factory, factories matter was originally published in Oracle Developers on Medium, where people are continuing the conversation by highlighting and responding to this story.

by Donald Raab at October 07, 2019 03:08 AM

JakartaOne Livestream Wrap up

by Tanja Obradovic at October 03, 2019 11:12 AM

September 10th, 2019 was a big day in the Jakarta EE global circles. Not just that we released the very first version of the Jakarta EE, but we also got very ambitious and organized the very first JakartaOne Livestream conference. What an experience that was!

The intention was to mark an important milestone, the release of the very first vendor neutral, Java EE 8 compatible release of Jakarta EE using the new Jakarta EE Specification Process. 

After almost two years since the Oracle announcement of Java EE contribution to Eclipse Foundation on September 10th, we’ll finally have the base level release that will enable existing products certified on Java EE 8 to move easily and seamlessly Jakarta EE 8 release. The release is a result of cross-community collaboration at the Eclipse Foundation, it has the same Java EE 8 APIs using the javax namespace, its Jakarta EE 8 TCKs are fully compatible with Java EE 8 TCKs, and new compatibility/branding process is available for compatible products.

It was very obvious from the beginning that this may be bigger than we expected, here is why. We have approached a few well-respected leaders in Java EE community to help out and be on the JakartaOne Livestream Program Committee. What a thrill that was! Reza Rahman graciously accepted to be the Program Committee Chair, and the rest of the members of the committee were equally eager and interested to help out: Josh Juneau, Ivar Grimstad, Adam Bien, Arun Gupta and from the Eclipse Foundation - Tanja Obradovic. It was a great pleasure working with this team. 

We started the work on the conference in early June, and with all members having busy schedules and summer vacations, we made most of the time we had: made a plan and put out CFP for the conference. The response was another indicator that there is an interest in the wider community for something like this. We got well over 50 talk submissions of a great quality and we had a difficult task selecting the best. We had a great mixture of introductory / overview talks, specification specific talks, cloud native focused talks, keynotes from Mike Milinkovich and James Gosling, as well as industry keynotes from Jakarta EE Working Group Steering Committee members: Tomitribe, IBM, Fujitsu, Oracle, Payara, Red Hat, demos and panel discussions. We selected 16 talks, which meant 18 hours of the program with keynotes and panel discussions. Adam Bien accepted to be MC of the event and I would be available to help out. In the end, the Program Committee chose the following collection of talks and a reminder that the talks themselves can still be viewed via

You may call it beginner's luck, but on the day of the event, we had well over 1350 registered attendees, with a number of questions that were almost immediately answered on the chat by someone from the community. The level of positivity and the sense of the community coming together was overwhelming, illustrating the true power of the open source. With very few technical difficulties, talks were going one after another and even when we had issues Reza Rahman yet again was available to save the day with an additional Q&A session.


And to leave the best for last - in terms of running the event, the work done by my colleagues of the Eclipse Foundation staff, was impressive. I could not ask for better help than working with Stephanie Swart, Laura Tran and Shabnam Mayel, as well as the great effort by all our marketing and web teams ahead of the event. The level of dedication, professionalism and readiness to improvise in order to deal with issues presented, was amazing. And did I mention for all four of us this was the very first conference we worked on! Let’s take a deep breath, enjoy the success for another moment before we start working on the next Jakarta EE release.

by Tanja Obradovic at October 03, 2019 11:12 AM

Instanceof Type Guards in N4JS

by n4js dev ( at September 30, 2019 08:06 AM

Statically typed languages like Java use instanceof checks to determine the type of an object at runtime. After a successful check, a type cast needs to be done explicitly in most of those languages. In this post we present how N4JS introduced type guards to perform these type casts implicitly. 

No error due to implicit cast in successful instanceof type guard

The example above shows that strict type rules on the any instance a causes errors to show up when accessing the unknown property pX. However, after asserting that a is an instance of X, the property pX can be accessed without errors. A separate type cast is unnecessary, since type inference now also considers instanceof type guard information.

Hover information on variable access of a shows the inferred type

The resulting type is the intersection type of the original type (which is here any) and of all type guards that must hold on a specific variable access (which is here only type X). Keeping the original types any or Object is not necessary and could be optimised later. In case the original type is different, it is necessary to include it in the resulting intersection type. The reason is that the type guard could check for an interface only. If so, property accesses to properties of the original types would cause errors.

Re-definition of a type guarded variable

Two distinct differences between type guards and type declarations are (1) their data flow nature and (2) their read-only effects. Firstly, when redefining (in the sense of the data flow) a variable, the type guard information gets lost. Consequently, subsequent accesses to the variable will no longer benefit from the type guard, since the type guard was invalidated by the re-definition. Secondly, only the original type information is considered for a redefinition. That means that the type guard does not change the expected type and, hence, does not limit the set of types that can be assigned to a type guarded variable.

Further examples for instanceof type guards in N4JS

Data flow analysis is essential for type guards and has been presented in a previous post. Based upon this information, type information for each variable access is computed. Since also complicated data flows are handled correctly, such as in for loops or short circuit evaluation, type guard information is already available in composed condition expressions (see function f3 and f5 above). Aside from being able to nest instanceof type guards (see function f4 above), they also can be used as a filter at the beginning of a function (see function f6 above) or inside a loop: Negating a type guard and then exiting the function or block leaves helpful valid type guard information on all the remaining control flow paths.

by Marcus Mews

by n4js dev ( at September 30, 2019 08:06 AM

Team Sports for Developers! Edge Computing Mini-Hackathon

by Anonymous at September 26, 2019 09:21 PM

Do you like to build gadgets and/or hack? Then get a team together for the Edge Computing Mini-Hackathon, organized by Edgeworx.

Teams will be challenged to integrate at least one other Eclipse IoT project with Eclipse ioFog and showcase what they were able to accomplish. Representatives from all Eclipse projects are welcome to come help guide, coach, and influence participants to make use of their projects. There will be prizes for the standouts, plus giveaways (and fun) for all!

The event is part of Community Night on Tuesday, October 22, from 19:30 - 22:00 in the Theater Stage room at the Forum.

by Anonymous at September 26, 2019 09:21 PM

How Does Eclipse Dirigible Contribute to Eclipse Che 7?

by Dragomir Anachkov at September 25, 2019 12:00 AM

Eclipse Che unites a wide range of different frameworks, programming languages, and development tools, and helps developers design and create next-level services on the Cloud. Eclipse Che provides you with a default Web IDE. However, Eclipse Che also allows you to plug in other IDEs, because the default IDE may not be able to cover your use case.

For example, we work on Eclipse Dirigible – an open-source cloud development platform that comes with its own Web IDE. You can directly integrate the Eclipse Dirigible Web IDE in Eclipse Che. This means that you can create a workspace in Eclipse Chе using the Eclipse Dirigible Web IDE instead of the default Eclipse Theia IDE.


What is so cool about that?

Developers can run Eclipse Dirigible on whatever platform Eclipse Che 7 is deployed. The most notable example is the OpenShift platform offered by Red Hat. That way, the Eclipse Dirigible portfolio of services and features for business application development becomes available to the entire Che community.

What does Eclipse Dirigible have to offer?

Now, let us take a look at what this portfolio currently consists of. Eclipse Dirigible puts an emphasis on low-code/no-code tools for developing business applications. As of version 3.4, Eclipse Dirigible provides the following tools:

Why use JavaScript as a business application language?

At Dirigible, we have decided to focus on JavaScript, because it has a small learning curve, and it is a well-known programming language that has proven itself in the context of web development throughout the years.

For business application development, which is our case, JavaScript is just a tool, which lets you consume the standardized set of Enterprise APIs that we provide. Additionally, Dirigible allows you to set the default server-side JavaScript execution as synchronous, so you could develop your service in a callback-free way. For example, some of the most popular Enterprise APIs that you can use are:

Are there any alternatives to Eclipse Dirigible?

There are alternatives to Eclipse Dirigible and these are platforms such as Mendix and by Salesforce. However, you have to purchase the corresponding licenses to start using them.

In the open-source world though, there are no alternatives to this day. There are other open-source platforms such as Eclipse Theia and Jupyter, but they are not competing directly with Eclipse Dirigible, because they specialize in other areas. For example, Eclipse Theia focuses on general-purpose code editing using the VSCode platform while Jupyter, on the other hand, is the right choice when it comes to big data analysis and data mining.

However, none of these platforms provide what Eclipse Dirigible has to offer in terms of low-code/no-code tools for developing business applications. At least for now.


Thanks to the great collaboration with the Eclipse Che team, Eclipse Dirigible is on the right way of achieving its ultimate goal, which is to provide developers of business applications with the fastest turnaround time in the Cloud and a unique user experience at the same time.

So why don’t you give it a try?

If there is something that you don’t like, or you think it can be improved, don’t hesitate to share your feedback. The Eclipse Dirigible team will definitely appreciate it. That is one of the best things about the open-source community that we are all part of!


How to Run Eclipse Dirigible on Eclipse Che 7

by Dragomir Anachkov at September 25, 2019 12:00 AM

Blocked by an Eclipse Wizard?

by Wim at September 24, 2019 08:53 AM

Tuesday, September 24, 2019
There is a small but very useful patch in Eclipse 4.12 for people that do not want the UI to be blocked by wizards. There are many cases where it is desired that the underlying window can be reached WHILE the user is finishing the wizard. That's why it's strange that the Eclipse Wizard demands from us to always have full and utter attention.

Read more

by Wim at September 24, 2019 08:53 AM

How to Render a (Hierarchical) Tree in Asciidoctor

by Niko Stotz at September 21, 2019 03:16 PM

Showing a hierarchical tree, like a file system directory tree, in Asciidoctor is surprisingly hard. We use PlantUML to render the tree on all common platforms.

Example of rendered hierarchical tree

This tree is rendered from the following code:

[plantuml, format=svg, opts="inline"]
skinparam Legend {
    BackgroundColor transparent
    BorderColor transparent
    FontName "Noto Serif", "DejaVu Serif", serif
    FontSize 17
|_ Element 1
  |_ Element 1.1
  |_ Element 1.2
|_ Element 2
  |_ Element 2.1
end legend

It works on all Asciidoctor implementations that support asciidoctor-diagram and renders well in both HTML and PDF. Readers can select the text (i.e. it’s not an image), and we don’t need to ship additional files.

We might want to externalize the boilerplate:

[plantuml, format=svg, opts="inline"]
!include asciidoctor-style.iuml
|_ Element 1
  |_ Element 1.1
  |_ Element 1.2
|_ Element 2
  |_ Element 2.1
end legend
skinparam Legend {
    BackgroundColor transparent
    BorderColor transparent
    FontName "Noto Serif", "DejaVu Serif", serif
    FontSize 17

Thanks to PlantUML’s impressive reaction time, we soon won’t even need Graphviz installed.

Please find all details in the example repository and example HTML / example PDF rendering.

by Niko Stotz at September 21, 2019 03:16 PM

Let's Do It! Obeo loves The SeaCleaners

by Cédric Brun ( at September 20, 2019 12:00 AM

I am deeply convinced a company is not only an economical actor. It has a much wider responsibility as any decision also has social, environmental or even political implications.

Looking at our environment state, its recent evolution and how it is forecasted to evolve indeed the task in front of us is huge. It would be easy to dismiss this as a problem our governments and big organizations should step up to, and indeed those in power have the responsibility, the ability and leverage to act and maybe bend those charts.

But I have a motto to “Focus on what you can control, then you can act” and so do I.

Obeo participates and hosts quite a few events each year and we are often struck by the nonsensical nature of the “goodies” industry and what global model they promote: built at the cheapest price, moved across the globe, distributed at the event and then pretty quickly to the bin.

Starting now, you won’t get any more goodies from us at conferences or events, but instead we will gladly discuss how we try to do our part, as a company, in this global challenge.

In relation to this initiative to stop producing waste we do not deem necessary: Obeo is partnering with The SeaCleaners organization to reduce plastic waste. The SeaCleaners is building a giant multihull boat designed to retrieve the plastic waste in the Ocean: The MANTA. The organization vision is that the preservation of the oceans is a global, long-term and worldwide matter that integrates economic, social, human, educational and scientific perspectives. They do that in a dynamic and solidarity-based project. You can learn more about this initiative on Obeo’s website.

The "Manta"

Furthermore, all the designs and blueprints of the Manta boat will be Open-Source and that enable enhancements and duplication at a global scale, a principle clearly aligned with our values and what we do within the Eclipse community.

The "Manta" boat technical data

That being said, it is just one step on a very specific part of our activity, but a step starting a journey with more to do to improve the way Obeo operates regarding its environmental responsibility. When you start building awareness of our impact on all the ins and outs of what we do, you realize even a non-industrial, software company can contribute.

Let's Do It! Obeo loves The SeaCleaners was originally published by Cédric Brun at CEO @ Obeo on September 20, 2019.

by Cédric Brun ( at September 20, 2019 12:00 AM

WTP 3.15 Released!

September 19, 2019 02:14 PM

The Eclipse Web Tools Platform 3.15 has been released! Installation and updates can be performed using the Eclipse IDE 2019-09 Update Site or through the Eclipse Marketplace . Release 3.15 is included in the 2019-09 Eclipse IDE for Enterprise Java Developers , with selected portions also included in several other packages . Adopters can download the R3.15 build directly and combine it with the necessary dependencies.

More news

September 19, 2019 02:14 PM

Eclipse Che 7 Enables Faster, Safer Development on Kubernetes

by Mike Milinkovich at September 17, 2019 02:00 PM

A major version release within the Eclipse Foundation community always provides us a reason to celebrate, congratulate, and thank all those who participated and contributed to the process. The delivery today of Eclipse Che 7 is no exception. But Che 7’s arrival is more than great news for the Eclipse community, it’s also an industry game changer because it drastically reduces the learning and adoption curves of Kubernetes for enterprise application developers.

Che 7 is the result of more than six years of collaboration and community contributions, including more than 20 vendors. It’s the world’s first Kubernetes-native IDE that has been built from the ground up specifically to enable developers to build cloud native applications. Fundamentally, Che 7 makes the developer and production environments the same on a scalable, collaborative, and secure platform specifically designed for building containerized applications. That platform addresses the major challenges developers face when working with Kubernetes.

While Kubernetes does a fantastic job of operating applications at scale, it’s a complex system that most developers do not yet fully understand. With Che 7, the workspace configuration complexities and challenges developers face with Kubernetes have been eliminated. The platform can be deployed on a public Kubernetes cluster or an on-premises data center. Once deployed, it provides centrally hosted private developer workspaces that make projects easy to share and easy to manage, but with enterprise-grade security.

Che 7 takes care of the “Kubernetization” of the development environment and the applications that a developer is building. It comes with a pre-packaged web-based IDE, based on an extended version of Eclipse Theia to provide an in-browser Visual Studio Code experience. The fully integrated environment containerizes everything a developer needs to develop, build, run, test, and debug enterprise cloud native applications. This includes all of the tools and dependencies. This a big deal considering many enterprises cite a lack of integration of development tools and processes as a primary challenge of container adoption.

The introduction of Che 7 represents another milestone in enterprise-grade, cloud native tooling innovation from the Eclipse Foundation and our community. It continues the Eclipse Foundation track record of delivering innovative tools to the development community, most notably through the Eclipse desktop IDE. Che is already integral to cloud native solutions from our vendor community, including Google, IBM, and Broadcom. It also comprises the core of Red Hat CodeReady Workspaces, a new development environment for Red Hat OpenShift.

As we move forward, our community will continue to deliver more innovation through the Eclipse Cloud Development (ECD) Tools Working Group. In addition to Che, the ECD WG encompasses a broad portfolio of open source cloud development projects including Theia, Eclipse CodeWind, Eclipse Dirigible, Eclipse Sprotty, Eclipse Orion, and many more. The ECD WG will drive the evolution and adoption of de facto standards for cloud development tools, including language support, extensions, and developer workspace definitions.

Of course, Che 7 and the ECD WG are made possible by our development community. So, I thank all of those who have participated to date and encourage everyone to take part in the innovation process. To that end, we are actively recruiting members to the Eclipse Cloud Development Working group and we encourage and welcome new members.

Get started with Che 7 on any Kubernetes cluster at or learn more about getting started with Che at To get involved with the Che community and contribute to the project, visit:


by Mike Milinkovich at September 17, 2019 02:00 PM

Eclipse Foundation Proposes Vulnerability Assessment Tool

by Erik Costlow at September 14, 2019 05:12 AM

The Eclipse Foundation is evaluating a proposal to incorporate a Vulnerability Assessment Tool that would help identify libraries with known security issues. The possible result would help inform developers when their application faces a downstream risk from using vulnerable components.

By Erik Costlow

by Erik Costlow at September 14, 2019 05:12 AM

From building blocks to IoT solutions

by Jens Reimann at September 10, 2019 07:07 AM

Eclipse IoT

The Eclipse IoT ecosystem consists of around 40 different projects, ranging from embedded devices, to IoT gateways and up to cloud scale solutions. Many of those projects stand alone as “building blocks”, rather than ready to run solutions. And there is a good reason for that: you can take these building blocks, and incorporate them into your own solution, rather than adopting a complete, pre-built solution.

This approach however comes with a downside. Most people will understand the purpose of building blocks, like “Paho” (an MQTT protocol library) and “Milo” (an OPC UA protocol library) and can easily integrate them into their solution. But on the cloud side of things, building blocks become much more complex to integrate, and harder to understand.

Of course, the “getting started” experience is extremely important. You can simply download an Eclipse IDE package, tailored towards your context (Java, Modelling, Rust, …), and are up and running within minutes. We don’t want you to design your deployment descriptors first, and then let you figure out how to start up your distributed cluster. Otherwise “getting started” will become a week long task. And a rather frustrating one.

Getting started. Quickly!

Eclipse IoT building blocks

During the Eclipse IoT face-to-face meeting in Berlin, early this year, the Eclipse IoT working group discussed various ideas. How can we enable interested parties to get started, with as little effort as possible. And still, give you full control. Not only with a single component, which doesn’t provide much benefit on its own. But get you started with a complete solution, which solves actual IoT related problems.

The goal was simple. Take an IoT use case, which is easy to understand by IoT related people. And provide some form of deployment, which gets people up and running in less than 15 minutes. With as little as possible external requirements. At best, run everything on your local laptop. Still, create everything in a close-to-production style of deployment. Not something completely stripped down. But use a way of deployment, that you could actually use as a basis for extending it further.

Kubernetes & Helm

We quickly agreed on Kubernetes as the runtime platform, and Helm as the way to perform the actual deployments. With Kubernetes being available even on a local machine (using minikube on Linux, Windows and Mac) and being available, at the same time, in several enterprise ready environments, it seemed like an ideal choice. Helm charts seemed like an ideal choice as well. Helm designed directly for Kubernetes. And it also allows you to generate YAML files, from the Helm charts. So that the deployment only requires you to deploy a bunch of YAML files. Maintaining the charts, is still way easier than directly authoring YAML files.

Challenges, moving towards an IoT solution

A much tougher question was: how do we structure this, from a project perspective. During the meeting, it soon turned out, there would be two good initial candidates for “stacks” or “groups of projects”, which we would like to create.

It also turned out that we would need some “glue” components for a package like that. Even though it may only be a script here, or a “readme” file there. Some artifacts just don’t fit into either of those projects. And what about “in development” versions of the projects? How can you point people towards a stable deployment, only using a stable (released) group of projects, when scripts and readme’s are spread all over the place, in different branches.

A combination of “Hono, Ditto & Hawkbit” seemed like an ideal IoT solution to start with. People from various companies already work across those three projects, using them in combination for their own purpose. So, why not build on that?

But in addition to all those technical challenges, the governance of this effort is an aspect to consider. We did not want to exclude other Eclipse IoT projects, simply by starting out with “Hono, Ditto, and Hawkbit”. We only wanted to create “an” Eclipse IoT solution, and not “the” Eclipse IoT solution. The whole Eclipse IoT ecosystem is much too diverse, to force our initial idea on everyone else. So what if someone comes up with an additional group of Eclipse IoT projects? Or what if someone would like to add a new project to an existing deployment?

A home for everyone

Luckily, creating an Eclipse Foundation project solves all those issues. And the Eclipse Packaging project already proves that this approach works. We played with the idea, to create some kind of a “meta” project. Not a real project in the sense of having a huge code base. But more a project, which makes use of the Eclipse Foundations governance framework. Allowing multiple, even competing companies, to work upstream in a joint effort. And giving all the bits and pieces, which are specific to the integration of the projects, a dedicated home.

A home, not only for the package of “Hono, Ditto and Hawkbit”, but hopefully for other packages as well. If other projects would like to present their IoT solution, by combining multiple Eclipse IoT projects, this is their chance. You can easily become a contributor to this new project, and publish your scripts, documentation and walk-throughs, alongside the other packages.

Of course everything will be open source, licensed under the EPL. So go ahead and fork it, add your custom application on top of it. Or replace an existing component with something, you think is even better than what we put it. We want to enable you to deploy what we provide in a few minutes. Offer you an explanation, what to expect from it, and what this IoT solution can do for you. And encourage you to play around with it. And enable you to extend it, and build something bigger.

Let’s get started

EclipseCon Europe 2019

We created a new project proposal for the Eclipse IoT packages project. The project is currently in the community review phase. Once we pass the creation review, we will start publishing the content for the first package we have.

The Eclipse IoT working group will also meet at the IoT community day of EclipseCon Europe 2019. Our goal is to present an initial version of the initial package. Ready to run!

But even more important, we would like to continue our discussions around this effort. All contributions are welcome: code, documentation, additional packages … your ideas, thoughts, and feedback!

The post From building blocks to IoT solutions appeared first on ctron's blog.

by Jens Reimann at September 10, 2019 07:07 AM

Release 3.5

September 10, 2019 12:00 AM

New version 3.5 released.

Release of Type B


  • Select branch for Push
  • Select branch for Pull
  • Usage Statistics
  • Import an arbitrary file into a workspace folder
  • Generic support for Statusbar
  • Programmatic Custom Datasources Support
  • Destinations API v4
  • jsonpath and alphanumeric APIs v4


  • Reset perspective option in Dirigible
  • Validation of the Listener handler to be done on Start
  • Restart the Listener after modification
  • Require confirmation from user on deletion of files, folders or projects
  • Problem with setTimestamp, setTime and setDate of Statement
  • Response API println and print don’t work with UTF-8 characters
  • Security - Missing isInRole() method
  • Updating Date is not working on HANA database
  • Updating Boolean is not working on HANA database
  • Fiori theme fixes and improvements
  • Minor fixes


  • 4000+ Downloads
  • 10K+ Docker Pulls
  • 5.4K+ Trial Users
  • 59K+ Sessions
  • 179 Countries
  • 354 Repositories in DirigibleLabs



September 10, 2019 12:00 AM

The Rising Adoption of Capella

by Cédric Brun ( at September 04, 2019 12:00 AM

Witnessing an OSS technology getting together with a wide group of users is something I find exhilarating, I have experienced it with Acceleo, EMF Compare and Eclipse Sirius along the years, each time in different contexts and at different scales but discovering what is being done by others with a technology is always a source of excitement to me.

Capella was contributed by Thales to the Eclipse communities a few years ago already and fueled by the growing need to design Systems in a better way, by the interest in Model Based System Engineering and the qualities of the product in itself we can clearly see an acceleration in the last few months.

If you are wondering what is Capella and what it’s used for, here is a 2-minute video we prepared for you:

Worldwide awareness of this solution grows and adoption rises, organizations from Europe, North America and Asia are now using Capella and experiencing the benefits of using a tool which implements a method (coined “Arcadia”) and not only a language.

Capella Forum Activity

Looking at the numbers, just for this summer : more than 1200 downloads each month, a forum actvity which has been growing with a nice looking curve and monthly stats on YouTube reaching more than 2000 views: considering the size of the target audience this is a significant acceleration and that is without counting the deployment of System Modeling Workbench provided by Siemens which includes the technology.

Adopters not only use it but speak about it and as with any other tool having an opportunity to understanding how others are using it is highly valuable.

Rolls Royce, ArianeGroup or the Singapore University: they all have shared valuable information through the recent webinars :

More are coming and many already available through the Resources Page! BTW we can’t always get the authorization to keep them available online so your safest option is to register and attend.

Munich (Germany)

We also make sure to setup « in Real Life » opportunities to discuss Capella and MBSE. Occasions to talk with the team behind Capella and the experts arounds the world. Next up is Capella Day Munich 2019 in a couple of weeks (the 16th of September) organized by Thales and Obeo in conjunction with the Models Conference 2019. Here is a glimpse of the program :

The agenda is filled with general presentations, feedback by industrial users about their Capella deployment or specific add-ons/integration.

The program of Capella Day Munich 2019

You might want to hurry as we are almost sold out and such occasions are pretty unique!

I sincerely hope you’ll enjoy it, we are working hard to make it a success :-), if you can’t make it this time then know there are more occasions to come: AOSEC in Bangalore, EclipseCon in Germany (again!) where there might be a workshop focused on “MBSE at Eclipse” (Please add your name and interest on the corresponding wiki page )

The Rising Adoption of Capella was originally published by Cédric Brun at CEO @ Obeo on September 04, 2019.

by Cédric Brun ( at September 04, 2019 12:00 AM

Time for Change

by Doug Schaefer at September 03, 2019 02:56 PM

First, let me get straight to the point. I have left BlackBerry/QNX and will be starting a new job in Ottawa next week. It’s a great opportunity to work on something new for a great company with a bunch of former colleagues I admire. As much as I’m looking forward to that much needed change, it sadly will take me away from the Eclipse community. This message is a goodbye and thank you.

Thinking back all the way to the beginning, I’m quickly overwhelmed by how many great people I have had the opportunity to work with thanks to the Eclipse CDT project. At the very beginning was Sky Matthews and John Prokopenko who let me weasel my way on as Rational’s technical lead on the project just as it was starting out in 2002 also at a time when I needed a change. Of course, I had a great team of developers at Rational with me that made it fun and easy. Not to mention the original team at QNX who were welcoming and made it easy to get involved. I have a special mention for Sebastien Marineau, CDT’s first project lead, who let me take a leadership role on the project and eventually hired me on at QNX to take over.

Then there was the early years on the CDT where we made our mark. Those early CDT Summits were so fun and really helped built up a team atmosphere. We had about a dozen companies sending contributors, a few of them competitors in the spirit of co-opetition, and we made it work. Then over the years we started getting independent contributors who just did it for the passion of building great C++ tooling they wanted to use themselves. It’s been a great mix and I am so lucky and proud to have been a part of it.

And of course, it was all topped off with our yearly EclipseCons. I am proud to have attended every one of the EclipseCon North America ones and was able to attend quite a few of the EclipseCon Europes in Germany. I have to thank Anne and Mike and Ralph and Wayne and Sharon and Perri and Donald and Ian and Lynn and all the Eclipse Foundation staff past and present for making me feel a part of the family. I always looked forward to the EclipseCon Express flights out of and return to Ottawa with many of them.

My fellow attendees at these conferences were amazing, from the first one at Disneyland where we had an overflow crowd at the CDT BOF and where I gave my first of many CDT talks, to all the friends I met at the bar or ran into at sessions, many of whom had nothing to do with CDT but made me feel so much a part of the bigger community. I will never forget the late nights in the bars chatting with friends like Michael Scharf and Ian Bull and Eric Cloninger and Gilles and Adrian and Jonah and Tom and so many others. As it turns out, last year in Ludwigsburg was a perfect finale where we had such a great time at the Nestor on Wednesday night. I will never forget you all.

I’m incredibly proud of what we built for the CDT. It still has the best indexer in the business, thanks to the parser we built back at Rational and the database I built at QNX and then with so many hands continually making it better and adjusting to the now ever changing C++ language spec. The Launch Bar achieved what I wanted by simplifying the Eclipse launch experience. CDT’s new Core Build fits naturally with the Launch Bar and makes it much simpler to integrate external build systems like CMake. And we have just started a GDB debug adapter using the debug adapter protocol which will pave the way to simplify integrating debuggers with the CDT.

The current set of active committers on the CDT have lately been pulling almost all the weight evolving it and getting releases out the door. Their great work has made my transition easier and will keep the CDT rolling along for years to come. And hopefully vendors will come back too and help provide funding for all this activity. We have an action plan to transition the project lead role. Follow the cdt-dev mailing list to find out more.

It’s sad to leave and the memories and friendships will be forever. I will keep my cdtdoug personal gmail account as a reminder of where I came from. But my new role will give me some much needed energy to keep things going for the next decade. I once questioned why you hardly see any retired engineers helping with open source projects or sharing their passion with the next generation. I promise you this, you will see me again.

Take care, and thank you.

by Doug Schaefer at September 03, 2019 02:56 PM

Xtext 2.19 Release – builds on Eclipse’s new infrastructure JIRO

by Karsten Thoms ( at September 03, 2019 07:27 AM

The Xtext team has released version 2.19.0 of Eclipse Xtext & Xtend. The current version is mainly a maintenance release. After working hard on some new features in the past releases, it was time for summer vacation during the current release period and for some focus on build engineering tasks. Still over 350 pull requests made it into the short release period.


Eclipse’s new build infrastructure JIRO

The Eclipse Foundation’s build engineers worked on a new build infrastructure called JIRO (Jenkins Instances Running on OpenShift). The Xtext project joined early the efforts on preparing a migration to the new infrastructure. However, now it was time and the Eclipse Foundation asked to finally shut down the old build server and to switch over to the new infrastructure. While we were already done with the main build jobs, there were still quite some supportive build jobs for release engineering that had to be migrated.

Luckily, the itemis Xtext team could acquire Nico Prediger from the itemis DevOps staff to support the efforts on build engineering tasks. With his support, we could finalize the work and finally replace the old Jenkins instance.

As a result, Xtext builds fine now on its new JIRO instance at and was released the first time on the new infra.

Keeping the software stack up-to-date

Xtext builds upon a quite huge software stack, and several components are released within each release period. We try to keep them all on the latest state as far as we can. Of course, for each used component we have to test the compatibility of each upgrade.

The most notable upgrades this time are Guava and Gradle:

The Guava version 21.0 that we used before had a security problem that was issued as CVE-2018-10237. This forced Xtext as well as other dependent Eclipse projects to upgrade to a recent version of Guava. For the Eclipse 2019-09 simultaneous release, the delivered Guava version is now 27.1.0. All builds descriptors, wizards, and projects have been updated to use Guava 27.1.0 now.

The Guava upgrade also affected the MWE project, which employed the upgrade with its recent release. As a consequence, Xtext upgraded to MWE 2.11.

Xtext has been updated to use Gradle 5.5 now. While Gradle 6 is not official yet, Xtext has already been prepared for it. We closely followed the planned changes and revisited all relevant sources to ensure compatibility with Gradle’s next major versions. We expect that Xtext finally upgrades to Gradle 6 shortly after its release.


With the rise of the Language Server Protocol (LSP) integration of Xtext-based languages into other IDEs and editors, it is often preferred to work through language servers. Xtext is integrating the latest LSP4J version 0.8.0 und thus the current status of the LSP.

When it comes to language support in web-based editors, Xtext offers a second approach called Xtext Web. The software components that Xtext Web is based on have been upgraded to their latest state. Also, the examples have been polished again with this version.

To get a better feeling, we have put the Xtext Web examples online now, so you don’t have to download and build them locally. Try the Xtext Web integration with the various supported editors Ace, CodeMirror, and Orion here:

What’s your wish for future Xtext versions?

We will continue to implement exciting features and ensure that Xtext will be compatible with the latest and greatest of all that we use. While we focus the development on the needs of our customers, you may have ideas how to make Xtext even better. Please tell us! We won’t bite you (and we can’t do this through the wire anyway)!

by Karsten Thoms ( at September 03, 2019 07:27 AM

OSGi Remote Services with Apache Dubbo

by Scott Lewis ( at August 31, 2019 05:37 PM

ECF's implementation of OSGi R7 Remote Services allows for replacing the underlying distribution system (repsonsible for the object serialization, transport, and other things). 

This makes it relatively easy to replace one kind of distribution (e.g. Jersey, ActiveMQ) with other/new distribution systems. 

Apache Dubbo has recently been contributed to Apache, and we've created a distribution provider based upon Apache Dubbo.

Here's a list of open ECF Remote Service distribution providers.   If you would like Remote Services support for a particular transport, or you've created your own distribution (or discovery) based upon some other transport and wish to make it available to others please let us know.

by Scott Lewis ( at August 31, 2019 05:37 PM

Eclipse Module on F30 Addendum

by Mat Booth at August 30, 2019 11:30 AM

Additional information about installing the Eclipse IDE module on F30.

by Mat Booth at August 30, 2019 11:30 AM

Redux App Development and Testing in N4JS (Chess Game Part 2)

by n4js dev ( at August 29, 2019 04:04 PM

In large applications, Redux - an implementation of Flux architecture created by Facebook - is often used to organise application code by using a strict data flow in one direction only. Redux is UI agnostic, and can be used in conjunction with any UI library. As a continuation of our chess game tutorial with React, we show how to extract the entire program state out of React components, store it with Redux, and test it with N4JS. The full tutorial is available at and the sources can be found at

The first part of the chess game tutorial discussed how to develop a chess game app with React and JSX in N4JS. We have stored the program state - which for instance contains information about the locations of all chess pieces - in the state of the React components directly. As applications become larger, however, the mix of program state and UI makes the application hard to comprehend and difficult to test. To address these issues, we extract the program state from the UI components in the second part of the tutorial.

When using React with Redux, we store the application state in Redux store instead of the state of React components. As a result, React components become stateless UI elements and simply render the UI using the data retrieved from the Redux store. In a Redux architecture, data flows strictly in one direction. The diagram below graphically depicts the action/data flow in a React/Redux app.

Strict data flow of flux architecture application

The action/data flow in the diagram can be roughly understood as follows:
  • When a user interaction is triggered on the React component (e.g. button clicked, text field edited etc.), an action is created. The action describes the changes needed to be updated in the application state. For instance, when a text field is edited, the action created may contain the new string of the text field.
  • Then the action is dispatched to the Redux store whereby the Redux store stores the application state, usually as a hierarchical tree of state.
  • The reducers take the action and the current application state and create an updated application state.
  • If the changes in the application state are to a certain React component, they are forwarded into the component in form of props. The change in props causes the component to re-render.

In the second part of the tutorial we further elaborate on the interaction of React and Redux and migrate the original chess non-Redux app. The tutorial explains the role of the reducer, and how the game state is stored and maintained in the Redux store. Based on storing the game using Redux, the tutorial shows how to test the game application with the N4JS test library Mangelhaft, by for instance checking that valid move destination squares are updated after a chess piece was selected.

Note that the way of testing the game logics is completely UI-agnostic and no React components are involved at all. This is thanks to the decoupling of game logics from UI with the help of Redux.

by Minh Quang Tran

by n4js dev ( at August 29, 2019 04:04 PM

And Now for Something Completely Different

by Ed Merks ( at August 29, 2019 09:23 AM

It's been 5 years since I last blogged, so I had to delete 500 SPAM posts when getting started again.  Much has happened over the past years, some of them not so great. When you start to get old like me, you must deal with the older generation gradually passing on and health problems, such as coronary re-plumbing, can become an ugly fact of life.

I've been working with itemis for the past 11 years, but that now draws to a close.  I wish to thank them for their generous support over all these years.  Many of you might thank them as well because much of what I've contributed is thanks to their funding.  Though admittedly I have the nasty habit of working like a maniac, beyond any reasonable number of working hours, regardless of whether or not there is financial reward.  Cool things are just so compelling. But the worst habit then is not bothering to document or advertise all these cool new features as they become available, but rather to dive into the next obsession because somehow that's more compelling.  Compulsion is a bit of a Merks' family trait, e.g., my sister has more than 20 dogs, though it's easy to lose count...

In any case, most of my obsession over the last year has been related to working with Airbus.  I don't normally talk about my customers, but given they were gracious enough to allow me to demo at last year's EclipseCon the software being developed at Airbus, it's common knowledge anyway.  My goodness but that was a creative and cool project! Unfortunately that too has, as is the case for all good things, come to an end.

I immediately dove into generating a quality report for the Eclipse SimRel p2 repository; there's no rest for the wicked nor for the compelled.  I used EMF's Java Emitter Templates (JET) for implementing that, just as I did for generating the full site information for  EMF's Update Sites  as part of migrating the build to Maven/Tycho.

Speaking of which, did you know that you can make it trivially easy for your contributors to set up a development environment? Just have a look at EMF' build page.  Also, did you know that there exists such a thing for the complete Eclipse Platform SDK as well? Of course not, because I never bothered to tell you!

What's really supergeil (yes, I live in Germany and speak fluent Denglish) about the installing an environment with the full Platform SDK, or some subset there of, is that you can easily see all the Git history of each source file, so you can see what exactly has changed and evolved.  Also, when developing new applications, you can easily search for how the Platform implements those things; then you can snarf and barf out your own solutions, with all due respect for the EPL of course.  You can even find out all the places that a constant is actually used; you cannot do that against binaries because constants get in-lined.  Also, if you see some label in the IDE, you can search for where it comes from, some *.properties file somewhere no doubt, and then you will know the name of that property and can easily find where that's defined and how that's used in the code.  You might even contribute fixes via Gerrit commits!

But I digress.  I was using JET to generate a nice helpful web page with information about all the problems in the SimRel repo, or in any arbitrary repo actually, i.e., invalid licenses, unsigned content, missing pack200 files, duplicate bundles, inappropriate providers, and so on. But then I got frustrated that JET templates eventually get really hard to read, especially as they become more complicated.  Then, when you need it the most, all the nice features of JDT are missing while editing the scriplets and expressions in that template. So as I am wont to do, I digressed further and spent the better part of the last two months working on a rich editor for JET.  I'm sorry (not!) that I had to violate a few API rules to do so, but alas, API rights activists is a topic for another blog because that's a long digression.  The good thing is that the JET editor is finished now; it will be in 2019-09's M3.  Here's a sneak preview:

Yes, that's content assist, just is if were in a real Java editor! Not only that, this time I wrote documentation for it in EMF's doc bundle. And, to top that off with icing, this time I blog about it.  Perhaps only three people in the world will ever use it, but I am one of those three people and I love it and I need it even for working with EMF's code generation templates too. So now I can pop this off my digression stack and go back to generating that p2 repo quality report.  I've been doing that for the past week, and it's almost ready for prime-time.

But then at this point, I must ask myself, where is the financial gain in all this?  My local neighborhood fox, I've named him Fergus,  might be trying to tell me something.

Perhaps you should be a little more sly.  Perhaps the endless free goodness too must come to an end...

by Ed Merks ( at August 29, 2019 09:23 AM

Eclipse is Now a Module on Fedora 30

by Mat Booth at August 21, 2019 01:30 PM

How to install the Eclipse IDE module on Fedora 30!

by Mat Booth at August 21, 2019 01:30 PM

GSoC 2019 Summary: Dart support for the Eclipse IDE

August 19, 2019 12:00 AM

Summary of my Summer of Code 2019

This post is a summary of my Summer of Code 2019. My project was to bring Dart development support to the Eclipse IDE. To do so I created a plugin that consumes the Dart analysis server using LSP4E. It also provides syntax highlighting using TM4E and many more features listed below.


The following list showcases the most significant features of the plugin I (and other contributors) added during GSoC 2019.

  • Running Dart programs directly from Eclipse - eclipse/dartboard#1

    • Standard & error output in a dedicated console
    • Support for multiple Launch configurations
    • Running single files from the context menu
  • Dart preference page - eclipse/dartboard#10

    • Set the location for the Dart SDK that should be used for all actions
    • Choose whether to automatically synchronize the dependencies of project
  • First class Pub support - eclipse/dartboard#107

    • Automatic synchronization of Pub dependencies when changing the pubspec.yaml file
    • Shortcut for running $ pub get manually
  • Creating new Dart projects and files - eclipse/dartboard#115

    • Stagehand templates are also supported
  • Usage of the Dart logo - eclipse/dartboard@a23fc1f

  • Import existing Dart projects directly into the workspace (+ automatic dependency synchronization) - eclipse/dartboard#116

Upstream Bug Fixes

During development I encountered many issues with the libraries and tools I was using. As I was already aware I took the time to fix them directly and provide a patch or PR for the corresponding library.

Things Left to do

I have completed all of my goals I set in the initial proposal for GSoC. However a few things and features have come up during development that I plan on taking care of in the near future.

  • Flutter support - Flutter apps need to be run using the special $ flutter command suite, instead of the default SDK

Other things that could be enhanced include:

  • Pub console - Currently there is now way to see the output of the pub commands
  • Webdev support - Dart apps that should be run on the browser need to be run using the $ webdev command line tools

I hope to be able to work on them but community contributions are always welcome.

A full list of commits and issues can be found on the project's GitHub repository. Installation instructions can also be found there.


In the early days, Lakshminarayana Nekkanti has joined the project as a committer. He has been extremely helpful since by fixing bugs in the Eclipse platform that have been open for years (Bug 513034) and contributing a lot of features and knowledge to the plugin. Thank you, Lakshminarayana!

I would also like to thank Lars Vogel who has been my Mentor and helped tremendously when I was unsure what to do.

August 19, 2019 12:00 AM

Dartboard: Pub support, Stagehand templates & better theming

August 03, 2019 12:00 AM

Automatic dependency synchronization, stagehand templates and theme improvements for TM4E.

Pub dependency synchronization is the main source of packages for Dart projects. Dependencies are added to a pubspec.yaml file and the $ pub get command is used to download the packages from the registry. Since most projects require at least a few dependencies this step must be taken before the project compiles without errors.

To ease this process a little, the command is now automatically run when saving the pubspec.yaml file in Eclipse. With this, required dependencies are automatically downloaded when a project is imported or when a new package is added to the pubspec.yaml file.

If you don't want this behavior the feature can be disabled from the preference page. Manually running the synchronization is also supported from the context menu of a project.

Pub context handler

The current progress of the synchronization is reported to the Progress view.

Pub progress


Stagehand is a CLI tool, written in Dart, that generates new projects from a list of templates. There are different project types to chose from, like Flutter, AngularDart or just console applications. After a template is generated the project contains a pubspec.yaml file containing all necessary dependency information and various entry files that are required by the type of project.

This tool is now supported graphically by the New Dart Project wizard also provided by Dartboard. Under the hood the plugin uses the exact executable from And by automatically updating it we make sure that new templates can be immediately used.

This is how the New Dart Project wizard looks now: Stagehand

At first selection of the Wizard (after a fresh IDE start) Stagehand is updated and its templates are fetched. After that job is finished the available templates are added to the combo box. If no template should be used the Use Stagehand template checkbox can be unchecked and an empty project is generated.

Subsequent usages of the wizard use cached versions of the templates list to not strain your network or the registry too much.

Project import

Not every Dart project was created from Eclipse though. So to be able to use Dartboard with existing Dart projects it is required to import them into the workspace. For this task we now provide a shortcut to import Dart projects from the Import Project context menu entry.

Currently it simply opens the Projects from Folder or Archive wizard. This wizard however allows to specify a ProjectConfigurator that takes care of selecting folders that should be imported as a project. In our own configurator we traverse all children and look for pubspec.yaml files. Every folder that contains such a file is considered to be a separate project.

Eclipse light theme for TM4E

TM4E can be used to apply different syntax highlighting to the editor. We provide a configuration file that specifies how certain words inside the editor should look. It also gives the option to select what theme to use. There are different light and dark themes available, like Solarized Light or the classic Eclipse Java editor theme.

I provided a patch to add some missing styles to the latter to make it look more like the classic theme. This is what it looks like now: Eclipse light theme

See eclipse/tm4e#215.

Wrap up

With two weeks to go until the end of Summer of Code 2019 there is not that much left to do for me to fulfill my proposed timeline. One major thing that is still missing are automated tests. I have started work on it now and will work on that for the last two weeks.

This will also be my last update post on Summer of Code as the next post will be a summary of my whole summer.

August 03, 2019 12:00 AM

KubeCon Shanghai 2019: Cloud Native at China Scale

by Chris Aniszczyk at July 29, 2019 04:08 PM

Last month, we held KubeCon + Cloud NativeCon in Shanghai, one of the largest open source events in China. Recently, we published the conference transparency report detailing how the 3500 person event went but I’d like to share a couple take aways as someone who has been traveling to China quite a bit the last few years.

Cloud Native at China Scale

The scale of operating a popular service in China can be wild when you serve a billion users. This forces many of these companies to operate in a cloud native fashion, similar to their internet scale peers in Silicon Valley. I strongly believe we will see more interesting open source technology born in China over the next decade as they deal with scaling issues, similar to how a lot of internet scale open source technology was born from Google and other SV companies that had to support a larger user base. I highly recommend this great interview from Kevin Xu highlights some of the scale and open source projects coming out of China.

Also, Ant Financial joined CNCF as a Gold End User member, which is indicative of the trends of Chinese companies supporting open source they depend on and sharing the lessons they have learned. For those that aren’t aware, Ant Financial is the largest mobile payments company in the world (Alipay), running on Kubernetes and other CNCF projects. You can read their CNCF Case study here how they run on tens of thousands of Kubernetes nodes serving nearly a billion Alipay customers.

Giving Back: China: #2 contributor to Kubernetes

For those who aren’t aware, China is the second largest contributor to Kubernetes (and third to CNCF projects overall).


It’s always great to have consumers contribute code back as that’s one important way how open source is sustainable in the long run.

On the whole, it was a fantastic to spend time with our cloud native community in Shanghai and we look forward to coming back to China next year, stay tuned for details for KubeCon + CloudNativeCon 2020 China! For now, we look forward to seeing many folks at KubeCon + CloudNativeCon 2019 San Diego which is gearing to be one of the largest open source events in the world.

by Chris Aniszczyk at July 29, 2019 04:08 PM

Pimping the status line

by Andrey Loskutov ( at July 28, 2019 04:50 PM

This weekend I've tried to write a test for Eclipse debug hover, that required to know exact position of the selected text, somewhere in the middle of the editor. If you think this is easy - go figure out in Eclipse at which offset is your cursor - surprisingly there is no obvious way to do so!

So I've used some 3rd party editor that was kind enough to provide this information in the status line. Why shouldn't this be offered by Eclipse itself?

So I've created an enhancement request and pushed patch that adds both features to Eclipse. By default, status line shows now cursor position, and if editor has something selected, the number of characters in the selection (works also in block selection mode). Both new additions to the status line can be disabled via preferences.

 If there is no selection, cursor offset is shown:

Both new additions to the status line can be disabled via preferences:

by Andrey Loskutov ( at July 28, 2019 04:50 PM

Incompatible Eclipse workspaces

by Andrey Loskutov ( at July 28, 2019 04:35 PM

Eclipse has mechanism to recognize if the workspace to be used is created with older Eclipse version.
In such case, to be safe, Eclipse shows dialog like:

As of today (Eclipse 4.12 M1), if you click on "Cancel" button, Eclipse will behave differently, depending on the use cases "history":

A. If the workbench was not started yet:

  1. If Eclipse was started without "-data" argument and user selects incompatible workspace, Eclipse will show "Older Workspace Version" dialog above and by clicking on "Cancel" it will offer workspace selection dialog.
  2. If Eclipse was started with "-data" argument pointing to the incompatible workspace, Eclipse will show "Older Workspace Version" dialog above and by clicking on "Cancel" it will terminate (instead of offering to select another workspace).

B. If the workbench was started:

  1. If user selects compatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts fine.
  2. If user selects incompatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts, shows the "Older Workspace Version" dialog above and by clicking on "Cancel" it will terminate (instead of offering to select another workspace).
This behavior is inconvenient (at least), so we have bug 538830.

Fix Proposal #1

The proposal is, that independently on the way Eclipse was started, if user clicks on the "Cancel" button in the "Older Workspace Version" dialog, we always show the default workspace selection dialog (instead of termination):

In this dialog above user has two choices: launch any workspace or finally terminate Eclipse via "Cancel".

Proposal #1 Matrix

A1. If the workbench was not started yet:

  1. If Eclipse was started with or without "-data" argument and user selects incompatible workspace, Eclipse will show "Older Workspace Version" dialog above and by clicking on "Cancel" it will offer workspace selection dialog. To terminate Eclipse, user has to click "Cancel" in the workspace selection dialog.

B1. If the workbench was started:

  1. If user selects compatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts fine.
  2. If user selects incompatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts, shows the "Older Workspace Version" dialog above and by clicking on "Cancel" it will offer to select another workspace.

Fix Proposal #2

The proposal is, that depending on the way Eclipse was started, if user clicks on the "Cancel" button in the "Older Workspace Version" dialog, we may or may not show the default workspace selection dialog. So what happens after "Older Workspace Version" dialog is shown is not predictable by just looking on this dialog - it depends on the history of this dialog.

Proposal #2 Matrix

A2. If the workbench was not started yet:

  1. If Eclipse was started without "-data" argument and user selects incompatible workspace, Eclipse will show "Older Workspace Version" dialog above and by clicking on "Cancel" it will offer workspace selection dialog.
  2. If Eclipse was started with "-data" argument pointing to the incompatible workspace, Eclipse will show "Older Workspace Version" dialog above and by clicking on "Cancel" it will terminate (instead of offering to select another workspace).

B2. If the workbench was started:

  1. If user selects compatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts fine.
  2. If user selects incompatible workspace in the "File -> Switch Workspace" dialog, Eclipse restarts, shows the "Older Workspace Version" dialog above and by clicking on "Cancel" it will offer to select another workspace.


Both proposals fix second bullet in the use case B2.


We see that Proposal #1 has no second bullet for A1 case, and is always consistent in the way how UI behaves after clicking on "Cancel" in the "Older Workspace Version" dialog. Proposal #2 fixes only B2 use case, inconsistency in UI behavior for the second part of A1 use case remains.

Technical (biased) notes:

  1. Proposal #1 is implemented and the patch is available, along with the demo video. To test it live, one has to build Eclipse - but here I have SDK binaries with the patch applied. The patch is relatively simple and only affects Platform UI internal code.
  2. Proposal #2 is not implemented yet. I assume that this will require more work compared to the patch #1. We will need a new command line argument for Eclipse to differentiate between "I want you not to terminate even if incompatible -data is supplied because I'm calling you from UI" and "Please terminate if incompatible data is supplied because I'm calling you from the command line". A new command line argument for Eclipse means not just Platform UI internal change, but also requires changes in the Equinox and Help, and also means public interface change.

Question to the masses!

We want to know your opinion - which proposal should be implemented?

Please reply here or on the bug 538830.


This version was implemented and available in 4.13 M1:

by Andrey Loskutov ( at July 28, 2019 04:35 PM

Papyrus SysML 1.6 available from the Eclipse Marketplace.

by tevirselrahc at July 12, 2019 02:03 PM

I should have mentioned, yesterday, that Papyrus SysML 1.6 is available from the Eclipse market place at

by tevirselrahc at July 12, 2019 02:03 PM

Building UIs with EASE

by Christian Pontesegger ( at July 08, 2019 06:54 PM

You probably used EASE before to automate daily tasks in your IDE or to augment toolbars and menus with custom functionality. But so far scripts could not be used to build UIs. This changed with the recent contribution of the UI Builder module.

What it is all about
The UI Builder module allows to create views and dialogs by pure script code in your IDE. It is great for custom views that developers do not want to put into their products, for rapid prototyping and even for mocking.

The aim of EASE is to hide layout complexity as much as possible and provide a simple, yet flexible way to implement typical UI tasks.

Example 1: Input Form
We will start by creating a simple input form for address data.

loadModule("/System/UI Builder");
createView("Create Contact");

createLabel("First Name:");
var txtFirstName = createText();
createLabel("Last Name:");
var txtLastName = createText();
This snippet will create a dynamic view as shown below:
The renderer used will apply a GridLayout. By setting the columnCount to 2 we may simply add our elements without providing any additional layout information - a simple way to create basic layouts.

If needed EASE provides more control by providing layout information when creating components:

createView("Create Contact");
createLabel("First Name:", "1/1 >x");
var txtFirstName = createText("2-4/1 o!");
createLabel("Last Name:", "1/2 >x");
var txtLastName = createText("2-4/2 o!");
Creates the same view as above, but now with detailed layout information.
As an example "1/2 >x" means: first column, second row, horizontal align right, vertical align middle. A full documentation on the syntax is provided in the module documentation (Hover over the UI Builder module in the Modules Explorer view).

Now lets create a combo viewer to select a country for the address:
cmbCountry = createComboViewer(["Austria", "Germany", "India", "USA"])
Simple, isn't it?

So far we did not need to react on any of our UI elements. Next step is to create a button which needs some kind of callback action:
createButton("Save 1", 'print("you hit the save button")')
createButton("Save 2", saveAddress)

function saveAddress() {
print("This is the save method");
The first version of a button adds the callback code as string argument. When the button gets pressed, the callback code will be executed. You may call any script code that the engine is capable of interpreting.

The second version looks a bit cleaner, as it defines a function saveAddress() which is called on a button click. Note that we provide a function reference to createButton().

View the full example of this script on our script repository. In addition to some more layouting it also contains a working implementation of the save action to store addresses as JSON data files.

Interacting with SWT controls

The saveAddress() method needs to read data from the input fields of our form. This could be done using
var firstName = txtFirstName.getText();
Unfortunately SWT Controls can only be queried in the UI thread, while the script engine is executed in its own thread. To move code execution to the UI thread, the UI module provides a function executeUI(). By default this functionality is disabled as a bad script executed in the UI thread might stall your Eclipse IDE. To enable it you need to set a checkbox in Preferences/Scripting. The full call then looks like this:
var firstName = executeUI('txtFirstName.getText();');

Example 2: A viewer for our phone numbers

Now that we are able to create some sample data, we also need a viewer for our phone numbers. Say we are able to load all our addresses into an array, the only thing we need is a table viewer to visualize our entries. Following 2 lines will do the job:
var addresses = readAddresses();
var tableViewer = createTableViewer(addresses)
Where readAddresses() collects our *.address files and stores them into an array.

So the viewer works, however we need to define how our columns shall be rendered.
createViewerColumn(tableViewer, "Name", createLabelProvider("getProviderElement().firstName + ' ' + getProviderElement().lastName"))
createViewerColumn(tableViewer, "Phone", createLabelProvider("getProviderElement().phone"))
Whenever a callback needs a viewer element, getProviderElement() holds the actual element.
We are done! 3 lines of code for a TableViewer does not sound too bad, right? Again a full example is available on our script repository. It automatically loads *.address files from your workspace and displays them in the view.

Example 3: A workspace viewer

We had a TableViewer before, now lets try a TreeViewer. As a tree needs structure, we need to provide a callback to calculate child elements from a given parent:
var viewer = createTreeViewer(getWorkspace().getProjects(), getChildren);

function getChildren() {
if (getProviderElement() instanceof org.eclipse.core.resources.IContainer)
return getProviderElement().members();

return null;
So simple! The full example looks like this:
Example 4: Math function viewer

The last example demonstrates how to add a custom Control to a view.
For plotting we use the Charting module that is shipped with EASE. The source code should be pretty much self explanatory.

Some Tips & Tricks

  • Layouting is dynamic.
    Unlike the Java GridLayout you do not need to fill all cells of your layout. The EASE renderer takes care to automatically fill empty cells with placeholders
  • Elements can be replaced.
    If you use coordinates when creating controls, you may easily replace a given control by another one. This simplifies the process of layouting (eg if you experience with alignments) and even allows a view to dynamically change its components depending on some external data/events
  • Full control.
    While some methods from SWT do not have a corresponding script function, still all SWT calls may be used as the create* methods expose the underlying SWT instances.
  • Layout help.
    To simplify layouting use the showGrid() function. It displays cell borders that help you to see row/column borders.

by Christian Pontesegger ( at July 08, 2019 06:54 PM

Eclipse Milo 0.3, updated examples

by Jens Reimann at July 06, 2019 08:22 PM

A while back I wrote a blog post about OPC UA, using Milo and added a bunch of examples, in order to get you started. Time passed by and now Milo 0.3.x is released, with a changed API and so those examples no longer work. Not too much has changed, but the experience of running into compile errors isn’t a good one. Finally I found some time to update the examples.

This blog post will focus on the changes, compared to the old blog post. As the old blog post is still valid, I though it might make sense to keep it, and introduce the changes of Milo here. The examples repository however is updated to show the new APIs on the master branch.

Making contact

This is the first situation where you run into the changed API, getting the endpoints. Although the new code is not much different, the old will no longer work:

List<EndpointDescription> endpoints =

When you compare that to the old code, then you will notice that instead of an array, now a list is being used and the class name changed. Not too bad.

Also, the way you create a new client instance with Milo 0.3.x is a bit different now:

OpcUaClientConfigBuilder cfg = new OpcUaClientConfigBuilder();
cfg.setEndpoint(endpoints[0]); // please do better, and not only pick the first entry

OpcUaClient client = OpcUaClient.create(;

Using the static create method instead of the constructor allows for a bit more processing, before the class instance is actually created. Also may this new method throw an exception now. Handling this in an async way isn’t too hard when you are using Java 9+:

public static CompletableFuture<OpcUaClient> createClient(String uri) {
  return DiscoveryClient
    .getEndpoints(uri) // look up endpoints from remote
    .thenCompose(endpoints -> {
      try {
        return CompletableFuture.completedFuture(
            OpcUaClient.create(buildConfiguration(endpoints)) // "buildConfiguration" should pick an endpoint
      } catch (final UaException e) {
        return CompletableFuture.failedFuture(e);

That’s it? That’s it!

Well, pretty much. However, we have only been looking at the client side of Milo. Implementing your own server requires to use the server side API, and that change much more. But to be fair, the changes improve the situation a lot, and make things much easier to use.

Milo examples repository

As mentioned, the examples in the repository ctron/milo-ece2017 have been updated as well. They also contain the changed server side, which changed a lot more than the client side.

When you compare the two branches master and milo-0.2.x, you can see the changed I made for updating to the new version.

I hope this helps a bit in getting started with Milo 0.3.x. And please be sure to read the original post, giving a more detailed introduction, as well.

The post Eclipse Milo 0.3, updated examples appeared first on ctron's blog.

by Jens Reimann at July 06, 2019 08:22 PM

Back to the top