Skip to main content

Eclipse Theia 1.21 Release: News and Noteworthy

by Jonas, Maximilian & Philip at January 12, 2022 11:22 AM

We are happy to announce the Eclipse Theia 1.21 release! This monthly release contains 36 merged pull requests and provides lots...

The post Eclipse Theia 1.21 Release: News and Noteworthy appeared first on EclipseSource.


by Jonas, Maximilian & Philip at January 12, 2022 11:22 AM

Eclipse Cloud DevTools Contributor Award: The DISCO Experience

by Christopher Guindon (webdev@eclipse-foundation.org) at January 12, 2022 12:00 AM

The Eclipse Cloud Developer Tools contributor award this month goes to CS Group, represented by Vincent Hemery, for DISCO which is a modeling tool for satellite databases built with Eclipse Theia.

by Christopher Guindon (webdev@eclipse-foundation.org) at January 12, 2022 12:00 AM

CDT.cloud – An overview about C/C++ tooling in the web

by Jonas, Maximilian & Philip at January 10, 2022 09:29 AM

Do you want to build a custom tool for C/C++ development based on a modern technology stack? Do you want to...

The post CDT.cloud – An overview about C/C++ tooling in the web appeared first on EclipseSource.


by Jonas, Maximilian & Philip at January 10, 2022 09:29 AM

Getting started with Eclipse Theia(2): Starting Theia Development in VS Code Remote Containers

January 09, 2022 02:07 PM

This article is part of a series to help newcomers to get started with Eclipse Theia development by setting up a local docker-based development environment for Theia.

After having written the previous article Getting started with Eclipse Theia (1): Starting Theia Development in a Docker Dev Environment, I have tried the same setup on a different machine which does not have a Docker Desktop installation, but which uses docker-machine to manage its containers in a boot2docker VM.

My goal was to achieve a similarly easy startup on this machine (and also on Linux machines for which Docker Desktop is not available). By digging a bit deeper into the inner workings of the Docker Dev Environments feature, I have learned that most of the functionality is also available in VS Code directly via the Remote Containers Extension.

Similar to the Docker Dev Environments feature, you can add a folder .devcontainer to a repository containing a file called devcontainer.json. Then, anyone can directly clone this repository and start working on it inside a docker container with VS Code. This is how my devcontainer.json file looks like:

{
	"name": "theia-dev",
	"context": "../docker-container",
	"dockerFile": "../docker-container/Dockerfile",
	"forwardPorts": [3000],
	"postCreateCommand": "yarn && yarn theia build",
	"remoteUser": "node"
}

The Dockerfile referenced here is the same we have used for the Docker Dev Environments in the last article.

To get started, after installing the Remote Containers Extension in VS Code, follow these steps:

  1. From the Command Palette (F3), run "Remote-Containers: Clone Repository in Container Volume“.
  2. Enter the URL to the repository (or clone my repository github.com/xpomul/theia-boilerplate.git) and follow the navigation to select your GitHub repository
  3. Now wait. The container will be built, the repository will be cloned in a volume, and even the yarn and yarn theia build commands will be executed automatically (as specified in the devcontainer.json).
  4. After everything is done, you can close the Terminal, open a new one and just run yarn theia start --plugins=local-dir:plugins and your Eclipse Theia instance will come up at http://localhost:3000 

Again, from here, you can follow the usual Theia tutorials and start experimenting.

Have fun!


January 09, 2022 02:07 PM

Eclipse Collections 11.0 Released

by Donald Raab at January 07, 2022 05:22 AM

Features you want with the collections you need.

Eclipse Collections Logo

Eclipse Collections 11.0 is here!

Eclipse Collections 11.0 in Maven Central

I’m excited to share that the Eclipse Collections 11.0 release is now available in Maven Central. It has been over a year since we released Eclipse Collections 10.4 in August, 2020. Since then there have been three new JDK releases (15, 16, 17)! Eclipse Collections continues to participate in the OpenJDK Quality Outreach Program and tests against the latest releases of the JDK as they become available. We are currently building and testing actively against JDK 8, 11, 17, and 18 EA.

10 years as OSS, 6 years at Eclipse Foundation

GS Collections was released in January 2012, and was migrated to the Eclipse Foundation in December 2015. We celebrate 6 years of Eclipse Collections at the Eclipse Foundation in December 2021, and 10 years of open source development and public releases in January 2022.

Thank you to everyone who worked to make Eclipse Collections possible, and to all of the contributors who have invested time and energy into this wonderfully feature rich library the past 6 years at the Eclipse Foundation.

Here’s a look back at the article in InfoQ detailing GS Collections migrating to the Eclipse Foundation to become Eclipse Collections six years ago.

GS Collections Moves to the Eclipse Foundation

Thank you to the release team

The Eclipse Collections 11.0 release would not have been possible without the efforts of Eclipse Collections committer Sirisha Pratha and Eclipse Collections Project Lead Nikhil Nanivadekar. Thank you for all of your hard work at delivering this release!

Thank you to the community

The 11.0 release has a lot of new features submitted by our outstanding community of contributors. 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.

New Features with Contributor Blogs

I’ve been encouraging Eclipse Collections contributors to write blogs about the features they contribute to the project. I do my best to set a good example and try to regularly blog about any features I added to Eclipse Collections, or new katas I add to the Eclipse Collections Kata repository.

Following are a few of the blogs written by contributors about features they have contributed to the Eclipse Collections 11.0 release.

  • Added containsAny and containsNone on primitive iterables.

Primitive containsAny & containsNone in Eclipse Collections

Blog by Rinat Gatyatullin

  • Added union, intersect, difference, symmetric difference, cartesianProduct , isSubsetOf, isProperSubsetOf to primitive sets.

Blogs by Sirisha Pratha

  • Added anySatisfyWithOccurrences, allSatisfyWithOccurrences, noneSatisfyWithOccurrences, detectWithOccurrences to Bag.

EC by Example: new features in the Bag API

Blog by Alex Goldberg

  • Added putAllMapIterable method to MutableMap.
  • Added withMapIterable to MutableMap.
  • Added newWithMap and newWithMapIterable to ImmutableMap.

New ways to create Maps in Eclipse Collections Map API

Blog by Neha Sardana

  • Added toImmutableList/Set/Bag/Map/BiMap to RichIterable.
  • Added toImmutableSortedList/Set/Bag to RichIterable.
  • Added toImmutableSortedBag/List/Set with Comparator to RichIterable.
  • Added toImmutableSortedBagBy/ListBy/SetBy with Function to RichIterable.

Improving the symmetry of converter methods in Eclipse Collections

Blog by Donald Raab

  • Added ClassComparer utility.

How to introspect and find conceptual symmetry between classes in Java

Blog by Donald Raab

More new Features w/ Examples

The following are the remaining list of new features. The features in bold have examples immediately following.

  • Added selectWithIndex and rejectWithIndex to OrderedIterable and ListIterable.
@Test
public void selectWithIndex()
{
var list = Lists.mutable.with(1, 2, 3, 4);
var actual = list.selectWithIndex((each, i) -> each + i > 3);
var expected = Lists.mutable.with(3, 4);
Assertions.assertEquals(expected, actual);
}

@Test
public void rejectWithIndex()
{
var list = Lists.mutable.with(1, 2, 3, 4);
var actual = list.rejectWithIndex((each, i) -> each + i > 3);
var expected = Lists.mutable.with(1, 2);
Assertions.assertEquals(expected, actual);
}
  • Added covariant overrides for sortThis().
  • Added covariant return types to methods in MultiReaderList that return this.
  • Added primitive singleton iterator.
  • Added toSortedList(Comparator) and toSortedListBy(Function) to primitive iterables.
@Test
public void toSortedListWithComparator()
{
var set = IntSets.immutable.with(1, 2, 3, 4, 5);
var list = set.toSortedList((i1, i2) -> i2 - i1);
var expected = IntLists.immutable.with(5, 4, 3, 2, 1);
Assertions.assertEquals(expected, list);
}

@Test
public void toSortedListByWithFunction()
{
var set = IntSets.immutable.with(1, 2, 3, 4, 5);
var list = set.toSortedListBy(Math::negateExact);
var expected = IntLists.immutable.with(5, 4, 3, 2, 1);
Assertions.assertEquals(expected, list);
}
  • Added isEqual and isSame to Pair and Triple as default methods.
@Test
public void isEqual()
{
Twin<String> pair1 = Tuples.twin("1", "1");
Assertions.assertTrue(pair1.isEqual());
Twin<String> pair2 = Tuples.twin("1", "2");
Assertions.assertFalse(pair2.isEqual());

Triplet<String> triple1 = Tuples.triplet("1", "1", "1");
Assertions.assertTrue(triple1.isEqual());
Triplet<String> triple2 = Tuples.triplet("1", "2", "1");
Assertions.assertFalse(triple2.isEqual());
}

@Test
public void isSame()
{
Twin<String> pair1 = Tuples.identicalTwin("1");
Assertions.assertTrue(pair1.isSame());
Twin<String> pair2 = Tuples.twin("1", new String("1"));
Assertions.assertFalse(pair2.isSame());

Triplet<String> triple1 = Tuples.identicalTriplet("1");
Assertions.assertTrue(triple1.isSame());
Triplet<String> triple2 = Tuples.triplet("1", new String("1"), "1");
Assertions.assertFalse(triple2.isSame());
}
  • Added converters from Pair and Triple to List types.
@Test
public void pairToList()
{
Twin<String> twin = Tuples.twin("1", "2");
var mutableList = Tuples.pairToList(twin);
var fixedSizeList = Tuples.pairToFixedSizeList(twin);
var immutableList = Tuples.pairToImmutableList(twin);
var expected = Lists.mutable.with("1", "2");
Assertions.assertEquals(expected, mutableList);
Assertions.assertEquals(expected, fixedSizeList);
Assertions.assertEquals(expected, immutableList);
}

@Test
public void tripleToList()
{
Triplet<String> triplet = Tuples.identicalTriplet("1");
var mutableList = Tuples.tripleToList(triplet);
var fixedSizeList = Tuples.tripleToFixedSizeList(triplet);
var immutableList = Tuples.tripleToImmutableList(triplet);
var expected = Lists.mutable.with("1", "1", "1");
Assertions.assertEquals(expected, mutableList);
Assertions.assertEquals(expected, fixedSizeList);
Assertions.assertEquals(expected, immutableList);
}
  • Added toImmutableSortedBagBy to Collectors2.
@Test
public void collectors2toImmutableSortedBagBy()
{
List<Integer> list = List.of(1, 2, 2, 3, 3, 3);
ImmutableSortedBag<Integer> bag =
list.stream().collect(
Collectors2.toImmutableSortedBagBy(Math::negateExact));
Comparator<Integer> c =
Functions.toIntComparator(Math::negateExact);
var expected = SortedBags.mutable.with(c, 1, 2, 2, 3, 3, 3);
Assertions.assertEquals(expected, bag);
}
  • Added toImmutableSortedMap and toImmutableSortedMapBy to Collectors2.
@Test
public void collects2toImmutableSortedMap()
{
List<Integer> list = List.of(1, 2, 3);
Comparator<Integer> c =
Functions.toIntComparator(Math::negateExact);
ImmutableSortedMap<Integer, String> map =
list.stream().collect(
Collectors2.toImmutableSortedMap(c, e -> e, String::valueOf));
var expected = SortedMaps.mutable.with(c, 1, "1", 2, "2", 3, "3");
Assertions.assertEquals(expected, map);
}

@Test
public void collects2toImmutableSortedMapBy()
{
List<Integer> list = List.of(1, 2, 3);
Function<Integer, Integer> negate = Math::negateExact;
ImmutableSortedMap<Integer, String> map =
list.stream().collect(
Collectors2.toImmutableSortedMapBy(negate, e -> e, String::valueOf));
Comparator<Integer> c = Comparator.comparing(negate);
var expected = SortedMaps.mutable.with(c, 1, "1", 2, "2", 3, "3");
Assertions.assertEquals(expected, map);
}
  • Added toSortedMap and toSortedMapBy to Collectors2.
@Test
public void collects2toSortedMap()
{
List<Integer> list = List.of(1, 2, 3);
Comparator<Integer> c =
Functions.toIntComparator(Math::negateExact);
MutableSortedMap<Integer, String> map =
list.stream().collect(
Collectors2.toSortedMap(c, e -> e, String::valueOf));
var expected = SortedMaps.mutable.with(c, 1, "1", 2, "2", 3, "3");
Assertions.assertEquals(expected, map);
}

@Test
public void collects2toSortedMapBy()
{
List<Integer> list = List.of(1, 2, 3);
Function<Integer, Integer> negate = Math::negateExact;
MutableSortedMap<Integer, String> map =
list.stream().collect(
Collectors2.toSortedMapBy(negate, e -> e, String::valueOf));
Comparator<Integer> c = Comparator.comparing(negate);
var expected = SortedMaps.mutable.with(c, 1, "1", 2, "2", 3, "3");
Assertions.assertEquals(expected, map);
}

Norwegian Website Translation

We now have a Norwegian translation of the Eclipse Collections web site.

Norwegian Translation of the Eclipse Collections website

Thank you to Rustam Mehmandarov for the contribution and to Mads Opheim for reviewing the translation!

Three new Eclipse Collections Katas in 2021

There were three new code katas created and added to the Eclipse Collections Kata repository in 2021. I wrote the following blog about the six Eclipse Collections Katas. The Eclipse Collections katas are the best hands-on resource for learning the Eclipse Collections library.

The Eclipse Collections Code Katas

And there’s more!

Please refer to the 11.0 release notes for a more comprehensive set of changes made available in the 11.0 release. In there you will find details of optimizations, tech debt reduction, removed functionality, build changes, and a list of breaking changes.

Thank you

We continue to see an upward trend of downloads from Maven Central each month. From all the contributors and committers to the entire Eclipse Collections community… thank you for using Eclipse Collections!

Downloads of eclipse-collections for the past 12 months

We hope you enjoy all of the new features and improvements in the 11.0 release!

I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.


by Donald Raab at January 07, 2022 05:22 AM

Getting started with Eclipse Theia (1): Starting Theia Development in a Docker Dev Environment

January 03, 2022 07:58 PM

This article is part of a series to help newcomers to get started with Eclipse Theia development by setting up a local docker-based development environment for Theia.

So here it is. After over 10 years of Eclipse development, I wanted to get my hands dirty on something entirely new. I have followed the developments of Orion, Che, and Theia for a long time, but only from a distance; and I just didn’t have the time to actually try out, let alone to get involved with, these projects.

I have used Gitpod a few times, but merely to have a quick look into a GitHub repository when I didn’t have a local development environment and didn’t want to get one up and running.

Yet, I have noticed an increasing interest from my customers in web-based environments and so, I wanted to finally play around with Eclipse Theia.

But how? I have found this article which provides several options to run Eclipse Theia in different ways, but none of those options really hit the spot for me. I wanted to run a Theia instance in my browser, so Theia Blueprint was not an option. I wanted to be able to work offline, so using Gitpod was not possible. And I didn’t want to install nodejs on my machine. But still the goal was to get a basic Theia product up and running that should be ready to start hacking and customizing it, and then to jump in and create my first Theia extension.

I had started, and aborted again, several attempts to create a Docker container in which I could do that. But so far, I had not managed to create a smooth environment.

Then, recently, I found out about the Docker Dev Environments Preview. This is an experimental feature of Docker Desktop (there seems to be no CLI available for this functionality so far, and also, Docker Desktop is only available for Windows and MacOS). It glues together Git repository cloning, Docker container setup, and VS Code integration. This results in an easy process in which you can get an environment up and running locally with just a few clicks. It seems to be like a small sibling of Gitpod that can be run locally.

So, I have followed the instructions of Composing A Theia Application and have copied the package.json from that page to a new folder on my PC. After playing around a bit with different Docker images, I have come up with this Dockerfile:

FROM node:12

RUN apt-get update \
    &amp;&amp; apt-get install -y g++ gcc make python2.7 pkg-config libx11-dev libxkbfile-dev libsecret-1-dev

# install code generator for theia extensions
RUN npm install -g yo generator-theia-extension

USER node

EXPOSE 3000

ENTRYPOINT docker-entrypoint.sh

To indicate that Docker Dev Environments shall use the Dockerfile as its container definition, I also had to create a docker-compose.yml file like this:

version: "3.7"
services:
  theia:
    build:
      context: ../docker-container
    stdin_open: true
    tty: true
    volumes:
      - /home/stefan/theia-boilerplate/:/theia:cached
      
 
From these three files, I have created the GitHub repository https://github.com/xpomul/theia-boilerplate which can now be used as a template for further Theia experiments.

Getting started is now as simple as following these steps:

  1. Fork the repository on GitHub (or use mine to try it out)
  2. Open Docker Desktop, go to "Dev Environments" and click on "Create Dev Environment". Paste the GitHub URL and Continue. After some time, your Theia Dev Environment should now be up and running.
  3. Click "Open in VS Code". Your workspace should now contain the repository files. From now on, the instructions from https://theia-ide.org/docs/composing_applications can be followed:
  4. Open a new Terminal and enter yarn to download all the Theia dependencies. (That might take quite some time…)
  5. After the process is finished, enter yarn theia build, to build Theia. (Again, this might take some time; and don’t get discouraged by the warning about the filenamify module)
  6. Finally enter yarn theia start --plugins=local-dir:plugins and Theia will come up at http://localhost:3000 (VS Code will announce this and offer to open a browser)

And we are ready to go. From here, we have a running Theia that can be modified and customized by adding and changing files in VS Code and managing Theia in the VS Code Terminal. As a next step, we can, for example, jump into Authoring a Theia Extension.

Have fun!

 

 


January 03, 2022 07:58 PM

Exploring the Smalltalk Collections API in unit tests using Pharo 8.0

by Donald Raab at December 31, 2021 05:30 AM

Learn a little Smalltalk, and you might thank yourself later.

https://pharo.org/

A Little Smalltalk for the Holidays

I wanted to write a blog for the holidays to meet my commitment of writing one blog per month. I had some experiments I had written using Pharo 8.0 that I decided to organize into individual tests so I could blog about them. The experiments were a Smalltalk port of the methods I had written about in the following blog about Eclipse Collections.

My 25 favorite methods from the Eclipse Collections API

The Smalltalk Collections API is amazing. I didn’t realize how amazing the Smalltalk Collections framework was until I started programming in Java. The absence of a rich collections API made me long for Smalltalk in my early days as a Java programmer. Smalltalk can help you become a better programmer in any programming language you code in. At least, this has been my personal experience. Learning Smalltalk in 1994 prepared me for the eventual inclusion of lambdas and Streams in Java, nearly twenty years later when they were released in Java 8 (2014).

Learn Smalltalk in Y minutes

For a quick intro to Smalltalk syntax and methods, check out the following link.

Learn X in Y minutes Where X=Smalltalk

Syntax used in the examples

In the examples in this blog I will use temporary variables ( | variable1 variable2 |), assignment operator (:=), statement ending (.), unary messages (e.g. new, isEmpty, asBag) , binary messages (e.g. , and =), keyword messages (e.g. with:, select:, inject:into:, assert:equals:, etc.), a reserved word (self), String literals (e.g. ‘banana’), Character literals (e.g. $a, $b, $c), SmallInteger literals (e.g. 5, 3, 2), and code blocks([ :parameter | expression ]). Code blocks are the equivalent of lambdas in Java, and are full lexical closures that have a single type in Smalltalk (BlockClosure in Pharo).

Object-Oriented Basics

This is what it looks like creating temporary variables, instantiating objects and calling methods on objects in both Java and Smalltalk with assignment.

Java:

Object param1, param2, param3;
SomeClass object = new SomeClass();
Object result1 = object.method();
Object result2 = object.withOne(param1);
Object result3 = object.withOneTwo(param1, param2);
Object result4 = object.withOneTwoThree(param1, param2, param3);

Smalltalk:

| object param1 param2 param3 result1 result2 result3 result4 |
object := SomeClass new.
result1 := object method.
result2 := object withOne: param1.
result3 := object withOne: param1 two: param2.
result4 := object withOne: param1 two: param2 three: param3.

Smalltalk Collection methods covered in this blog

The following are the iteration patterns I will cover in this blog. I decided to keep it limited to a set of basic patterns. The full source for all examples is here.

The following are additional methods I used in the tests.

  • ,
  • =
  • asBag
  • assert: / assert:equals: / deny:
  • asUppercase
  • first
  • includes:
  • ifTrue:ifFalse:
  • isEmpty
  • newFromKeys:andValues:
  • occurrencesOf:
  • with:

The following are the data structures I used in the tests.

  • Bag
  • OrderedCollection
  • OrderedDictionary
  • Set

Smalltalk Iteration Patterns

Select

The method select: can be used to a filter a collection inclusively. The method takes a one-argument block that returns a Boolean (aka Predicate).

Filtering fruit using the select: method

Reject

The method reject: can be used to a filter a collection exclusively. The method takes a one-argument block that returns a Boolean (aka Predicate).

Filtering fruit using the reject: method

Collect

The method collect: can be used to transform a collection. The method takes a one-argument block that returns any type (aka Function).

Transforming fruit using the collect: method

FlatCollect

The method flatCollect: can be used to flatten and transform a collection. The method takes a one-argument block that returns a Collection (aka Function). In Smalltalk, a String is a Collection. The flatCollect: method on a String flattens the Character instances into a Collection. I convert the characters to a Bag using asBag so I can use the occurrencesOf: method to test the count of each character.

Flattening the characters in fruit using the flatCollect: method

Detect / DetectIfNone

The methods detect: and detect:ifNone: can be used to find the first object that matches a condition. The detect: method takes a one-argument block that returns a Boolean (aka Predicate). The detect:ifNone: method additionally takes a second zero-argument block as a second parameter that is evaluated and the result returned in the case that no element matches the condition of the first block.

Finding the fruit that starts with a letter using detect: and detect:ifNone:

InjectInto

The method inject:into: injects an initial value into an iteration over a Collection, and some result of each iteration is injected into the next iteration and so on and so forth. This method is usually used to implement methods like sum, min, max, etc. The method inject:into: is one of the most general, flexible and powerful of the iteration patterns in Smalltalk. In the following example, I inject an empty String into a iteration, and the result of each iteration is a concatenation of the injected String with a comma and each element. The only element that is not concatenated with a comma is the first one.

Concatenating the fruit in a collection using inject:into:

GroupedBy

The method groupedBy: iterates over a Collection and groups the elements in a Dictionary containing collections of the same type where the keys are derived by applying a function to each element. The groupedBy: method takes a one-argument block that returns any type (aka Function).

The method groupedBy: used to group fruit by the first character

AnySatisfy / AllSatisfy / NoneSatisfy

The methods anySatisfy:, allSatisfy: and noneSatisfy: test a collection to see if a certain condition is met and returns a Boolean result. All three methods take a one-argument block as a parameter. The block returns a Boolean (aka Predicate). Each of these methods will short-circuit if the Boolean result of the Predicate is the opposite of what is expected for the method.

Examples of the method anySatisfy:
Examples of the method allSatisfy:
Examples of the method noneSatisfy:

Count

The method count: returns the count of the number of elements that match a given condition. The count: method takes a one-argument block that returns a Boolean (aka Predicate).

Count all the bananas and fruit that contains the letter $a

The Source

Here’s a link to a gist with the source code in the examples above. Enjoy!

https://medium.com/media/abdbb868ea5c6252e24f0b4463c9bc26/href

That’s all folks!

Thank you for reading! I hope you enjoyed my trip down Smalltalk memory lane. If you’re bored this holiday season with everything getting locked down due to the pandemic, then maybe give yourself the gift of a little Smalltalk learning. The syntax will be different than what you are used to, but if you learn it, you will understand why Smalltalk developers prefer it to curly brace and parentheses languages.

I hope you have a safe, happy and healthy holiday! Hug your loved ones, take care of your family and yourself.

I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.


by Donald Raab at December 31, 2021 05:30 AM

RHAMT Eclipse Plugin 4.0.0.Final has been released!

by josteele at December 30, 2021 08:47 AM

We are happy to announce the latest release of the Red Hat Application Migration Toolkit (RHAMT) Eclipse Plugin.

Getting Started

It is now available through JBoss Central, and from the update site here.

What is RHAMT?

RHAMT is an automated application migration and assessment tool.

Example ways to RHAMT up your code:

  • Moving your application from WebLogic to EAP, or WebSphere to EAP

  • Version upgrade from Hibernate 3 to Hibernate 4, or EAP 6 to EAP 7

  • Change UI technologies from Seam 2 to pure JSF 2.

An example of how to run the RHAMT CLI:

$ ./rhamt-cli --input /path/to/jee-example-app-1.0.0.ear --output /path/to/output --source weblogic --target eap:7

The output is a report used to assess and prioritize migration and modernization efforts.

The RHAMT Eclipse Plugin - What does it do?

Consider an application migration comprised of thousands of files, with a myriad of small changes, not to mention the tediousness of switching between the report and your IDE. Who wants to be the engineer assigned to that task? :) Instead, this tooling marks the source files containing issues, making it easy to organize, search, and in many cases automatically fix issues using quick fixes.

Let me give you a quick walkthrough.

Ruleset Wizard

We now have quickstart template code generators.

Rueset Wizard

Rule Creation From Code

We have also added rule generators for selected snippets of code.

Rule Generation From Source

Ruleset Graphical Editor

Ruleset navigation and editing is faster and more intuitive thanks to the new graphical editor.

Graphical Editor

Ruleset View

We have created a view dedicated to the management of rulesets. Default rulesets shipped with RHAMT can now be opened, edited, and referenced while authoring your own custom rulesets.

Ruleset View

Run Configuration

The Eclipse plugin interacts with the RHAMT CLI process, thereby making it possible to specify command line options and custom rulesets.

Run Configuration

Ruleset Submission

Lastly, contribute your custom rulesets back to the community from within the IDE.

Ruleset Submission


You can find more detailed information here.

Our goal is to make the RHAMT tooling easy to use. We look forward to your feedback and comments!

Have fun!
John Steele
github/johnsteele


by josteele at December 30, 2021 08:47 AM

We are hiring

by jeffmaury at December 30, 2021 08:47 AM

The Developer Experience and Tooling group, of which JBoss Tools team is part, is looking for an awesome developer. We are looking to continue improving the usability for developers around various IDEs including Eclipse, VSCode and IntelliJ and around the Red Hat product line, including JBoss Middleware.

Topics range from Java to JavaScript, application servers to containers, source code tinkering to full blown CI/CD setups.

If you are into making developers life easier and like to be able to get involved in many different technologies and get them to work great together then do apply.

You can also ping me (jeffmaury@redhat.com) for questions.

The current list of openings are:

Note: the job postings do list a specific location, but for the right candidate we are happy to consider many locations worldwide (anywhere there is a Red Hat office), as well as working from home.

Have fun!
Jeff Maury
@jeffmaury @jbosstools


by jeffmaury at December 30, 2021 08:47 AM

RHAMT Eclipse Plugin 4.1.0.Final has been released!

by josteele at December 30, 2021 08:47 AM

Happy to announce version 4.1.0.Final of the Red Hat Application Migration Toolkit (RHAMT) is now available.

Getting Started

Downloads available through JBoss Central and from the update site.

RHAMT in a Nutshel

RHAMT is an application migration and assessment tool. The migrations supported include application platform upgrades, migrations to a cloud-native deployment environment, and also migrations from several commercial products to the Red Hat JBoss Enterprise Application Platform.

What is New?

Eclipse Photon

The tooling now targets Eclipse Photon.

Photon

Ignoring Patterns

Specify locations of files to exclude from analysis (using regular expressions).

Ignore Patterns

External Report

The generated report has been moved out of Eclipse and into the browser.

Report View

Improved Ruleset Schema

The XML ruleset schema has been relaxed providing flexible rule structures.

Schema

Custom Severities

Custom severities are now included in the Issue Explorer.

Custom Category

Stability

A good amount of time has been spent on ensuring the tooling functions consistently across Windows, OSX, and Linux.

You can find more detailed information here.

Our goal is to make the RHAMT tooling easy to use. We look forward to your feedback and comments!

Have fun!
John Steele
github/johnsteele


by josteele at December 30, 2021 08:47 AM

Quarkus

by jeffmaury at December 30, 2021 08:47 AM

You’ve probably heard about Quarkus, the Supersonic Subatomic Java framework tailored for Kubernetes and containers.

We wrote an article on how to create your first Quarkus project in an Eclipse based IDE (like Red Hat CodeReady Studio).


by jeffmaury at December 30, 2021 08:47 AM

Integration Tooling for Eclipse Photon

by pleacu at December 30, 2021 08:47 AM

Try our leaner, complete Eclipse Photon and Red Hat Developer Studio 12 compatible integration tooling.

devstudio12

JBoss Tools Integration Stack 4.6.0.Final / Red Hat Developer Studio Integration Stack 12.0.0.GA

All of the Integration Stack components have been verified to work with the same dependencies as JBoss Tools 4.6 and Red Hat Developer Studio 12.

What’s new for this release?

This is the initial release in support of Eclipse Photon. It syncs up with Developer Studio 12.0.0, JBoss Tools 4.6.0 and Eclipse 4.8.0 (Photon). It is also a maintenance release for Teiid Designer and BRMS tooling.

Released Tooling Highlights

Business Process and Rules Development

BPMN2 Modeler Known Issues

See the BPMN2 1.5.0.Final Known Issues Section of the Integration Stack 12.0.0.GA release notes.

Drools/jBPM6 Known Issues

See the Drools 7.8.0.Final Known Issues Section of the Integration Stack 12.0.0.GA release notes.

Data Virtualization Highlights

Teiid Designer

See the Teiid Designer 11.2.0.Final Resolved Issues Section of the Integration Stack 12.0.0.GA release notes.

What’s an Integration Stack?

Red Hat Developer Studio Integration Stack is a set of Eclipse-based development tools. It further enhances the IDE functionality provided by Developer Studio, with plug-ins specifically for use when developing for other Red Hat products. It’s where DataVirt Tooling and BRMS tooling are aggregated. The following frameworks are supported:

Red Hat Business Process and Rules Development

Business Process and Rules Development plug-ins provide design, debug and testing tooling for developing business processes for Red Hat BRMS and Red Hat BPM Suite.

  • BPEL Designer - Orchestrating your business processes.

  • BPMN2 Modeler - A graphical modeling tool which allows creation and editing of Business Process Modeling Notation diagrams using graphiti.

  • Drools - A Business Logic integration Platform which provides a unified and integrated platform for Rules, Workflow and Event Processing including KIE.

  • jBPM - A flexible Business Process Management (BPM) suite.

Red Hat Data Virtualization Development

Red Hat Data Virtualization Development plug-ins provide a graphical interface to manage various aspects of Red Hat Data Virtualization instances, including the ability to design virtual databases and interact with associated governance repositories.

  • Teiid Designer - A visual tool that enables rapid, model-driven definition, integration, management and testing of data services without programming using the Teiid runtime framework.

The JBoss Tools website features tab

Don’t miss the Features tab for up to date information on your favorite Integration Stack components.

Installation

The easiest way to install the Integration Stack components is through the stand-alone installer or through our JBoss Tools Download Site.

For a complete set of Integration Stack installation instructions, see Integration Stack Installation Guide

Let us know how it goes!

Paul Leacu.


by pleacu at December 30, 2021 08:47 AM

Integration Tooling for Eclipse Oxygen

by pleacu at December 30, 2021 08:47 AM

Try our complete Eclipse Oxygen and Red Hat JBoss Developer Studio 11 compatible integration tooling.

jbosstools jbdevstudio blog header

JBoss Tools Integration Stack 4.5.2.Final / Developer Studio Integration Stack 11.2.0.GA

All of the Integration Stack components have been verified to work with the same dependencies as JBoss Tools 4.5 and Developer Studio 11.

What’s new for this release?

This release provides full Teiid Designer tooling support for JBoss Data Virtualization 6.4 runtime. It provides an updated BPMN2 Modeler and jBPM/Drools for our Business Process Modeling friends. It also provides full synchronization with Devstudio 11.2.0.GA, JBoss Tools 4.5.2.Final and Eclipse Oxygen.2. Please note that SwitchYard is deprecated in this release.

Released Tooling Highlights

JBoss Business Process and Rules Development

BPMN2 Modeler Known Issues

See the BPMN2 1.4.2.Final Known Issues Section of the Integration Stack 11.2.0.GA release notes.

Drools/jBPM6 Known Issues

See the Drools 7.5.0.Final Known Issues Section of the Integration Stack 11.2.0.GA release notes.

SwitchYard Highlights

See the SwitchYard 2.4.1.Final Resolved Issues Section of the Integration Stack 11.2.0.GA release notes.

Data Virtualization Highlights

Teiid Designer

See the Teiid Designer 11.1.1.Final Resolved Issues Section of the Integration Stack 11.2.0.GA release notes.

What’s an Integration Stack?

Red Hat JBoss Developer Studio Integration Stack is a set of Eclipse-based development tools. It further enhances the IDE functionality provided by JBoss Developer Studio, with plug-ins specifically for use when developing for other Red Hat JBoss products. It’s where DataVirt Tooling, SOA tooling and BRMS tooling are aggregated. The following frameworks are supported:

JBoss Business Process and Rules Development

JBoss Business Process and Rules Development plug-ins provide design, debug and testing tooling for developing business processes for Red Hat JBoss BRMS and Red Hat JBoss BPM Suite.

  • BPEL Designer - Orchestrating your business processes.

  • BPMN2 Modeler - A graphical modeling tool which allows creation and editing of Business Process Modeling Notation diagrams using graphiti.

  • Drools - A Business Logic integration Platform which provides a unified and integrated platform for Rules, Workflow and Event Processing including KIE.

  • jBPM - A flexible Business Process Management (BPM) suite.

JBoss Data Virtualization Development

JBoss Data Virtualization Development plug-ins provide a graphical interface to manage various aspects of Red Hat JBoss Data Virtualization instances, including the ability to design virtual databases and interact with associated governance repositories.

  • Teiid Designer - A visual tool that enables rapid, model-driven definition, integration, management and testing of data services without programming using the Teiid runtime framework.

JBoss Integration and SOA Development

JBoss Integration and SOA Development plug-ins provide tooling for developing, configuring and deploying BRMS and SwitchYard to Red Hat JBoss Fuse and Fuse Fabric containers.

  • All of the Business Process and Rules Development plugins plus SwitchYard. Switchyard is deprecated as of this release.

  • Fuse Tooling has moved out of the Integration Stack to be a core part of JBoss Tools and Developer Studio.

The JBoss Tools website features tab

Don’t miss the Features tab for up to date information on your favorite Integration Stack components.

Installation

The easiest way to install the Integration Stack components is through the stand-alone installer or through our JBoss Tools Download Site.

For a complete set of Integration Stack installation instructions, see Integration Stack Installation Guide

Let us know how it goes!

Paul Leacu.


by pleacu at December 30, 2021 08:47 AM

Integration Tooling for Eclipse Oxygen

by pleacu at December 30, 2021 08:47 AM

Try our complete Eclipse Oxygen and Red Hat JBoss Developer Studio 11 compatible integration tooling.

jbosstools jbdevstudio blog header

JBoss Tools Integration Stack 4.5.0.Final / Developer Studio Integration Stack 11.0.0.GA

All of the Integration Stack components have been verified to work with the same dependencies as JBoss Tools 4.5 and Developer Studio 11.

What’s new for this release?

This is the initial release in support of Eclipse Oxygen. It syncs up with Developer Studio 11.0.0, JBoss Tools 4.5.0 and Eclipse 4.7.0 (Oxygen.0). It is also a maintenance release for SwitchYard and BRMS tooling.

Data Virtualization tooling support is not yet available (scheduled for the autumn).

SwitchYard is deprecated in this release.

Fuse Tooling has moved out of the Integration Stack to be a core part of JBoss Tools and Developer Studio.

Released Tooling Highlights

JBoss Business Process and Rules Development

BPMN2 Modeler Known Issues

See the BPMN2 1.4.0.Final Known Issues Section of the Integration Stack 11.0.0.GA release notes.

Drools/jBPM6 Known Issues

See the Drools 7.0.1.Final Known Issues Section of the Integration Stack 11.0.0.GA release notes.

SwitchYard Highlights

See the SwitchYard 2.4.0.Final Resolved Issues Section of the Integration Stack 11.0.0.GA release notes.

Data Virtualization Highlights

Teiid Designer

Not yet available for Oxygen.

What’s an Integration Stack?

Red Hat JBoss Developer Studio Integration Stack is a set of Eclipse-based development tools. It further enhances the IDE functionality provided by JBoss Developer Studio, with plug-ins specifically for use when developing for other Red Hat JBoss products. It’s where DataVirt Tooling, SOA tooling and BRMS tooling are aggregated. The following frameworks are supported:

JBoss Business Process and Rules Development

JBoss Business Process and Rules Development plug-ins provide design, debug and testing tooling for developing business processes for Red Hat JBoss BRMS and Red Hat JBoss BPM Suite.

  • BPEL Designer - Orchestrating your business processes.

  • BPMN2 Modeler - A graphical modeling tool which allows creation and editing of Business Process Modeling Notation diagrams using graphiti.

  • Drools - A Business Logic integration Platform which provides a unified and integrated platform for Rules, Workflow and Event Processing including KIE.

  • jBPM6 - A flexible Business Process Management (BPM) suite.

JBoss Data Virtualization Development

JBoss Data Virtualization Development plug-ins provide a graphical interface to manage various aspects of Red Hat JBoss Data Virtualization instances, including the ability to design virtual databases and interact with associated governance repositories. Data Virtualization tooling support is not yet available (scheduled for the autumn).

  • Teiid Designer - A visual tool that enables rapid, model-driven definition, integration, management and testing of data services without programming using the Teiid runtime framework.

JBoss Integration and SOA Development

JBoss Integration and SOA Development plug-ins provide tooling for developing, configuring and deploying BRMS and SwitchYard to Red Hat JBoss Fuse and Fuse Fabric containers.

  • All of the Business Process and Rules Development plugins plus SwitchYard. Switchyard is deprecated as of this release.

  • Fuse Tooling has moved out of the Integration Stack to be a core part of JBoss Tools and Developer Studio.

The JBoss Tools website features tab

Don’t miss the Features tab for up to date information on your favorite Integration Stack components.

Installation

The easiest way to install the Integration Stack components is through the stand-alone installer.

For a complete set of Integration Stack installation instructions, see Integration Stack Installation Instructions

Be the first to try it on Oxygen!

Paul Leacu.


by pleacu at December 30, 2021 08:47 AM

Integration Tooling for Eclipse 2019-03

by pleacu at December 30, 2021 08:47 AM

Check out our new branding for Eclipse 2019-03. We’re now Red Hat CodeReady Studio 12 Integration Stack.

crstudio12

JBoss Tools Integration Stack 4.11.0.Final / Red Hat CodeReady Studio Integration Stack 12.11.0.GA

All of the Integration Stack components have been verified to work with the same dependencies as JBoss Tools 4.11 and Red Hat CodeReady Studio 12.

What’s new for this release?

DataVirtualization support from Teiid Designer is no longer available through the Integration Stack. It can be installed directly from Teiid Designer

This release has an updated BPMN2 Modeler and jBPM/Drools/KIE.

Released Tooling Highlights

Business Process and Rules Development

BPMN2 Modeler Known Issues

See the BPMN2 1.5.1.Final Known Issues Section of the Integration Stack 12.11.0.GA release notes.

Drools/jBPM6 Known Issues

See the Drools 7.21.0.Final Known Issues Section of the Integration Stack 12.11.0.GA release notes.

What’s an Integration Stack?

Red Hat CodeReady Studio Integration Stack is a set of Eclipse-based development tools. It further enhances the IDE functionality provided by Developer Studio, with plug-ins specifically for use when developing for other Red Hat products. It’s where BRMS tooling is aggregated. The following frameworks are supported:

Red Hat Business Process and Rules Development

Business Process and Rules Development plug-ins provide design, debug and testing tooling for developing business processes for Red Hat BRMS and Red Hat BPM Suite.

  • BPEL Designer - Orchestrating your business processes.

  • BPMN2 Modeler - A graphical modeling tool which allows creation and editing of Business Process Modeling Notation diagrams using graphiti.

  • Drools - A Business Logic integration Platform which provides a unified and integrated platform for Rules, Workflow and Event Processing including KIE.

  • jBPM - A flexible Business Process Management (BPM) suite.

The JBoss Tools website features tab

Don’t miss the Features tab for up to date information on your favorite Integration Stack components.

Installation

The easiest way to install the Integration Stack components is through the stand-alone installer or through our JBoss Tools Download Site.

For a complete set of Integration Stack installation instructions, see Integration Stack Installation Guide

Let us know how it goes!

Paul Leacu.


by pleacu at December 30, 2021 08:47 AM

JBoss Tools 4.9.0.AM3 for Eclipse 2018-09 M2

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.9.0.AM3 (Developer Milestone 3) build for Eclipse 2018-09 M2.

Downloads available at JBoss Tools 4.9.0 AM3.

What is New?

Full info is at this page. Some highlights are below.

General

Server Tools

Wildfly 14 Server Adapter

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

Forge Tools

Forge Runtime updated to 3.9.1.Final

The included Forge runtime is now 3.9.1.Final. Read the official announcement here.

Fuse Tooling

Know issues

A regression has been introduced touching all functionalities using Jaxb. It includes:

  • Variable content display in debug

  • Data Transformation wizard

  • Tracing Camel route via Jolokia Connection

It may affect other functionalities. In this case, you will have this kind of error in log:

java.lang.NullPointerException
          at javax.xml.bind.ContextFinder.handleClassCastException(ContextFinder.java:95)

Please note that it has been already fixed on nightly build

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.9.0.AM2 for Eclipse 2018-09 M2

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.9.0.AM2 (Developer Milestone 2) build for Eclipse 2018-09 M2.

Downloads available at JBoss Tools 4.9.0 AM2.

What is New?

Full info is at this page. Some highlights are below.

General

Eclipse 2018-09

JBoss Tools is now targeting Eclipse 2018-09 M2.

Fuse Tooling

WSDL to Camel REST DSL improvements

The version of the library used to generate Camel REST DSL from WSDl files has been updated. It now covers more types of WSDL files. See https://github.com/jboss-fuse/wsdl2rest/milestone/3?closed=1 for the list of improvements.

REST Editor tab improvements

In the last milestone we began adding editing capabilities to the read-only REST tab to the route editor we added in the previous release. Those efforts have continued and we now have a fully editable REST tab.

Fully Editable REST Editor

You can now:

  • Create and delete REST Configurations

  • Create and delete new REST Elements

  • Create and delete new REST Operations

  • Edit properties for a selected REST Element in the Properties view

  • Edit properties for a selected REST Operation in the Properties view

In addition, we’ve improved the look and feel by fixing the scrolling capabilities of the REST Element and REST Operations lists.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.6.0.AM3 for Eclipse Photon.0.RC3

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.6.0.AM3 (Developer Milestone 3) build for Eclipse Photon.0.RC3.

Downloads available at JBoss Tools 4.6.0 AM3.

What is New?

Full info is at this page. Some highlights are below.

General

Eclipse Photon

JBoss Tools is now targeting Eclipse Photon RC3.

Fuse Tooling

Camel URI completion with XML DSL

As announced here, it was already possible to have Camel URI completion with XML DSL in the source tab of the Camel Route editor by installing the Language Support for Apache Camel in your IDE.

This feature is now installed by default with Fuse Tooling!

Camel URI completion in source tab of Camel Editor

Now you have the choice to use the properties view with UI help to configure Camel components or to use the source editor and benefit from completion features. It all depends on your development preferences!

Webservices Tooling

JAX-RS 2.1 Support

JAX-RS 2.1 is part of JavaEE8 and JBoss Tools now provides you with support for this update of the specification.

Server side events

JAX-RS 2.1 brought support for server side events. The Sse and SseEventSink resources can now be injected into method arguments thanks to the @Context annotation.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.6.0.AM2 for Eclipse Photon.0.M7

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.6.0.AM2 (Developer Milestone 2) build for Eclipse Photon.0.M7.

Downloads available at JBoss Tools 4.6.0 AM2.

What is New?

Full info is at this page. Some highlights are below.

General

Eclipse Photon

JBoss Tools is now targeting Eclipse Photon M7.

OpenShift

Enhanced Spring Boot support for server adapter

Spring Boot runtime was already supported by the OpenShift server adapter. However, it has one major limitation: files and resources were synchronized between the local workstation and the remote pod(s) only for the main project. If your Spring Boot application had dependencies that were present in the local workspace, any change to a file or resource of one of these dependencies was not handled. This is not true anymore.

Fuse Tooling

Camel Rest DSL from WSDL wizard

There is a new "Camel Rest DSL from WSDL" wizard. This wizard wraps the wsdl2rest tool now included with the Fuse 7 distribution, which takes a WSDL file for a SOAP-based (JAX-WS) web service and generates a combination of CXF-generated code and a Camel REST DSL route to make it accessible using REST operations.

To start, you need an existing Fuse Integration project in your workspace and access to the WSDL for the SOAP service. Then use File→New→Other…​ and select Red Hat Fuse→Camel Rest DSL from WSDL wizard.

On the first page of the wizard, select your WSDL and the Fuse Integration project in which to generate the Java code and Camel configuration.

SOAP to REST Wizard page 1

On the second page, you can customize the Java folder path for your generated classes, the folder for the generated Camel file, plus any customization for the SOAP service address and destination REST service address.

SOAP to REST Wizard page 2

Click Finish and the new Camel configuration and associated Java code are generated in your project. The wizard determines whether your project is Blueprint, Spring, or Spring Boot based, and it creates the corresponding artifacts without requiring any additional input. When the wizard is finished, you can open your new Camel file in the Fuse Tooling Route Editor to view what it created.

Fuse Tooling editor Rest Tab

That brings us to another new functionality, the REST tab in the Fuse Tooling Route Editor.

Camel Editor REST tab

The Fuse Tooling Route Editor provides a new REST tab. For this release, the contents of this tab is read-only and includes the following information:

  • Details for the REST Configuration element including the component (jetty, netty, servlet, etc.), the context path, the port, binding mode (JSON, XML, etc.), and host. There is only one REST Configuration element.

  • A list of REST elements that collect REST operations. A configuration can have more than one REST element. Each REST element has an associated property page that displays additional details such as the path and the data it consumes or produces.

Fuse Tooling Rest Elements Properties View
  • A list of REST operations for the selected REST element. Each of the operations has an associated property page that provides details such as the URI and output type.

Fuse Tooling Rest Operations Properties View

For this release, the REST tab is read-only. If you want to edit the REST DSL, use the Route Editor Source tab. When you make changes and save them in the Source tab, the REST tab refreshes to show your updates.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.6.0.AM1 for Eclipse Photon.0.M6

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.6.0.AM1 (Developer Milestone 1) build for Eclipse Photon.0.M6.

Downloads available at JBoss Tools 4.6.0 AM1.

What is New?

Full info is at this page. Some highlights are below.

General

Eclipse Photon

JBoss Tools is now targeting Eclipse Photon M6.

Forge Tools

Forge Runtime updated to 3.9.0.Final

The included Forge runtime is now 3.9.0.Final. Read the official announcement here.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.3.AM3 for Eclipse Oxygen.3

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.3.AM3 (Developer Milestone 3) build for Eclipse Oxygen.3.

Downloads available at JBoss Tools 4.5.3 AM3.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

CDK and Minishift Server Adapter runtime download

When working with both CDK and upstream Minishift, you needed to have previously downloaded the CDK or Minishift binary. It is now possible to download the runtime to a specific folder when you create the server adapter.

Let’s see an example with the CDK server adapter.

From the Servers view, select the new Server menu item and enter cdk in the filter:

cdk server adapter wizard

Select Red Hat Container Development Kit 3.2+

cdk server adapter wizard1

Click the Next button:

cdk server adapter wizard3

In order to download the runtime, click the Download and install runtime…​ link:

cdk server adapter wizard4

Select the version of the runtime you want to download

cdk server adapter wizard5

Click the Next button:

cdk server adapter wizard6

You need an account to download the CDK. If you already had configured credentials, select the one you want to use. If you didn’t, click the Add button to add your credentials.

cdk server adapter wizard7

Click the Next button. Your credentials will be validated, and upon success, you must accept the license agreement:

cdk server adapter wizard8

Accept the license agreement and click the Next button:

cdk server adapter wizard9

You can choose the folder where you want the runtime to be installed. Once you’ve set it, click the Finish button:

The download of the runtime will be started and you should see the progression on the server adapter wizard:

cdk server adapter wizard10

Once the download is completed, you will notice that the Minishift Binary and Username fields have been filled:

cdk server adapter wizard11

Click the Finish button to create the server adapter.

Please note that if it’s the first time you install CDK, you must perform an initialization. In the Servers view, right click the server and select the Setup CDK menu item:

cdk server adapter wizard12
cdk server adapter wizard13

Hibernate Tools

Hibernate Runtime Provider Updates

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

New Hibernate 5.3 Runtime Provider

With beta releases available in the Hibernate 5.3 stream, the time was right to make available a corresponding Hibernate 5.3 runtime provider. This runtime provider incorporates Hibernate Core version 5.3.0.Beta2 and Hibernate Tools version 5.3.0.Beta1.

hibernate 5 3
Figure 1. Hibernate 5.3 is available
Other Runtime Provider Updates

The Hibernate 5.0 runtime provider now incorporates Hibernate Core version 5.0.12.Final and Hibernate Tools version 5.0.6.Final.

The Hibernate 5.1 runtime provider now incorporates Hibernate Core version 5.1.12.Final and Hibernate Tools version 5.1.7.Final.

The Hibernate 5.2 runtime provider now incorporates Hibernate Core version 5.2.15.Final and Hibernate Tools version 5.2.10.Final.

Fuse Tooling

Fuse Ignite Technical Extension templates

The existing template for "Custom step using a Camel Route" has been updated to work with Fuse 7 Tech Preview 4.

Two new templates have been added: - Custom step using Java Bean - Custom connector

New Fuse Ignite wizard with 3 options

Improvements of the wizard to create a Fuse Integration project

The creation wizard provides better guidance for the targeted deployment environment:

New Fuse Integration Project wizard page to select environment

More place is available to choose the templates and they are now filtered based on the targeted environment:

New Fuse Integration Project wizard page to select templates

It also points out to other places to find different examples for advanced users (see the link at the bottom of the previous screenshot).

Camel Rest DSL editor (Technical preview)

Camel is providing a Rest DSL to help the integration through Rest endpoints. Fuse Tooling is now providing a new tab in read-only mode to visualize the Rest endpoints defined.

Rest DSL editor tab in read-only mode

It is currently in Tech Preview and needs to be activated in Window → Preferences → Fuse Tooling → Editor → Enable Read Only Tech preview REST DSL tab.

Work is still ongoing and feedback is very welcome on this new feature, you can comment on this JIRA epic.

Dozer upgrade and migration

When upgrading from Camel < 2.20 to Camel > 2.20, the Dozer dependency has been upgraded to a version not backward-compatible If you open a Data transformation based on Dozer in Fuse Tooling, it will propose to migrate the file used for the transformation (technically changing the namespace). It allow to continue to use the Data Transformation editor and have - in most cases - the Data Transformation working at runtime with Camel > 2.20.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.3.AM2 for Eclipse Oxygen.3

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.3.AM2 (Developer Milestone 2) build for Eclipse Oxygen.3.

Downloads available at JBoss Tools 4.5.3 AM2.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

CDK and Minishift Server Adapter better developer experience

When working with both CDK and upstream Minishift, it is recommanded to distinguish environments through the MINISHIFT_HOME variable. It was possible before to use this parameter but it requires a two steps process:

  • first create the server adapter (through the wizard)

  • then change the MINISHIFT_HOME in the server adapter editor

It is now possible to set this parameter from the server adapter wizard. So now, everything is correctly setup when you create the server adapter.

Let’s see an example with the CDK server adapter.

From the Servers view, select the new Server menu item and enter cdk in the filter:

cdk server adapter wizard

Select Red Hat Container Development Kit 3.2+

cdk server adapter wizard1

Click the Next button:

cdk server adapter wizard2

The MINISHIFT_HOME parameter can be set here and is defaulted.

Fuse Tooling

Display Fuse version corresponding to Camel version proposed

When you create a new project, you select the Camel version from a list. Now, the list of Camel versions includes the Fuse version to help you choose the version that corresponds to your production version.

Fuse Version also displayed in drop-down list close to Camel version

Update validation for similar IDs between a component and its definition

Starting with Camel 2.20, you can use similar IDs for the component name and its definition unless the specific property "registerEndpointIdsFromRoute" is provided. The validation process checks the Camel version and the value of the "registerEndpointIdsFromRoute" property.

For example:

<from id="timer" uri="timer:timerName"/>

Improved guidance in method selection for factory methods on Global Bean

When selecting factory method on a Global bean, a lot of possibilities were proposed in the user interface. The list of factory methods for a global bean is now limited to only those methods that match the constraints of the bean’s global definition type (bean or bean factory).

Customize EIP labels in the diagram

The Fuse Tooling preferences page for the Editor view includes a new "Preferred Labels" option.

Fuse Tooling editor preference page

Use this option to define the label of EIP components (except endpoints) shown in the Editor’s Design view.

Dialog for defining the display text for an EIP

General

Credentials Framework

Sunsetting jboss.org credentials

Download Runtimes and CDK Server Adapter used the credentials framework to manage credentials. However, the JBoss.org credentials cannot be used any more as the underlying service used by these components does not support these credentials.

The credentials framework still supports the JBoss.org credentials in case other services / components require or use this credentials domain.

Aerogear

Aerogear component deprecation

The Aerogear component has been marked deprecated as there is no more maintenance on the source code. It is still available in Red Hat Central and may be removed in the future.

Arquillian

Arquillian component removal

The Arquillian component has been removed from Red Hat Central as it has been deprecated a while ago.

BrowserSim

BrowserSim component deprecation

The BrowserSim component has been marked deprecated as there is no more maintenance on the source code. It is still available in Red Hat Central and may be removed in the future.

Freemarker

Freemarker component removal

The Freemarker component has been removed from Red Hat Central as it has been deprecated a while ago.

LiveReload

LiveReload component deprecation

The LiveReload component has been marked deprecated as there is no more maintenance on the source code. It is still available in Red Hat Central and may be removed in the future.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.3.AM1 for Eclipse Oxygen.2

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.3.AM1 (Developer Milestone 1) build for Eclipse Oxygen.2.

Downloads available at JBoss Tools 4.5.3 AM1.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

Minishift Server Adapter

A new server adapter has been added to support upstream Minishift. While the server adapter itself has limited functionality, it is able to start and stop the Minishift virtual machine via its minishift binary. From the Servers view, click New and then type minishift, that will bring up a command to setup and/or launch the Minishift server adapter.

minishift server adapter

All you have to do is set the location of the minishift binary file, the type of virtualization hypervisor and an optional Minishift profile name.

minishift server adapter1

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

minishift server adapter2

Once the server is started, Docker and OpenShift connections should appear in their respective views, allowing the user to quickly create a new Openshift application and begin developing their AwesomeApp in a highly-replicatable environment.

minishift server adapter3
minishift server adapter4

Fuse Tooling

New shortcuts in Fuse Integration perspective

Shortcuts for the Java, Launch, and Debug perspectives and basic navigation operations are now provided within the Fuse Integration perspective.

The result is a set of buttons in the Toolbar:

New Toolbar action

All of the associated keyboard shortcuts are also available, such as Ctrl+Shift+T to open a Java Type.

Performance improvement: Loading Advanced tab for Camel Endpoints

The loading time of the "Advanced" tab in the Properties view for Camel Endpoints is greatly improved.

Advanced Tab in Properties view

Previously, in the case of Camel Components that have a lot of parameters, it took several seconds to load the Advanced tab. For example, for the File component, it would take ~3.5s. It now takes ~350ms. The load time has been reduced by a factor of 10. (See this interesting article on response time)

If you notice other places showing slow performance, you can file a report by using the Fuse Tooling issue tracker. The Fuse Tooling team really appreciates your help. Your feedback contributes to our development priorities and improves the Fuse Tooling user experience.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.2.AM2 for Eclipse Oxygen.2

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.2.AM2 (Developer Milestone 2) build for Eclipse Oxygen.2 (built with RC2).

Downloads available at JBoss Tools 4.5.2 AM2.

What is New?

Full info is at this page. Some highlights are below.

Fuse Tooling

Fuse 7 Karaf-based runtime Server adapter

Fuse 7 is cooking and preliminary versions are already available on early-access repository. Fuse Tooling is ready to leverage them so that you can try the upcoming major Fuse version.

Fuse 7 Server Adapter

Classical functionalities with server adapters are available: automatic redeploy, Java debug, Graphical Camel debug through created JMX connection. Please note: - you can’t retrieve the Fuse 7 Runtime yet directly from Fuse tooling, it is required to download it on your machine and point to it when creating the Server adapter. - the provided templates requires some modifications to have them working with Fuse 7, mainly adapting the bom. Please see work related to it in this JIRA task and its children.

Display routes defined inside "routeContext" in Camel Graphical Editor (Design tab)

"routeContext" tag is a special tag used in Camel to provide the ability to reuse routes and to split them across different files. This is very useful on large projects. See Camel documentation for more information. Since this version, the Design of the routes defined in "routeContext" tags are now displayed.

Usability improvement: Progress bar when "Changing the Camel version"

Since Fuse Tooling 10.1.0, it is possible to change the Camel version. In case the Camel version was not cached locally yet and for slow internet connections, this operation can take a while. There is now a progress bar to see the progress.

Switch Camel Version with Progress Bar

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.2.AM1 for Eclipse Oxygen.1a

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.2.AM1 (Developer Milestone 1) build for Eclipse Oxygen.1a.

Downloads available at JBoss Tools 4.5.2 AM1.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

Support for route timeouts and liveness probe for OpenShift Server Adapter debugging configurations

While debugging your OpenShift deployment, you may face two different issues:

  • if you launch your test through a Web browser, then it’s likely that you will access your OpenShift deployment through an OpenShift route. The problem is that, by default, OpenShift routes have a 30 seconds timeout for each request. So if you’re stepping through one of your breakpoints, you will get a timeout error message in the browser window even if you can still debug your OpenShift deployment. And you’re now stuck will the navigation of your OpenShift application.

  • if your OpenShift deployment has a liveness probe configured, depending on your virtual machine capabilities or how your debugger is configured, if your stepping into one of your breakpoints, the liveness probe may fail thus OpenShift so OpenShift will restart your container and your debugging session will be destroyed.

So, from now, when the OpenShift server adapter is started in debug mode, the following action are being performed:

  • if an OpenShift route is found that is linked to the OpenShift deployment you want to debug, the route timeout will be set or increased to 1 hour. The original or default value will be restored when the OpenShift server adapter will be restarted in run mode.

  • if your OpenShift deployment has a liveness probe configured, the initialDelay field will be increased to 1 hour if the defined value for this field is lower than 1 hour. If the value of this field is defined to a value greater than 1 hour, it is left intact. The original value will be restored when the OpenShift server adapter will be restarted in run mode

Fuse Tooling

Camel context parameters configurable in properties view for Camel version < 2.18

Before Camel 2.18, the Camel catalog is missing information about Camel Context. Fuse Tooling is now providing this missing piece of information and thus allow to edit Camel Context parameters in Properties view like for any other component. It is activated when there is no element selected on the diagram.

Parameters in Properties view for Camel context

Usability improvement: Progress bar when "Changing the Camel version"

Since Fuse Tooling 10.1.0, it is possible to change the Camel version. In case the Camel version was not cached locally yet and for slow internet connections, this operation can take a while. There is now a progress bar to see the progress.

Switch Camel Version with Progress Bar

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.1.AM3 for Eclipse Oxygen.1

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.1.AM3 (Developer Milestone 3) build for Eclipse Oxygen.1.

Downloads available at JBoss Tools 4.5.1 AM3.

What is New?

Full info is at this page. Some highlights are below.

OpenShift.io

OpenShift.io login

It is possible to login from JBoss Tools to OpenShift.io. A single account will be maintained per workspace. Once you initially logged onto OpenShift.io, all needed account information (tokens,…​) will be stored securely.

There are two ways to login onto OpenShift.io:

  • through the UI

  • via a third party service that will invoke the proper extension point

UI based login to OpenShift.io

In the toobar, you should see a new icon Toolbar. Click on it and it will launch the login.

If this is the first time you login to OpenShift.io or if you OpenShift.io account tokens are not valid anymore, you should see a browser launched with the following content:

osio browser

Enter your RHDP login and the browser will then auto-close and an extract (for security reasons) of the OpenShift.io token will be displayed:

osio token dialog

This dialog will be also shown if an OpenShift.io account was configured in the workspace and the account information is valid.

Via extension point

The OpenShift.io integration can be invoked by a third party service through the org.jboss.tools.openshift.io.code.tokenProvider extension point. This extension point will perform the same actions as the UI but basically will return an access token for OpenShift.io to the third party service. A detailed explanation of how to use this extension point is described here: Wiki page

You can display the account information using the Eclipse Jboss Tools → OpenShift.io preference node. If you workspace does not contain an OpenShift.io account yet, you should see the following:

osio preferences

If you have a configured OpenShift.io account, you should see this:

osio preferences1

CDK 3.2 Beta Server Adapter

A new server adapter has been added to support the next generation of CDK 3.2. This is Tech Preview in this release as CDK 3.2 is Beta. While the server adapter itself has limited functionality, it is able to start and stop the CDK virtual machine via its minishift binary. Simply hit Ctrl+3 (Cmd+3 on OSX) and type CDK, that will bring up a command to setup and/or launch the CDK server adapter. You should see the old CDK 2 server adapter along with the new CDK 3 one (labeled Red Hat Container Development Kit 3.2+ ).

cdk3.2 server adapter

All you have to do is set the credentials for your Red Hat account, the location of the CDK’s minishift binary file, the type of virtualization hypervisor and an optional CDK profile name.

cdk3.2 server adapter1

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

cdk3.2 server adapter2

Once the server is started, Docker and OpenShift connections should appear in their respective views, allowing the user to quickly create a new Openshift application and begin developing their AwesomeApp in a highly-replicatable environment.

cdk3.2 server adapter3
cdk3.2 server adapter4
This is Tech Preview. The implementation is subject to change, may not work with next releases of CDK 3.2 and testing has been limited.

Fuse Tooling

Global Beans: improve support for Bean references

It is now possible to set Bean references from User Interface when creating a new Bean:

Create Factory Bean Reference

Editing Bean references is also now available on the properties view when editing an existing Bean:

Edit Factory Bean Reference

Additional validation has been added to help users avoid mixing Beans defined with class names and Beans defined referencing other beans.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.5.1.AM2 for Eclipse Oxygen.1

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.5.1.AM2 (Developer Milestone 2) build for Eclipse Oxygen.1.

Downloads available at JBoss Tools 4.5.1 AM2.

What is New?

Full info is at this page. Some highlights are below.

OpenShift 3

New command to tune resource limits

A new command has been added to tune resource limits (CPU, memory) on an OpenShift deployment. It’s available for a Service, a DeploymentConfig, a ReplicationController or a Pod.

To activate it, go the the OpenShift explorer, select the OpenShift resource, right click and select Edit resource limits. The following dialog will show up:

edit resource limits

After you changed the resource limits for this deployment, it will be updated and new pods will be spawned (not for ReplicationController)

edit resource limits1

Discover Docker registry URL for OpenShift connections

When an OpenShift connection is created, the Docker registry URL is empty. When the CDK is started through the CDK server adapter, an OpenShift connection is created or updated if a matching OpenShift connection is found. But what if you have several OpenShift connections, the remaining ones will be left with the empty URL.

You can find the matching Docker registry URL when editing the OpenShift connection through the Discover button:

edit connection discover

Click on the Discover button and the Docker registry URL will be filled if a matching started CDK server adapter is found:

edit connection discover1

CDI Tools

CDI 2.0

CDI Tools now support CDI 2.0 projects. If your CDI project (with enabled CDI support) has CDI 2.0 jars in its classpath, CDI Tools will recognize it as CDI 2.0 project automatically. There is no need to use any special settings to distinguish CDI 1.0 or CDI 1.1 from CDI 2.0 in CDI Tools.

The new javax.enterprise.event.ObservesAsync is now being validated according to the CDI specifications.

Fuse Tooling

Apache Karaf 4.x Server Adapter

We are happy to announce the addition of new Apache Karaf server adapters. You can now download and install Apache Karaf 4.0 and 4.1 from within your development environment.

Apache Karaf 4x Server Adapters

Switch Apache Camel Version

You can now change the Apache Camel version used in your project. To do that you invoke the context menu of the project in the project explorer and navigate into the Configure menu. There you will find the menu entry called Change Camel Version which will guide you through this process.

Switch Camel Version

Improved Validation

The validation in the editor has been improved to find containers which lack mandatory child elements. (for instance a Choice without a child element)

Improved validation

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.21.2.AM1 for Eclipse 2021-09

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.21.2.AM1 (Developer Milestone 1) build for Eclipse 2021-09.

Downloads available at JBoss Tools 4.21.2.AM1.

What is New?

Full info is at this page. Some highlights are below.

Quarkus Tools

Quarkus stream selection in the new Quarkus project wizard

When a new Quarkus project/module is to be generated, it is now possible to select the Quarkus stream (see this article) on which the generated application will be based on.

By default, the recommended (latest release) will be selected but you can choose another one:

quarkus31

Enhanced code completion in Java files

When you want to define a fallback method thanks to the @Fallback annotation from MicroProfile Fault Tolerance, the code completion is activated on the fallbackMethod member and will propose you available target methods.

quarkus32

Quarkus launch configuration workspace resolution

When you define a Quarkus launch/debug configuration, it is linked to a specific project from your workspace. If this project has a dependency on another project from the workspace, it will be resolved against the workspace and you don’t have to install the dependency in the local Maven/Gradle cache so that it can be resolved.

Hibernate Tools

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

Runtime Provider Updates

The Hibernate 5.6 runtime provider now incorporates Hibernate Core version 5.6.1.Final and Hibernate Tools version 5.6.1.Final.

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

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

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.21.0.AM1 for Eclipse 2021-09

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.21.0.AM1 (Developer Milestone 1) build for Eclipse 2021-09.

Downloads available at JBoss Tools 4.21.0 AM1.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

Operator based services

When developing cloud native applications on OpenShift, developer may need to launch services (databases, messaging system,…​) that the application under development may need to connect to. The OpenShift tooling allowed to launch such services but it was based on the service catalog which is not available anymore on OpenShift 4.

The new feature is based on operators which is the devops way of installing and managing software on Kubernetes clusters. So when you want to launch a service for your application, you will have to choose from the list of installed operators on your cluster and then select type of deployment you want.

In the following example, there are two operators installed on our cluster: the Strimzi operator for setting up Kafka clusters on Kubernetes and a Postgresql operator.

For each operator, we can select the type of deployment we want to setup.

operator based services1

After you’ve entered the name of your service, it will appear in the application explorer view:

operator based services2

Hibernate Tools

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

Runtime Provider Updates

The Hibernate 5.5 runtime provider now incorporates Hibernate Core version 5.5.7.Final and Hibernate Tools version 5.5.7.Final.

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

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.19.1.AM1 for Eclipse 2021-03

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.19.1.AM1 (Developer Milestone 1) build for Eclipse 2021-03.

Downloads available at JBoss Tools 4.19.1 AM1.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

Improved OpenShift Application explorer

When the OpenShift cluster has no applications or projects, user is required to create them. However, it may not be obvious for the user that the corresponding function is available from a sub menu of the New context menu.

So now, a link will be provided within the tree with an explanation message.

If no projects are available, user will be guided to create one:

application explorer enhanced navigation1

If no applications are available in a project, user will be guided to create a new component:

application explorer enhanced navigation2

Hibernate Tools

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

Runtime Provider Updates

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

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.19.0.AM1 for Eclipse 2021-03

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.19.0.AM1 (Developer Milestone 1) build for Eclipse 2021-03.

Downloads available at JBoss Tools 4.19.0 AM1.

What is New?

Full info is at this page. Some highlights are below.

OpenShift

Browser based login to an OpenShift cluster

When it comes to login to a cluster, OpenShift Tools supported two different authentication mechanisms:

  • user/password

  • token

The drawback is that it does not cover clusters where a more enhanced and modern authentication infrastructure is in place. So it is now possible to login to the cluster through an embedded web browser.

In order to use it, go to the Login context menu from the Application Explorer view:

weblogin1

Click on the Retrieve token button and an embedded web browser will be displayed:

weblogin2

Complete the workflow until you see a page that contains Display Token:

weblogin3

Click on Display Token:

The web browser is automatically closed and you’ll notice that the retrieved token has been set in the original dialog:

weblogin4

Devfile registries management

Since JBoss Tools 4.18.0.Final, the preferred way of developing components is now based on devfile, which is a YAML file that describe how to build the component and if required, launch other containers with other containers. When you create a component, you need to specify a devfile that describe your component. So either you component source contains its own devfile or you need to pick a devfile that is related to your component. In the second case, OpenShift Tools supports devfile registries that contains a set of different devfiles. There is a default registry (https://github.com/odo-devfiles/registry) but you may want to have your own registries. It is now possible to add and remove registries as you want.

The registries are displayed in the OpenShift Application Explorer under the Devfile registries node:

registries1

Please note that expanding the registry node will list all devfiles from that registry with a description:

registries2

A context menu on the Devfile registries node allows you to add new registries, and on the registry node to delete it.

Devfile enhanced editing experience

Although devfile registries can provide ready-to-use devfiles, there may be some advanced cases where users need to write their own devfile. As the syntax is quite complex, the YAML editor has been completed so that to provide:

  • syntax validation

  • content assist

Support for Python based components

Python-based components were supported but debugging was not possible. This release brings integration between the Eclipse debugger and the Python runtime.

Hibernate Tools

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

Runtime Provider Updates

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

Server Tools

Wildfly 23 Server Adapter

A server adapter has been added to work with Wildfly 23.

EAP 7.4 Beta Server Adapter

The server adapter has been adapted to work with EAP 7.4 Beta.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

JBoss Tools 4.18.0.AM1 for Eclipse 2020-09

by jeffmaury at December 30, 2021 08:47 AM

Happy to announce 4.18.0.AM1 (Developer Milestone 1) build for Eclipse 2020-09.

Downloads available at JBoss Tools 4.18.0 AM1.

What is New?

Full info is at this page. Some highlights are below.

Quarkus

Support for codestarts in New Quarkus project wizard

code.quarkus.io has added a new option codestart that allows extension that support this new feature to contribute sample code in the generated project. It is enabled by default and is accessible from the second step in the wizard:

quarkus30

OpenShift

Devfile based deployments

The Application Explorer view is now based on odo 2.x, which allows deployments to be based on devfile (developer oriented manifest file). The components from the default odo registry are listed with legacy S2I components:

devfile

It is also now possible to bootstrap from an empty project as the components from the registry may expose starter projects (sample code that will initialize your empty project).

devfile1

Hibernate Tools

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

Runtime Provider Updates

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

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

Server Tools

Wildfly 22 Server Adapter

A server adapter has been added to work with Wildfly 22.

CDI Tools

Eclipse Microprofile support

CDI Tools now support Eclipse Microprofile. Eclipse Microprofile related assets are checked against @Inject injections points and are validated according to rules specified in various Eclipse Microprofile specifications.

Forge Tools

Forge Runtime updated to 3.9.8.Final

The included Forge runtime is now 3.9.8.Final.

Enjoy!

Jeff Maury


by jeffmaury at December 30, 2021 08:47 AM

Conditionally direct retrieving API calls to either live or twin channel

December 22, 2021 12:00 AM

After the added option to target the live channel by adding the channel=live to HTTP requests (see also blog post about “HTTP live channel”), Eclipse Ditto version 2.3.0 will in addition support to define a live channel condition, which, when evaluating to true, will retrieve data from a device via the live channel, or fall back to the persisted twin otherwise.

Note: In order to use the live channel, the device receiving live commands must be able to understand and answer in Ditto Protocol messages with the topic’s channel being live.

Relying on conditions

Ditto 2.1.0 added support for conditional requests by e.g. specifying a condition query parameter for HTTP API calls.

This mechanism can now additionally be used to formulate a condition through the query parameter live-channel-condition whether data shall be retrieved via the live channel from the device.

Optionally update twin automatically based on retrieved live data

Whenever a device reports back its actual sensor readings, one can be sure that this data is the most recent “truth”.
It therefore is obvious to use that data in order to update the persisted twin managed by Ditto.

This can optionally be enabled by configuring the new UpdateTwinWithLiveResponse mapper in a Ditto managed connection.
This mapper will transform each “live response” retrieving and transporting data from a device to an additional merge command modifying the twin with that live data.

Example: Device is marked to be polled

This is for example helpful if the device does not push its newest sensor readings actively into its twin representation managed by Ditto, but relies on being polled for the newest readings.
In that case, the twin could be marked e.g. as attributes/polling-mode=true:

{
  "thingId": "my.namespace:my-polling-device-1",
  "policyId": "my.namespace:my-polling-device-1",
  "attributes": {
    "polling-mode": true
  },
  "features": {
    "temperature": {
      "properties": {
        "value": 23.42
      }
    }
  }
}

When an IoT application now needs to retrieve the latest temperature value, it can formulate a query (e.g. in HTTP):

GET /api/2/things/my.namespace:my-polling-device-1/features/temperature/properties/value
  ?live-channel-condition=eq(attributes/polling-mode,true)
  &timeout=10s
  &live-channel-timeout-strategy=use-twin

The specified live-channel-condition will evaluate to true, meaning that the retrieve is transformed to a live command and sent to the device, e.g. connected via a managed connection.
Upon receiving the “live retrieve” at the device, the device can create a command response correlated with the same correlation-id and send it back to Ditto with the current value.
This value is then returned as result of the GET, the HTTP response header channel will indicate that the data was sent by the device by having the value live.

If the device does not answer with a correctly correlated response within the given timeout, the request will fall back to the twin channel, retrieving the data from the last known persisted temperature value in the twin managed by Ditto.
The HTTP response header channel will indicate that the data was received by the persisted twin by having the value twin.

Example: Device contains a connection status

Another perfect fit for that feature is when the device (or the device connectivity layer) is able to reflect the connection status of the device in the Ditto managed twin.
When e.g. using Eclipse Hono in combination with Ditto, the ConnectionStatus mapper can be configured in a Ditto managed connection which will automatically update a feature in the twin based on Hono’s device notifications reflecting a "readySince" and "readyUntil" timestamp:

{
  "thingId": "my.namespace:my-connection-aware-device-1",
  "policyId": "my.namespace:my-connection-aware-device-1",
  "features": {
    "ConnectionStatus": {
      "definition": [ "org.eclipse.ditto:ConnectionStatus:1.0.0" ],
      "properties": {
        "status": {
          "readySince": "2021-12-22T14:16:18Z",
          "readyUntil": "9999-12-31T23:59:59Z"
        }
      }
    },
    "temperature": {
      "properties": {
        "value": 23.42
      }
    }
  }
}

In that case, the "readyUntil" will contain a timestamp how long the device will be ready to receive commands, the timestamp "9999-12-31T23:59:59Z" being an alias for indefinitely (once the device disconnects, e.g. from the MQTT adapter of Eclipse Hono, this timestamp will be set to the disconnection time).

Utilizing this “connection awareness”, we can now easily define a query to retrieve data from the real device when it is connected and use the persisted twin when it is not connected or runs into a timeout.
For using the current time as ISO-8601 timestamp, a new placeholder time:now was also introduced, usable in RQL expressions everywhere in Ditto:

GET /api/2/things/my.namespace:my-connection-aware-device-1/features/temperature/properties/value
  ?live-channel-condition=gt(features/ConnectionStatus/properties/status/readyUntil,time:now)
  &timeout=10s
  &live-channel-timeout-strategy=use-twin

Of course every other field in the persisted twin may also be used in the live-channel-condition, if your devices e.g. are aware if they are connected or not by other means (e.g. by setting an attribute), this can be utilized as well.

Feedback?

Please get in touch if you have feedback or questions towards this new functionality.



Ditto


The Eclipse Ditto team


December 22, 2021 12:00 AM

Xmas Clean Sheet Update (0.9)

by Frank Appel at December 21, 2021 04:29 PM

Written by Frank Appel

The Xmas Clean Sheet update introduces a new theme derivate. Welcome the glare effect reducing Cream theme!

The Clean Sheet Eclipse Design

In case you've missed out on the topic and you are wondering what I'm talking about, here is a screenshot of my real world setup using the Clean Sheet theme (click on the image to enlarge). Eclipse IDE Look and Feel: Clean Sheet Screenshot For more information please refer to the features landing page at http://fappel.github.io/xiliary/clean-sheet.html, read the introductory Clean Sheet feature description blog post, and check out the New & Noteworthy page.

Introducing Cream

The original Clean Sheet theme can sometimes still be susceptible to glaring effects. How much depends among other things on the monitor brightness, the ambient lighting, and the sensitivity of the user’s eye. The Cream theme reduces the background color’s proportion of blue. As a result, glare is diminished. Otherwise, it has the same feature set as the Clean Sheet theme and is available on Windows and Mac. If you are experiencing interfering glaring effects on bright monitor screens while working with light themes on Eclipse, consider giving Cream a try.

Click on the image for full size screenshot

Discontinuation of Dark Theme and Windows Theme with Flat-Scrollbars

With the intent to reduce maintenance effort, the Dark and Windows themes are no longer available. There are Eclipse dark themes that incorporate the Clean Sheet Flat-Scrollbars technology, for example, the eclipse-planet-themes or the DevStyle theme. As there is a new Eclipse default theme available now for a while, the windows 7 theme adaption looked pretty much dated …

Bug Fixes

This update resolves an oddment of the ruler numbers issue fix #87. Kudos to Pierre-Yves B. for contributing the initial fixes. Furthermore, there is a syntax highlighting for keywords adjustment to support Java 16 records. Please refer to issues #103 and #107 for more details.

Clean Sheet / Cream Installation

Drag the 'Install' link below to your running Eclipse instance

Drag to your running Eclipse* workspace. *Requires Eclipse Marketplace Client

or

Select Help > Install New Software.../Check for Updates.
P2 repository software site: @ http://fappel.github.io/xiliary/
Feature: Code Affine Theme

After feature installation and workbench restart select the ‘Clean Sheet’ / 'Cream' theme:
Preferences: General > Appearance > Theme: Clean Sheet / Cream

 

Dark Mode vs. Light Mode: Which Is Better?

Recently, I stumbled across an interesting research article by the Nielsen Norman Group in the context of the work on Cream. It examines the advantages and disadvantages of dark and light modes. So, in case you wonder how much of the trend toward dark UI modes is justified from a scientific point of view I recommend the read (https://www.nngroup.com/articles/dark-mode/).

Finally…

Of course, it’s interesting to hear suggestions or find out about further potential issues that need to be resolved. Feel free to use the Xiliary Issue Tracker or the comment section below for reporting.

With this in mind, I’d like to thank all the new and long term Clean Sheet / Cream adopters for the support and wish everybody a Merry Christmas and a Happy New Year :-)

Title Image: © Depositphotos.com/zphoto

The post Xmas Clean Sheet Update (0.9) appeared first on Code Affine.


by Frank Appel at December 21, 2021 04:29 PM

Migrating Eclipse-based Tools/Plugins to Eclipse Theia or VSCode

by Jonas, Maximilian & Philip at December 21, 2021 01:48 PM

Do you have an existing tool based on Eclipse RCP or a plugin for the Eclipse Desktop IDE? Do you wonder...

The post Migrating Eclipse-based Tools/Plugins to Eclipse Theia or VSCode appeared first on EclipseSource.


by Jonas, Maximilian & Philip at December 21, 2021 01:48 PM

Build Kubernetes controllers with Fabric8 Kubernetes Client, Quarkus, and JKube

December 21, 2021 01:00 PM

Introduction

Josh Long, one of my favorite Java champions and advocates, has recently published an article showing how to create a simple Kubernetes controller using Spring Boot Native and the Official Kubernetes Client.

Since this is one of my favorite topics, and I'm currently working on the Fabric8 Kubernetes Client, I thought it would be nice to create a port of his example using Fabric8 Kubernetes Client , Quarkus and Eclipse JKube instead. The structure of the original post has also been replicated so that the differences for each part can be easily spotted.

Please, don't take this post as an xxx is better than zzz article. The intention of the article is to showcase the available alternatives so that developers can mix and match whatever they like. I think that we are living a great moment for Java and that having so many choices for anything cloud-related is making Java shine again.

Fabric8 Kubernetes Client

The Fabric8 Kubernetes Client is an automatically code-generated Java client for the Kubernetes API. Quarkus has a built-in extension to support the Fabric8 client both in JVM and native mode, so your only concern should be to add the extension's dependency (and taking a little bit of care with generics).

<dependency>
  <groupId>io.quarkus</groupId>
  <artifactId>quarkus-kubernetes-client</artifactId>
</dependency>

Example KubernetesControllerApplication

1package com.marcnuri.demo.booternetes.port;
2
3import io.fabric8.kubernetes.api.model.ListOptionsBuilder;
4import io.fabric8.kubernetes.api.model.Node;
5import io.fabric8.kubernetes.api.model.Pod;
6import io.fabric8.kubernetes.client.KubernetesClient;
7import io.fabric8.kubernetes.client.KubernetesClientException;
8import io.fabric8.kubernetes.client.informers.ResourceEventHandler;
9import io.fabric8.kubernetes.client.informers.SharedIndexInformer;
10import io.fabric8.kubernetes.client.informers.SharedInformerFactory;
11import io.quarkus.runtime.Quarkus;
12import io.quarkus.runtime.QuarkusApplication;
13import io.quarkus.runtime.ShutdownEvent;
14import io.quarkus.runtime.annotations.QuarkusMain;
15
16import javax.enterprise.context.ApplicationScoped;
17import javax.enterprise.event.Observes;
18import javax.inject.Inject;
19import javax.inject.Singleton;
20import java.util.Objects;
21
22@QuarkusMain
23public class KubernetesControllerApplication implements QuarkusApplication {
24
25  @Inject
26  KubernetesClient client;
27  @Inject
28  SharedInformerFactory sharedInformerFactory;
29  @Inject
30  ResourceEventHandler<Node> nodeEventHandler;
31
32  @Override
33  public int run(String... args) throws Exception {
34    try {
35      client.nodes().list(new ListOptionsBuilder().withLimit(1L).build());
36    } catch (KubernetesClientException ex) {
37      System.out.println(ex.getMessage());
38      return 1;
39    }
40    sharedInformerFactory.startAllRegisteredInformers().get();
41    final var nodeHandler = sharedInformerFactory.getExistingSharedIndexInformer(Node.class);
42    nodeHandler.addEventHandler(nodeEventHandler);
43    Quarkus.waitForExit();
44    return 0;
45  }
46
47  void onShutDown(@Observes ShutdownEvent event) {
48    sharedInformerFactory.stopAllRegisteredInformers(true);
49  }
50
51  public static void main(String... args) {
52    Quarkus.run(KubernetesControllerApplication.class, args);
53  }
54
55  @ApplicationScoped
56  static final class KubernetesControllerApplicationConfig {
57
58    @Inject
59    KubernetesClient client;
60
61    @Singleton
62    SharedInformerFactory sharedInformerFactory() {
63      return client.informers();
64    }
65
66    @Singleton
67    SharedIndexInformer<Node> nodeInformer(SharedInformerFactory factory) {
68      return factory.sharedIndexInformerFor(Node.class, 0);
69    }
70
71    @Singleton
72    SharedIndexInformer<Pod> podInformer(SharedInformerFactory factory) {
73      return factory.sharedIndexInformerFor(Pod.class, 0);
74    }
75
76    @Singleton
77    ResourceEventHandler<Node> nodeReconciler(SharedIndexInformer<Node> nodeInformer, SharedIndexInformer<Pod> podInformer) {
78      return new ResourceEventHandler<>() {
79
80        @Override
81        public void onAdd(Node node) {
82          // n.b. This is executed in the Watcher's  WebSocket Thread
83          // Ideally this should be executed by a Processor running in a dedicated thread
84          // This method should only add an item to the Processor's queue.
85          System.out.printf("node: %s%n", Objects.requireNonNull(node.getMetadata()).getName());
86          podInformer.getIndexer().list().stream()
87            .map(pod -> Objects.requireNonNull(pod.getMetadata()).getName())
88            .forEach(podName -> System.out.printf("pod name: %s%n", podName));
89        }
90
91        @Override
92        public void onUpdate(Node oldObj, Node newObj) {}
93
94        @Override
95        public void onDelete(Node node, boolean deletedFinalStateUnknown) {}
96      };
97    }
98  }
99}

This is a very simple example application that iterates through the Pod instances and prints their name whenever a Node is added (or the existent Nodes when the application starts).

It's a port of the original post's application and I tried to structure it in a very similar way to achieve the same result and keep the code visually similar.

You can compile the application to a native executable by running:

mvn -Pnative clean package

If you run the application you will get an output similar to:

$ ./target/kubernetes-controller-0.0.1-SNAPSHOT-runner
__  ____  __  _____   ___  __ ____  ______ 
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
2021-12-21 10:59:46,834 INFO  [io.quarkus] (main) kubernetes-controller 0.0.1-SNAPSHOT native (powered by Quarkus 2.5.2.Final) started in 0.020s. Listening on: http://0.0.0.0:8080
2021-12-21 10:59:46,834 INFO  [io.quarkus] (main) Profile prod activated. 
2021-12-21 10:59:46,834 INFO  [io.quarkus] (main) Installed features: [cdi, kubernetes-client, resteasy-jackson, smallrye-context-propagation, vertx]
node: fv-az210-846
pod name: kube-apiserver-fv-az210-846
pod name: kubernetes-controller-c44477d9b-zd4pt
pod name: kube-proxy-9sz5l
pod name: storage-provisioner
pod name: etcd-fv-az210-846
pod name: kube-scheduler-fv-az210-846
pod name: coredns-64897985d-49w7x
pod name: kube-controller-manager-fv-az210-846

That's 20 milliseconds, or 20 thousandths of a second. In addition, the resulting application takes up a trivially small memory footprint, 23.5 MiB of RAM.

Creating a container image (Docker Image)

Quarkus has several extensions to create Docker/Container images. However, since I'm part of the team maintaining JKube, I'll show you how to perform the full Kubernetes experience with JKube's Kubernetes Maven Plugin.

In this case, the only necessary step is to add the required dependency to the plugins section:

<plugin>
  <groupId>org.eclipse.jkube</groupId>
  <artifactId>kubernetes-maven-plugin</artifactId>
  <version>1.5.1</version>
</plugin>

You can now create the image by running:

mvn -Pnative k8s:build

JKube automatically detects the native profile and creates a tiny distribution using Red Hat's UBI minimal image.

Kubernetes resource manifest generation (YAML)

For this part, JKube also infers the configuration and generates the required configuration YAML files. For any standard project you wouldn't really need to add any extra configuration.

Cluster Role Binding and Role

However, in this case we need to access the underlying cluster API, so we need to authorize the Pod's service account via RBAC.

The original article binds the service account to the cluster-admin role which can be dangerous. To keep things simple we're just going to create a new cluster role with read access to Pods and Nodes, and bind it to the default Service Account. It would be better to create a specific Service Account too.

To achieve this we'll add two fragments for the Cluster Role and the Cluster Role Binding that JKube will pick up and merge with the rest of generated resources:

Cluster Role src/main/jkube/kubernetes-controller-java-cr.yaml

1rules:
2  - apiGroups: [""]
3    resources:
4      - nodes
5      - pods
6    verbs:
7      - list
8      - get
9      - watch

Cluster Role Binding src/main/jkube/kubernetes-controller-java-crb.yaml

1subjects:
2  - kind: ServiceAccount
3    name: default
4    namespace: ${jkube.namespace}
5roleRef:
6  apiGroup: rbac.authorization.k8s.io
7  kind: ClusterRole
8  name: kubernetes-controller-java

Namespace

To keep things clean, we're going to create a dedicated Namespace for our application. To achieve this with JKube we only need to provide the following Maven properties:

<jkube.namespace>kubernetes-controller-java</jkube.namespace>
<jkube.enricher.jkube-namespace.namespace>${jkube.namespace}</jkube.enricher.jkube-namespace.namespace>

Deploying to Minikube

The original article deploys the application to a Google Cloud Kubernetes environment (GKE), however I don't have any GKE cluster available. In this case I will show you how to deploy to Minikube.

To skip pushing the image to a container image registry we can share Minikube's Docker daemon by invoking the following command and build the image directly on Minikube:

eval $(minikube docker-env)

Next we can build, generate application manifests and deploy them to our cluster by running:

mvn -Pnative k8s:build k8s:resource k8s:apply

Here's a trivial GitHub Actions file that performs the mentioned steps and deploys them to a dedicated Minikube cluster:

name: Deploy Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  deploy-and-test:
    name: Deploy and Test
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Setup Minikube-Kubernetes
        uses: manusa/actions-setup-minikube@v2.4.3
        with:
          minikube version: v1.24.0
          kubernetes version: v1.23.0
          github token: ${{ secrets.GITHUB_TOKEN }}
      - name: Setup Java 17
        uses: actions/setup-java@v2
        with:
          java-version: '17'
          distribution: 'temurin'
      - name: Build
        run: mvn -Pnative package
      - name: Run and test from host
        run: timeout 5s ./target/kubernetes-controller-0.0.1-SNAPSHOT-runner > out.txt || grep "node:" out.txt
      - name: Deploy
        run: mvn -Pnative k8s:build k8s:resource k8s:apply
      - name: Test Deployment
        run: |
          kubectl wait --for=condition=available --timeout=60s --namespace kubernetes-controller-java deployments.apps/kubernetes-controller
          kubectl logs --namespace kubernetes-controller-java --tail=-1 --selector app=kubernetes-controller | grep "node:"
      - name: Print Application Logs
        run: |
          kubectl logs --namespace kubernetes-controller-java --tail=-1 --selector app=kubernetes-controller

Conclusion

As you can see, generating and deploying a Java Kubernetes controller with Quarkus and JKube can be even easier than with Go and just as performant thanks to GraalVM.

As Josh said in his original blog post, it's a great time to be alive. Again, I want to remark that this is not a Spring vs. Quarkus post. The intention is to show the amount of choices Java developers have these days and that Java is still alive and Kicking.

You can find the full source code for this post at GitHub.


December 21, 2021 01:00 PM

Sending live channel commands via HTTP to devices

December 20, 2021 12:00 AM

The upcoming release of Eclipse Ditto version 2.3.0 will support sending commands via the HTTP API directly to devices using the live channel by just adding the channel=live query parameter to the same HTTP API request which would target the twin.

HTTP Live channel

Ditto supports sending all kind of Thing commands via the live channel directly to devices. When sending a live command to a device, the device is responsible for sending a correlated and correct response in Ditto Protocol.

Ditto supports two types of channels for communication.

  • twin: The default value of the channel parameter is twin to communicate with the persisted twin representation.
  • live: The channel parameter can be changed to live to communicate with the real device.
Note: In order to use the live channel, the device receiving live commands must be able to understand and answer in Ditto Protocol messages with the topic’s channel being live.

When using the twin channel, the command is routed to the Ditto backend and handled by the twin persistence. Before using the live channel, it is necessary to create the digital twin of the device in the Ditto backend.

If the live channel is used, the command is directly routed to the device. In this case the device is responsible for answering the command and sending back a response. In case no response is sent back, the Ditto HTTP API is responding with 408 Request Timeout.
The default timeout for live commands is 10s but it can be changed by setting the timeout parameter to the desired value.

Ditto ensures that the correlation ID, entity ID, path and command response type of the command response is the same as in the sending command. If this is not the case, Ditto is dropping the response and the caller of the HTTP request will get a 408 Request Timeout with a message that the timeout was caused by an incompatible command response from the device.

Permissions for live commands

Sending live commands to devices is restricted by the policy of the thing.
Thus Ditto ensures that only authorized parties with WRITE permission are able to send commands or messages.
Ditto also filters responses from the device based on the policy. This ensures that the requester only gets the data where he/she has READ permission on.

For retrieve commands, the authenticated subject needs to have (at least partial) READ permission at the resource which is requested.
In case a RetrieveThing (via HTTP a GET /api/2/things/<thing-id>) command is sent to a real device and the requester only has partial READ permission on the thing, the response is filtered based on the policy and only the fields where READ permission is granted are returned.

Live commands via HTTP API

When using the HTTP API the channel parameter can either be specified via HTTP Header or via HTTP query parameter.
In the examples below both ways are possible to specify the channel parameter.

Live command with HTTP Header

curl -X GET -H 'channel: live' -H 'timeout: 30s' /api/2/things/org.eclipse.ditto:coffeebrewer'

Live command with HTTP query parameter

curl -X GET /api/2/things/org.eclipse.ditto:coffeebrewer?channel=live&timeout=30s'

Example

The following section provides an example how to use the HTTP live channel together with the Ditto Java client.

For demonstration purpose, we assume that the thing with ID org.eclipse.ditto:outdoor-sensor already exists.

In this example we want to retrieve the live state of the device by sending a RetrieveThing command via the live channel directly to the device.

Permissions to execute the example

For this example, the authenticated subject has READ and WRITE permissions on the complete thing resource to send the command and retrieve the full response.

Executing the example

When sending a command over the live channel to a device, the device needs to take action and send back a response.
The response from the device is routed back to the initial requester of the live command at the HTTP API.

In this example the Ditto Java Client acts as device and sends back the response.
The following snippet shows how to register for retrieve thing live commands and send back a RetrieveThingResponse.

String thingId = "org.eclipse.ditto:outdoor-sensor";
String featureId = "environment-sensor";
Attributes attributes = Attributes.newBuilder()
  .set("location", "outdoor in the woods")
  .build();
Feature feature = ThingsModelFactory.newFeatureBuilder()
  .properties(ThingsModelFactory.newFeaturePropertiesBuilder()
    .set("temperature", 9.2)
    .set("humidity", 56.3)
    .build())
  .withId(featureId)
  .build();

Thing thing = ThingsModelFactory.newThingBuilder()
  .setId(thingId)
  .setFeature(feature)
  .setAttributes(attributes)
  .build();

// initialize the ditto-client and startConsumption() of live commands
DittoClient dittoClient = ... ;

dittoClient.live()
  .forId(thingId)
  .handleRetrieveThingCommandsFunction(retrieveThingLiveCommand -> {
      return retrieveThingLiveCommand.answer()
                  .withResponse(response -> response.retrieved(thing));
  });

When the above shown code snippet is running and the following HTTP request is sent out:

curl -X GET /api/2/things/org.eclipse.ditto:outdoor-sensor?channel=live&timeout=15s

The received HTTP response payload should look like this:

{
  "thingId": "org.eclipse.ditto:outdoor-sensor",
  "_namespace": "org.eclipse.ditto",
  "attributes": {
    "location": "outdoor in the woods"
  },
  "features": {
    "environment-sensor": {
      "properties": {
        "temperature": 9.2,
        "humidity": 56.3
      }
    }
  }
}

Feedback?

Please get in touch if you have feedback or questions towards this new functionality.



Ditto


The Eclipse Ditto team


December 20, 2021 12:00 AM

IoT & Edge Developer Priorities and Challenges

by Mike Milinkovich at December 16, 2021 02:00 PM

The results of the Eclipse Foundation’s seventh annual IoT & Edge Developer Survey have been compiled and the report is available to download. As in previous years, this year’s survey provides important insights into developer trends and challenges, platform choices, and target markets. 

Administered by the Eclipse IoT Working Group, the Edge Native Working Group, and the Sparkplug Working Group, this year’s survey was conducted over a period of seven weeks, starting in late August. We received responses from more than 660 developers, committers, architects, and decision-makers from a broad set of industries and organizations globally. 

What Technologies are Developers Choosing?

  • IoT and edge developers told us they’re using C and C++ for constrained devices, but prefer Python over Java for edge servers, IoT and edge gateways, and cloud platform development.
  • MQTT has emerged as the clear leader in industrial IoT (IIoT) communications protocols. It showed solid growth in adoption over the past year, while protocols such as REST, HTTP/HTTPS, and TCP/IP showed a significant decline in IIoT usage compared to 2020.
  • AWS IoT is the preferred middleware, with a significant lead over Microsoft Azure IoT and Google Cloud IoT Platform.
  • Artificial intelligence is still the most frequently selected edge computing workload.
  • While Arm continues to dominate hardware architectures for constrained devices, gateways, and edge servers, RISC-V and OpenHW Group CORE-V architectures are showing strong market share gains.

Industrial Automation Is the Top Industry Focus Area

While industrial automation has displaced smart agriculture as the leading industry focus area, that doesn’t mean efforts on smart agriculture applications are dropping off. In fact, developer focus on smart agriculture rose seven percent from the 2020 survey results. However, focus on industrial automation rose 13 percent, indicating a sharp increase in demand for these types of applications.

Building automation, emergency management, and smart cities rounded out the top five industry focus areas.

Security Is the Top Concern

Almost half of this year’s survey respondents cited security as their primary worry when developing IoT and edge applications. However, concerns about connectivity, deployment, and integration complexity also rose this year, painting a picture of a changing landscape.

The results underscore the challenges developers face in determining which are the right technologies for the job. They also indicate that more IoT and edge solutions are moving past the proof-of-concept phase as developers look for technologies that help them optimize and integrate production systems to deliver better user experiences.

Get Involved in Eclipse IoT & Edge Native Communities

To stay current with the happenings in the Eclipse IoT Working Group, join the mailing list here.

To join the Eclipse Edge Native Working Group conversation on Slack, click here.

Read the Full Report

For detailed insights, Download the IoT & Edge Developer Survey Results 


by Mike Milinkovich at December 16, 2021 02:00 PM

Internationalization in Eclipse Theia

by Brian King at December 16, 2021 12:12 PM

This post was written by Mark Sujew, Software Engineer at TypeFox

What?

Internationalization (i18n) aims to provide the necessary infrastructure in an application to translate it into different languages/locales. It has been a frequently requested feature for Theia, especially considering that most modern software supports different locales in one way or another.

Why?

Even though some attempts by contributors have been made in the past, as of mid 2021 still Theia had no support for different locales. Arduino has addressed this with the all new Arduino IDE based on Theia. Having supported Arduino previously with their IDE, they tasked TypeFox with contributing this feature to Theia.

Implementation Positives and Challenges

Of course, the main technical inspiration for this feature has been VSCode’s i18n implementation. In short: Inside of VSCode, every user-facing string is translated using a ‘localize’ function call that accepts a key and the English default value. A special build process reads these function calls and extracts every key and default value into a JSON file. These files are then translated, and each placed inside of a dedicated VSCode extension, dubbed as a “Language Pack”.

To keep the maintenance effort for Theia as low as possible, the i18n feature supports VSCode’s language packs to localize Theia. The main challenge here was correctly identifying the keys used in VSCode and using them to translate Theia. Luckily, after going through the process of finding them all, around 85% of Theia was already translated by simply installing a VSCode language pack.

Localizing the monaco-editor and the extension host were also challenges. The former uses an index based approach for localization instead of using string keys, while the latter uses the ‘vscode-nls’ package, whose inner workings are only sparsely documented, requiring some reverse-engineering.

What’s Next?

With Theia version 1.19, most of the framework is translated using language packs, while strings that are custom to Theia are still only available in English. Going into the next months, we plan to integrate a translation pipeline into Theia’s development process and thereby localize Theia into the most commonly used languages.

You can try it out by opening Theia in Gitpod or cloning and compiling it yourself. After installing a language pack of your choice by searching for the language in the extensions tab and downloading it from the Open-VSX registry (see Chinese or French), run the Configure Display Language command and select your desired language. Theia will automatically reload itself and you’ll be presented with a translated user interface.

Theia in Chinese

Theia with a partial Chinese locale

How to Get Involved?

As always, feedback and questions regarding Theia features are appreciated. The easiest way to do that is by filing a feature request issue or creating a Q&A discussion, respectively on GitHub. Be aware that text that is custom to Theia is not yet translated. This will be addressed in the following months.


by Brian King at December 16, 2021 12:12 PM

Community Perspective: 20 Years of the Eclipse IDE

by Jacob Harris at December 16, 2021 10:00 AM

To help us celebrate 20 years of the Eclipse IDE, we reached out to some of the community members who use and contribute to the platform to find out why they got involved, what they’ve learned so far, and what they expect for the future.

by Jacob Harris at December 16, 2021 10:00 AM

Internationalization in Eclipse Theia

by Christopher Guindon (webdev@eclipse-foundation.org) at December 16, 2021 12:00 AM

Even though some attempts by contributors have been made in the past, as of mid 2021 still Theia had no support for different locales. Arduino has addressed this with the all new Arduino IDE based on Theia. Having supported Arduino previously with their IDE, they tasked TypeFox with contributing this feature to Theia.

by Christopher Guindon (webdev@eclipse-foundation.org) at December 16, 2021 12:00 AM

The Eclipse Foundation Is Your Destination For Commercial-Friendly Open Source Projects

by waynebeaton at December 15, 2021 02:16 PM

As  a member of the Eclipse Foundation, you already know the value of making a project open source. Open source allows organizations to participate in a thriving developer community, while sharing the costs of innovation and focusing their resources on building differentiated features that customers value. 

However, all open source organizations are not created equal and certain objectives will be better met by partnering with one that best aligns with your organizational needs. For example, if your objective is to drive broad adoption with commercial-friendly production ready code, the Eclipse Foundation is the right choice 

Creating a Commercial-Friendly Environment For Open Source

The Eclipse Foundation provides key services to support and grow open source projects, while leaving your organization’s developers free to focus on writing code. Our focus is on enabling commercial ecosystems around open source technology. The Foundation does this by providing processes and practices that maximize opportunities to work in a truly open and transparent manner, and minimize the risks associated with copyright and licensing.

Here are just a few of the reasons that bringing your open source projects to the Eclipse Foundation makes good business sense:

Vendor-Neutral Process: The Eclipse Foundation Development Process, describes principles and practices to manage the open source project lifecycle in a consistent open, transparent, meritocratic, and vendor-neutral manner. In essence, the Eclipse Foundation Development Process describes a vendor-neutral “level playing field” that encourages diverse and collaborative open source, mitigating the risk of domination by any single party. This means that your developers’ ideas and contributions are just as valuable as everyone else’s.

Intellectual Property and Due Diligence: The Eclipse Foundation provides robust contributor and committer agreement management. The Eclipse Foundation’s Intellectual Property Due Diligence Process provides support to project teams for reviewing large contributions, and ensuring that all third party content is available under terms that are compatible with the project license, and — ultimately — commercial adoption.

Collaborative Working Group Structure: Eclipse Foundation Working Groups provide a means for Eclipse Projects to collaborate at higher levels. Working groups, for example, organise our annual simultaneous release which makes it easier for downstream consumers to adopt new Eclipse IDE releases; and provide us with a means to host vendor neutral services like the Eclipse Marketplace and the OpenVSX registry, and specification branding programs that enable project teams working on specifications to engage with a broad community of adopters and implementers. 

Infrastructure Support: To provide reliable and scalable service for committers working on projects and consumers who use the technology, the Eclipse Foundation manages the IT infrastructure for each project. This includes managing Git code repositories and code review tools, issue trackers, Jenkins build farms, developer-oriented mailing lists and forums, and websites. 

Marketing and Ecosystem Development Support: The Eclipse Foundation also provides vendor-neutral marketing and ecosystem development services to help get projects in front of the right audiences and support their growth. Our creative team assists in the development of logos and graphics, helping you develop a brand identity that fits your project.

Like much of the Eclipse Foundation’s activity, community is at the forefront of our ecosystem development efforts. Participation from our passionate developer communities allows us to create content, ranging from webinars to white papers and newsletter articles, that illustrates how members are leveraging the power of open source to accomplish their goals.

The bottom line is that some of the most significant advantages that organizations and individual developers gain from open source can only be realized through participation in an open source organization that has underlying principles, processes, and practices that support vendor-neutral open collaboration and innovation, as opposed to simply sharing your code online.

How To Get Started

Do you have a project to host at the Eclipse Foundation? The first step is to submit a project proposal. The proposal must minimally include a description of the project, a declaration of scope, and a list of prospective members before we make it accessible to the public for community review. For more information on how to get started, see the Eclipse Foundation Project Handbook.
To experience these benefits and get the most out of open source, submit a project proposal.


by waynebeaton at December 15, 2021 02:16 PM

Diagram editors with Eclipse GLSP – towards 1.0

by Jonas, Maximilian & Philip at December 15, 2021 08:15 AM

Eclipse GLSP is a framework for building web-based diagram editors. These diagram editors can be embedded into Eclipse Theia, into VS...

The post Diagram editors with Eclipse GLSP – towards 1.0 appeared first on EclipseSource.


by Jonas, Maximilian & Philip at December 15, 2021 08:15 AM

The Eclipse Foundation Is Your Destination For Commercial-Friendly Open Source Projects

December 14, 2021 12:00 AM

As a member of the Eclipse Foundation, you already know the value of making a project open source. Open source allows organizations to participate in a thriving developer community, while sharing the costs of innovation and focusing their resources on building differentiated features that customers value. However, all open source organizations are not created equal and certain objectives will be better met by partnering with one that best aligns with your organizational needs.

December 14, 2021 12:00 AM

Eclipse Cloud DevTools Contributor Award: Improving the Migration Guide for Eclipse Theia

by Brian King at December 13, 2021 12:12 PM

The Eclipse Cloud Developer Tools contributor award this month goes to Evolved Binary for improving the migration guide and process for Eclipse Theia. As representatives, we want to acknowledge Charafeddine Cheraa, Duncan Paterson and Adam Retter. Congratulations and thanks for your contributions!

Contributor Award to Evolved Binary

Let us look at the details of this great contribution and its background. Eclipse Theia is a platform for building web-based tools and IDEs. It helps you efficiently develop and deliver multi-language Cloud & Desktop IDEs and tools with modern, state-of-the-art web technologies. As a platform, Theia is adopted by multiple parties to build their own custom tool offerings (see here for a list of adopters).

The Theia project is very active and delivers a release each month. This allows for a fast pace of innovation. Many core adopters that are also regular contributors integrate new versions very early in the process to evaluate new releases and provide initial feedback. In this process, necessary migration steps are discovered and often discussed among the committers. We call these core adopters “early adopters”.

However, the broader Eclipse Theia adopter base consists of projects that follow a much slower update strategy. This makes perfect sense. If you build a commercial tool offering based on Theia, which many vendors do, you do not need or want to upgrade every month. This type of adoption is actually much more common. We therefore call them “regular adopters”.For this type of adopter, necessary adaptations of new Theia versions can actually pile up over time. These necessary adaptations often also involve updates to underlying technologies, such as Webpack or JavaScript.

The issue that Evolved Binary discovered is that the information and experience gathered by the early adopters was actually not being made available for use by regular adopters. While the Theia project maintains a detailed change log, including any breaking changes, there was no document that collected the migration experience of adopters. Therefore, regular adopters had to rediscover the necessary steps during their migration. And, even worse, every adopter had to repeat this exercise.

How did Evolved Binary contribute to a solution to this problem? Very simple: They reported the issue! After contacting the project leads, they joined the weekly Theia developer meeting. There, they provided details of the issues and discussed potential solutions with the community. There were several great ideas on how to improve the situation, many of which are already in place. The most important one is probably the creation of a shared migration guide. This guide will be started during the development of a release. What is now new, is that it will also now be added to by adopters (especially the early adopters) to capture migration knowledge gathered during the adoption of new releases. This builds up a shared resource of information that all adopters can contribute to and benefit from. So if you are an adopter of Theia, please have a look at the migration guide and of course, please contribute to it!

So this award is assigned for reporting an issue? Absolutely yes! There are many things you can contribute to an open source project, with the most obvious one being source code. However, providing feedback is at least as important. This is especially true for a platform like Theia with so many adopters. It is hard for the core team to understand the needs of the so called “dark matter”, meaning unknown adopters not frequently in contact with the team. Raising issues in a constructive way, providing necessary details and even ideas how to solve issues allows projects to improve, from which all adopters benefit. Therefore, we want to thank Evolved Binary, especially Charafeddine Cheraa, Duncan Paterson and Adam Retter, for their great contribution and congratulate them for winning the Eclipse Cloud Developer Tools contributor award this month!

This Eclipse Cloud Developer Tools contributor award is sponsored by EclipseSource, providing consulting and implementation services for web-based tools and Eclipse Theia.


by Brian King at December 13, 2021 12:12 PM

Getting started with Eclipse Cloud Developer Tools

by Jonas, Maximilian & Philip at December 13, 2021 10:21 AM

Are you interested in building web- and cloud-based tools? Are you wondering what Eclipse Theia is, how it compares to VS...

The post Getting started with Eclipse Cloud Developer Tools appeared first on EclipseSource.


by Jonas, Maximilian & Philip at December 13, 2021 10:21 AM

Eclipse Cloud DevTools Contributor Award: Improving the Migration Guide for Eclipse Theia

by Christopher Guindon (webdev@eclipse-foundation.org) at December 13, 2021 12:00 AM

The Eclipse Cloud Developer Tools contributor award this month goes to Evolved Binary for improving the migration guide and process for Eclipse Theia.

by Christopher Guindon (webdev@eclipse-foundation.org) at December 13, 2021 12:00 AM

WTP 3.24 Released!

December 08, 2021 04:59 PM

The Eclipse Web Tools Platform 3.24 has been released! Installation and updates can be performed using the Eclipse IDE 2021-12 Update Site or through any of the related Eclipse Marketplace . Release 3.24 is included in the 2021-12 Eclipse IDE for Enterprise Java and Web Developers , with selected portions also included in several other packages . Adopters can download the R3.24 p2 repository directly and combine it with the necessary dependencies.

More news


December 08, 2021 04:59 PM

Celebrating Eclipse at 20

by Jacob Harris at December 08, 2021 04:34 PM

Today the Eclipse project and the Eclipse Foundation are shipping Eclipse IDE 2021‑12, the latest in a string of releases that go back to November 2001. How better to mark its 20th anniversary than to celebrate another release!

by Jacob Harris at December 08, 2021 04:34 PM

Celebrating Eclipse at 20

by Mike Milinkovich at December 08, 2021 02:12 PM

Today the Eclipse project and the Eclipse Foundation are shipping Eclipse IDE 2021‑12, the latest in a string of releases that go back to November 2001. How better to mark its 20th anniversary than to celebrate another release!

Last month we published a press release and a landing page to celebrate twenty years of Eclipse history, which we are augmenting today with a celebration video that includes great segments from Eclipse project leaders, both past and present. I highly recommend taking the time to watch it to learn about the history of this ground breaking open source project, as well as hearing where the community plans to take it in the future. And, definitely don’t miss the guitar solo at the end! I would like to thank the members of the original Eclipse project team who participated: Erich Gamma (Microsoft), John Duimovich (Red Hat), Steve Northover (IBM), and Paul Buck (Eclipse Foundation). I would also like to thank Sarika Sinha (IBM) and Mickael Istria (Red Hat), who joined the video to talk about the project today and who continue to make the Eclipse IDE a great platform for developers around the world. 

It is impossible to overstate the impact that the Eclipse IDE has had on the software industry, the open source community, and the Java ecosystem. Envisioned originally as “a kind of universal tool platform – an open extensible IDE for anything and nothing in particular”, The Eclipse project and platform can be celebrated for many milestones. Here are just a few:

  • The technology itself was groundbreaking. Using the Java language, while utilizing the desktop UI frameworks, made the Eclipse IDE a fast and attractive solution for the enterprise developers of the day. Don’t forget that the original design intent was to compete with Microsoft’s Visual Studio and ensure that the Java ecosystem had an ecosystem of professional tools. Coupling that with the most extensible architecture ever seen in a tooling platform made the Eclipse IDE perfect for its time. No one can dispute that the Eclipse IDE was part of the overall value equation that allowed Java to become dominant in the enterprise.
  • The Eclipse Rich Client Platform was based on the insight that if you could build desktop-portable IDEs, you could re-use that platform for building desktop-portable applications. Pre-dating the Web 2.0 technologies that we now all use, RCP was the go-to technology for building portable desktop applications in the enterprise for a decade. RCP was used extensively in banking, insurance, and healthcare (to name just a few) as the basis for the applications that millions of people used every day.
  • Language support was another key Eclipse win. Although to this day many developers think of the Eclipse IDE as Java-centric, it was used to create language IDEs for almost every available programming language. Today the Eclipse C/C++ Development Tools (CDT) project remains the dominant platform used by the embedded and RTOS markets for their developer tools. Arm, Renesas, Xilinx, ST Micro, NXP, etc. all ship Eclipse IDE-based products today.
  • The “Eclipse Way” of development, first described by Erich Gamma and John Weigand at EclipseCon so many years ago, explained how an open source project could sustainably deliver high quality code on a predictable schedule. And those processes still work today, as we celebrate yet another Eclipse IDE release delivered on time to the day. For over 16 years now, that highly predictable schedule delivered by an open source community has been a marvel of mature development processes embraced by a community.
  • While commonplace today, the Eclipse project was one of the first (if not the first) projects to consciously create a consortium of industry players in support of an open source community. It is hard to overstate how novel this was in 2001, when the professionalization of open source was an entirely new idea. I can confirm that the experiment was a success.

But none of this would have been possible without the hard work and dedication of literally hundreds of people over the years. Initially created by the IBM subsidiary Object Technology International, the Eclipse IDE in its early days was very much an IBM-led project. The Eclipse Foundation was created in 2004 as a vendor-neutral home for the project in order to help build trust amongst potential adopters, and to steward a community. By all measures that strategy was a success, with many IBM competitors joining the Eclipse Foundation and creating tools on top of the platform. After a few years, Eclipse adopters were a who’s who of the industry at the time, including BEA Systems, Blackberry, Borland, Computer Associates, Compuware, HP, Intel, Motorola, Nokia, Oracle, SAP, Sybase, and Wind River. 

The success in growing the Eclipse ecosystem resulted in an increase in potential contributors, and today the Eclipse Project is incredibly diverse with over a dozen different companies supporting committers on the project. On behalf of the entire community, I would like to thank each and every one of the committers and contributors who have and continue to make the Eclipse IDE a success.

And finally, twenty years is a long time. I would also like to thank and remember the team members who I knew personally that are no longer with us to enjoy this moment. Jeem and Dani, you are missed.


by Mike Milinkovich at December 08, 2021 02:12 PM

The Eclipse Foundation Releases 2021 IoT & Edge Developer Survey Results

by Jacob Harris at December 07, 2021 10:00 AM

– The world’s largest open source IoT community reveals developer trends focused on edge computing, AI, and security, with results detailing platform use, developer concerns, target markets, and more – 

BRUSSELS – DECEMBER 7, 2021 –  The Eclipse Foundation, the world’s largest open source foundation focused on the Internet of Things (IoT), today announced results from its 2021 IoT & Edge Developer Survey. Administered by the Eclipse IoT Working Group, the Eclipse Edge Native Working Group, and the Eclipse Sparkplug Working Group, the survey provides essential insights into IoT and edge computing industry landscapes, the challenges developers are facing, and the opportunities for enterprise stakeholders in the IoT & edge open source ecosystem. Now in its seventh year, the survey is the IoT & edge industry’s leading technical survey. 

“The IoT and edge computing go hand-in-hand with each technology influencing the other,” said Mike Milinkovich, executive director of the Eclipse Foundation. “Once again, this survey provides significant insights into what developers are working on and what challenges they face as we move into 2022.”

The online survey was conducted over a period of seven weeks (Aug 26, 2021 - October 12, 2021) during which time 662 global developers, committers, architects, and decision-makers from a broad set of industries and organizations participated. Key findings include:

  • Industrial automation has displaced smart agriculture as the leading vertical industry for IoT and edge computing technologies 
  • Security (46%), connectivity (38%) and deployment (31%) are the top three concerns for IoT developers 
  • C and C++ are the most widely used programming languages for constrained devices. Developers prefer Python over Java for edge servers, IoT & edge gateways, and cloud platform development
  • Artificial Intelligence (21%) remains the top edge computing workload, unchanged from 2020. However, the number of workloads diversified significantly.  
  • The IoT middleware market is dominated by AWS IoT (37%), Microsoft Azure IoT (27%), and Google Cloud IoT Platform (22%)
  • Message Broker-MQTT (44%) is the top technology used in messaging infrastructure 

The survey data also contains details around edge computing workloads,  developer concerns, and breakdowns by market. The entire report and its ground-breaking insights can be downloaded here.

Eclipse IoT’s knowledge and expertise spanning 10+ years of experience in the field of edge and IoT. Eclipse IoT is home to open source innovation that has delivered some of the industry’s most popular IoT protocols. CoAP (Eclipse Californium), DDS (Eclipse Cyclone DDS), LwM2M (Eclipse Leshan), MQTT (Eclipse Paho, Eclipse Mosquitto and Eclipse Amlen) and OPC UA (Eclipse Milo) are all built around Eclipse IoT projects. Other popular Eclipse IoT production-ready platforms cover use cases such as digital twins (Eclipse Ditto), energy management (Eclipse VOLTTRON), contactless payments (Eclipse Keyple), Industrial applications (Eclipse Kura) in addition to Eclipse Kapua  — a modular IoT cloud platform that manages data, devices, and much more.

To learn more about how to get involved with Eclipse IoT, Edge Native, Sparkplug or other working groups at the Eclipse Foundation, visit the Foundation’s membership page. Working group members benefit from a broad range of services, including exclusive access to detailed industry research findings, marketing assistance, and expert open source governance.

For further IoT & edge related information, please reach us at:

IoT@eclipse.org

Edgenative@eclipse.org

About the Eclipse Foundation

The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.

Third-party trademarks mentioned are the property of their respective owners.

###

Media contacts: 

Schwartz Public Relations for the Eclipse Foundation, AISBL
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 – 43 / -35 / -70

Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551


by Jacob Harris at December 07, 2021 10:00 AM

Java News Roundup: IntelliJ IDEA, JEP 421, Groovy, Open Liberty, Hibernate ORM, Eclipse Collections

by Michael Redlich at December 07, 2021 06:30 AM

This week's Java roundup for November 29th, 2021, features news from OpenJDK, JDK 18, Project Loom Build 18-loom+7-288, multiple Spring project point releases, Quarkus 2.5.1.Final, WildFly 26 Beta 1, Open Liberty 21.0.0.12, Hibernate ORM 6.0.0-Beta2, Eclipse Mojarra 2.3.17, GraalVM Native Build Tools 0.9.8, Groovy 4.0.0-RC1, Eclipse Collections 11.0.0, IntelliJ IDEA 2021.3, and JReleaser 0.9.0.

By Michael Redlich

by Michael Redlich at December 07, 2021 06:30 AM

Is software development Green?

by Denis Roy at December 02, 2021 08:16 PM

The world is environmentally conscious like never before. The planet's resources are not endless, and the amount of waste that our environment can tolerate is limited. We understand the need to recycle, the need for public transit, the need to use green energy, such as wind power and electric cars. We're all starting to do what we can to minimize our footprint on this planet.

So why are we so wasteful in the software development cycle?

You know that scenario I'm talking about: one line change in a Pull Request triggers a build, where a compute environment is created from scratch, megabytes and megabytes of data pulled from the Internet, massive amounts of code are compiled, verified against complex test suites, digitally signed and placed in an artifact storage that is seldomly cleaned up. Compound all that if the module built is a dependency that triggers another, larger build.

The environment is then torn down and discarded, only to be recreated moments later, perhaps multiple times a day, to support that need for Continuous Integration and the immediate feedback loop.

We're generation Giga -- we have Gigabits/sec of bandwidth, dozens of Gigabytes of RAM, multiple processors operating at several GigaHertz, and thousands of Gigabytes of storage on devices that can move several Gigabytes of data each second. So why not?

As I stand behind a cabinet in the Eclipse Datacenter upgrading our network gear, I feel the heat of all those servers being blown in my face. Power units on each side of the cabinet, each delivering 60 amps of 208v 3-phase AC current, are silent -- I think. I can't hear anything but the soothing sound of thousands of fans dissipating all the heat. But my comfort is only temporary: I walk down the long isle of cabinets, make two left turns to avoid the bedroom-sized Air Conditioner units, and I'm in the cold zone -- where cool, conditioned air blows up from the floor, ingested from the front of cabinets, and transformed into hot air. The three transport-truck-sized diesel-powered generators outside the building are standing by, should the building's closet-sized UPS batteries near depletion in the event of a power outage.

Where I live, water is free and AC power is dirt cheap. I could fill a full sink of hot water, wash each individual plate, bowl, dish and utensil with a clean cloth I use only once, drain and restart. Each plate, bowl and utelsil would be as clean as the previous.  Who cares, it's cheap, and it's free, right?

No, it's not. It's not free. It's not cheap.

And it's not Green, either.


by Denis Roy at December 02, 2021 08:16 PM

5 Questions for Michael Plagge, Eclipse Foundation Europe GmbH

by Jacob Harris at December 02, 2021 01:28 PM

Eclipse Foundation Director of Ecosystem Development Michael Plagge discussed industry challenges and opportunities for digitization in this interview with the eco Association.

by Jacob Harris at December 02, 2021 01:28 PM

CDT.cloud? C/C++ tooling in the web/cloud

by Jonas, Maximilian & Philip at November 26, 2021 11:08 AM

Are you looking to build a custom C/C++ tool using modern technologies? Do you have an existing Eclipse CDT-based toolchain and...

The post CDT.cloud? C/C++ tooling in the web/cloud appeared first on EclipseSource.


by Jonas, Maximilian & Philip at November 26, 2021 11:08 AM

The Eclipse Collections Code Katas

by Donald Raab at November 23, 2021 08:42 PM

Learn the Eclipse Collections library by completing hands-on Java code katas.

Photo by Carl Heyerdahl on Unsplash
We learn best by doing

What is Eclipse Collections?

Eclipse Collections is an open source Java collections library. Eclipse Collections has been evolving as a Java library since 2004. It was first released into open source as GS Collections in January 2012. It was later moved to the Eclipse Foundation in December 2015 and became Eclipse Collections.

You can read more about the history of GS Collections and its move to the Eclipse Foundation in the following article in InfoQ.

GS Collections Moves to the Eclipse Foundation

What are the Eclipse Collections Katas?

The Eclipse Collections Katas are structured exercises organized into individual kata modules that will help you learn the Eclipse Collections library. There are currently six distinct code katas that make up the Eclipse Collections Kata Project on GitHub.

GitHub - eclipse/eclipse-collections-kata: Eclipse Collections Katas

The katas are the best way to learn the Eclipse Collections library. The Eclipse Collections project started out at the Eclipse Foundation initially with two supporting code katas — the Company Kata and the Pet Kata. These two katas have been used over the past decade to teach thousands of Java developers how to use the Eclipse Collections library. They are still the best katas to start learning Eclipse Collections by doing.

I blogged about the two original Eclipse Collections katas a few years ago.

A Tale of Two Katas

More doing, more learning

Over the past four years, four more code katas have been added to the Eclipse Collections Kata project. Each kata focuses on a different area of Eclipse Collections. The more Eclipse Collections katas you do, the more you will learn about Eclipse Collections.

I will briefly describe each of the four new Eclipse Collections katas, and what motivated their creation.

Candy Kata

The Candy Kata was originally developed to teach Java developers about the Bag data structure available in Eclipse Collections.

Halloween is a popular holiday in the U.S. Many school aged kids get dressed up in costumes and go around their neighborhoods collecting candy in bags. In my neighborhood, the school kids usually make the rounds collecting bags of candy in different groups. The youngest kids start with their parents early in the afternoon, followed by the middle school kids before sunset, and then finally the high school kids who usually go out in the evening.

This kata has a single test class with two tests that focus on using methods on Bag and Set classes.

I blogged about the Candy Kata on Halloween back in 2018.

Trick or Treat: A Halloween Kata

Converter Method Kata

The Converter Method Kata started out as a blog that explained how to convert one collection type to another type using Eclipse Collections converter methods. Converter methods are methods that being with the prefix “to” and copy collections contents from one type to another. In order to convert a List to a Set in Eclipse Collections, you can call toSet on the List. The kinds of converters a developer can learn in this kata are as follows:

  • Convert object collections to MutableCollection types
  • Convert object collections to ImmutableCollection types
  • Convert Java Streams to MutableCollection types using Collectors2
  • Convert Java Streams to ImmutableCollection types using Collectors2
  • Convert primitive collections to other primitive MutableCollection types

I blogged about the converter methods available in Eclipse Collections almost a year ago.

Converter methods in Eclipse Collections

Top Methods Kata

The Top Methods Kata started out as a blog where I wanted to see how many of the Eclipse Collections methods I could include in a single method example. I decided to stop at 25 methods, even though there are a lot more in the RichIterable interface. We all have limited time, so I wanted to create a kata that a developer could complete that would expose them to the most commonly used methods in the Eclipse Collections API as quickly as possible.

The Top Methods Kata has a single test that you need to complete. There is a test method for each method in the Eclipse Collections API I wanted to include as an example for developers to learn.

Linked here is the original blog which I later turned into the Top Methods Kata.

My 25 favorite methods from the Eclipse Collections API

Lost and Found Kata

Eclipse Collections is a huge library. The code base has over 1 million lines of code. This makes it a challenge to teach all of the amazing features available in the Eclipse Collections API to developers. A million lines of code is just too much code to just sit down and read. This rather large code base has 18 years of software engineering investment, including contributions from over 100 developers. There are many data structures and algorithms you will not find direct equivalents for in the JDK today.

Nikhil Nanivadekar and I gave a talk on Eclipse Collections to a few hundred software engineers in Amazon at the end of July 2021. In this talk we included examples of several data structures and algorithms that we felt were not generally well known by developers, and had no direct equivalent in the JDK. After delivering this talk, I decided I would write a few blogs going into much more detail about the “missing Java data structures no one ever told you about”. The following blog links to the blog series I wrote in August 2021.

Blog Series: The missing Java data structures no one ever told you about

The Lost and Found Kata was a translation of this blog series into an advanced code kata that can help contributors who are interested learn Eclipse Collections in depth.

The kata is broken into three sections and covers many different data types. I’m including this snapshot of the README.md to show what a developer can potentially learn by completing this kata.

README — What is in the Lost and Found Kata?

After 18 years of working on Eclipse Collections, I started to feel like I was at risk of forgetting more than I could remember. I wanted to write down as many things that I know or learned, in blogs and katas before the knowledge became only mysterious artifacts buried in a million lines of code. This is why I created this kata. In this kata I am sharing lessons I learned directly with developers in hand-on exercises, hopefully guaranteeing this found knowledge is never at risk of being lost again.

Do. Or do not. There is no Try.

I hope this blog motivates some developers to complete the Eclipse Collections katas. We are looking for more committers for the Eclipse Collections library. If you are interested in investing and committing time to your own learning and the development of the library, then I highly recommend completing the Lost and Found Kata. For more information on becoming a committer on a project managed at the Eclipse Foundation, check out this post on the Eclipse Foundation Wiki.

Development Resources/Becoming a Committer

For folks looking for some quick examples to read, or to validate their own solutions to the katas, there are solution modules checked in for each of the katas.

I hope you enjoy these katas! Feedback, improvements and contributions to the katas are amazing and welcome contributions to the library!

Thank you!

I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.


by Donald Raab at November 23, 2021 08:42 PM

Announcing Eclipse Ditto Release 2.2.0

November 22, 2021 12:00 AM

The Eclipse Ditto teams announces availability of Eclipse Ditto 2.2.0.

It features several nice added features and e.g. allows using the dash - in the namespace part of thing IDs.

Adoption

Companies are willing to show their adoption of Eclipse Ditto publicly: https://iot.eclipse.org/adopters/?#iot.ditto

From our various feedback channels we however know of more adoption.
If you are making use of Eclipse Ditto, it would be great to show this by adding your company name to that list of known adopters.
In the end, that’s one main way of measuring the success of the project.

Changelog

The main improvements and additions of Ditto 2.2.0 are:

  • Filter for twin life-cycle events like e.g. “thing created” or “feature deleted” via RQL expressions
  • Possibility to forward connection logs via fluentd or Fluent Bit to an arbitrary logging system
  • Add OAuth2 client credentials flow as an authentication mechanism for Ditto managed HTTP connections
  • Enable loading additional extra JavaScript libraries for Rhino based JS mapping engine
  • Allow using the dash - as part of the “namespace” part in Ditto thing and policy IDs

The following notable fixes are included:

  • Policy enforcement for event publishing was fixed
  • Search updater cache inconsistencies were fixed
  • Fixed diff computation in search index on nested arrays

The following non-functional work is also included:

  • Collect Apache Kafka consumer metrics and expose them to Prometheus endpoint

Please have a look at the 2.2.0 release notes for a more detailed information on the release.

Artifacts

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

The Ditto JavaScript client release was published on npmjs.com:

The Docker images have been pushed to Docker Hub:



Ditto


The Eclipse Ditto team


November 22, 2021 12:00 AM

How to introspect and find conceptual symmetry between classes in Java

by Donald Raab at November 19, 2021 08:54 PM

Demonstrating ClassComparer, a utility class built with Eclipse Collections.

Photo by Jack French on Unsplash

A challenge with rich APIs

Rich APIs can be great. They can significantly reduce the duplication of code by providing many useful common behaviors. Sometimes there are different implementations of classes that have a similar rich set of method signatures. Some classes in Java are conceptually equivalent, even if they don’t share a common parent abstraction that defines that behavior.

The problem is that we as humans sometimes need help determining and understanding the subtle differences between classes that are conceptually the same. Parsing and comparing the text in Java source files or Javadoc that may be hundreds of lines long is laborious and error prone. Sometimes we miss things. Computers can help us here so we can identify and understand patterns.

Eclipse Collections is a library that has a primary design goal of providing good symmetry in its API. This goal is extremely challenging to achieve, given the size of the Eclipse Collections API. The Eclipse Collections API has grown so much in the past 18 years, I’ve needed some help to fully understand it.

A solution for comparing classes

A few years ago, I wrote some code in a utility class for comparing the method signatures in two classes. The utility leverages the methods available in Java to introspect classes along with data structures and algorithms available in Eclipse Collections to compare the methods.

There is nothing spectacularly amazing about the utility I wrote that compares classes. I have shared earlier versions of the source code in a previous blog (linked towards the end). It wasn’t until recently when I had to copy the code to my current Eclipse Collections project and modify it in order to compare IntIterable and RichIterable that I decided it would be useful to include it in the Eclipse Collections eclipse-collections-testutils module so I can easily use it in any project where I may need to compare rich APIs.

The utility does the following:

  • Reads the methods of each Class using getMethods
  • Optionally reads the parameters for each Method using getParameters
  • Optionally will include the return type of each method
  • Adds a String for each method to one of two MutableSortedSet instances
  • Calculates the intersection of the two sets of methods
  • Calculates the differences of the two sets of methods in both directions
  • Outputs the methods sorted alphabetically and groups them by their first letter

There are a few other useful methods on the utility class named ClassComparer, but this is its primary purpose.

Keep it simple

The utility creates the equivalent of a Venn Diagram between the method signatures of two classes. The clever part, if there is any, is that the utility class will allow you to optionally include parameter types and return types in the method signature comparison. By excluding parameter types and return types, we are able to determine if two classes have good conceptual symmetry by simply comparing the method names.

A simple comparison

As a first example of a comparison, I will compare StringBuffer and StringBuilder. Note: I was using this code in my local Eclipse Collections project, which is currently using Java 8. StringBuilder was introduced as a drop-in replacement for StringBuffer in Java 5, so we would expect them to have identical method signatures. Conceptually, they are identical. When we dig deeper into the details, we will see that they have subtle differences.

Here’s the code required to compare the two classes, excluding parameter types or return types.

Compare StringBuffer.class and StringBuilder.class

This particular method will do the comparison and output a text version of the intersection and bi-directional difference of StringBuffer and StringBuilder classes. Because I have used the default constructor, method parameter types and return types are excluded from the comparison.

Output of intersection and differences between StringBuffer and StringBuilder

Now, let’s compare the output when we include the parameters in the methods.

Setting the first flag to true enables the inclusion of method parameter types

Here’s the output with the method parameters included.

Output comparing StringBuffer and StringBuilder with parameter types

The classes still look identical. So let’s include return types, by setting the second flag in the ClassComparer constructor to true.

Setting the second flag to true enables the inclusion of method return types

Now the output looks much different.

Output comparing StringBuffer and StringBuilder with parameter and return types

Many of the method signatures return either StringBuffer or StringBuilder. There is a parent abstraction for both named AbstractStringBuilder which defines many of the methods like append that are called from the two subclasses and are overridden to return a the specific return type. This is why the number of methods grew significantly in the bi-directional difference.

An experimental Swing UI

I decided to build a quick prototype Swing UI to display the intersection and differences for ClassComparer. The Swing UI is nicer for quickly comparing the differences, as it uses a three pane list view which more or less emulates a Venn Diagram, just without the overlapping circles.

Here’s what the Swing UI looks like comparing the two classes above.

Excluding parameter and return types

Swing UI comparing StringBuffer and StringBuilder excluding parameter and return types

Including parameter types

Swing UI comparing StringBuffer and StringBuilder including parameter types only

Including parameter and return types

Swing UI comparing StringBuffer and StringBuilder including parameter and return types

Finding asymmetry in the Eclipse Collections API

To illustrate how a developer working on Eclipse Collections can use this utility to find potential work to complete in the space of improving symmetry, I will compare a primitive collection interface with its equivalent on the object side.

IntIterable vs. RichIterable

First, let’s compare the method signatures for IntIterable and RichIterable from a purely conceptual view. We can do this just by using the constructor with no parameter on ClassComparer.

Compare IntIterable and RichIterable interfaces

The output shows some interesting differences between the primitive collection parent type and the object collection parent type even at the conceptual level. Conceptual symmetry is the most important concern we have in Eclipse Collections. We clearly have plenty of work to do in this space.

The output comparing IntIterable and RichIterable interfaces

Looking at the same output in the experimental Swing UI shows one of the strengths of the text output that groups methods by their first letter. There is no need to scroll in the text output, where with the three pane Swing UI, all methods do not fit on the screen so scrolling is required.

The Swing UI comparing IntIterable and RichIterable

Look what happens to the text output when we add parameter types and return types to the methods in the comparison.

Part 1 of the output comparing IntIterable and RichIterable including parameter and return types
Part 2 of the output comparing IntIterable and RichIterable including parameter and return types

As we can see, there are quite a few methods overloaded in the Eclipse Collections RichIterable and IntIterable interfaces. Using the conceptual view without method parameter and return types hides this detail. This detail is important, so both views have value.

This is what the Swing UI looks like for this larger comparison.

The Swing UI comparing IntIterable and RichIterable including parameter and return types

The Swing UI is potentially more useful for this particular comparison, since scrolling is required in both cases.

Stay tuned

The code for ClassComparer will be available in the Eclipse Collections 11.0 release which is due out soon. It is located in the eclipse-collections-testutils module. If you want to see the code, it is now available in the Eclipse Collections repo linked below.

eclipse-collections/ClassComparer.java at master · eclipse/eclipse-collections

An older version of the code exists in the following blog, which is where I first started exploring how I could more easily understand the differences between rich APIs.

Graduating from Minimal to Rich Java APIs

I’ve used the ClassComparer utility to produce all of the examples in this blog. The Swing UI code which is part of a separate class is not included yet in Eclipse Collections. I need to discuss the potential inclusion of the swing code with the other Eclipse Collections committers. It would be unique for Eclipse Collections eclipse-collections-testutils module to include any UI code, so I can’t make any promises on it arriving there. For now, here is a gist with the code for the experimental Swing UI.

https://medium.com/media/5c561bf56ae0d618248d0f6a4ca33b31/href

I hope you found this useful. Thanks for reading!

I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.

Other Java Resource articles you may like to explore


How to introspect and find conceptual symmetry between classes in Java was originally published in Javarevisited on Medium, where people are continuing the conversation by highlighting and responding to this story.


by Donald Raab at November 19, 2021 08:54 PM

Welcome AsiaInfo to the Jakarta EE Working Group!

by Tanja Obradovic at November 18, 2021 05:06 PM

It is great to see that our Chinese membership is growing!   HuNan AsiaInfo AnHui is a Chinese software company, mainly engaged in basic software research and development, committed to communication operators, artificial intelligence, 5G, Internet of Things software and cloud computing, big data and other industry applications. Current products include database product AntDB, Application middleware product FlyingServer, AI-RPA, etc. The goal is to provide good basic software, connect relevant global norms and technologies, and serve the huge software demand market in China.

Warm welcome to the HuNan AsiaInfo AnHui as a new member of the Jakarta EE Working Group! 


by Tanja Obradovic at November 18, 2021 05:06 PM

Welcome SOUJava to the Jakarta EE Working Group!

by Tanja Obradovic at November 17, 2021 04:50 PM

We have another Java User Group as a Guest member! I am extremely happy to let you know that SOUJava has joined Jakarta EE Working Group! 

SOU Java does not need an introduction in the Java community! Their members are already heavily involved in Jakarta EE-related projects and having them as a Guest Member of the Jakarta EE Working Group additionally shows their commitment to advancing enterprise Java development.

Please join me in welcoming the SOUJava to Jakarta EE Working Group! It is great to see the Jakarta EE Working Group and our community is continuously growing.


by Tanja Obradovic at November 17, 2021 04:50 PM

Jakarta EE Community Update Fall 2021

by Tanja Obradovic at November 16, 2021 10:23 PM

The summer is usually a time when the activities slow down a little, and Jakarta EE is no exception. Throughout the summer, the Jakarta EE Platform project has put all its attention on Jakarta EE 10, while the TCK project has started with the massive task of refactoring the TCK. Other projects also  moved forward during summer.

The fall for Jakarta EE, however, has been and still is very busy! The teams are continuously working on the new releases on the individual specifications, while the Jakarta EE platform team is working on planning the Platform and Profiles (yes it will be plural for Profiles going forward!) release for the version 10. We are also working hard to bring you all the latest Jakarta EE news in our JakartaOne Livestream event that will be happening on December 7th this year. Our Compatibility Product list and membership base are growing, , and the Jakarta EE boat is sailing strong and in the right direction!

Here are some of highlights:

JakartaOne Livestream 2021: The Biggest Jakarta EE Event of the Year!

The biggest celebration of Jakarta EE is always our JakartaOne Livestream 2021 annual event! This year is no exception, so save the date December 7th, 202and please register and let us know you’ll be there!

Our popular JakartaOne Livestream virtual conference series, as you know, runs in different languages as well! 

We had the following language-specific events:

 

The Jakarta EE Community and Working Group is Growing

It is great to see new members continuously joining the working group. Recently, we welcomed:

SOU Java does not need an introduction in the Java community! Their members are already heavily involved in Jakarta EE-related projects and having them as a Guest Member of the Jakarta EE Working Group additionally shows their commitment to advancing enterprise Java development.

It is great to see that our Chinese membership is growing!   HuNan Asiainfo AnHui,founded on September 25, 2019, is a Chinese software company, mainly engaged in basic software research and development, committed to communication operators, artificial intelligence, 5G, Internet of Things software and cloud computing, big data and other industry applications. Current products include database product AntDB, Application middleware product FlyingServer, AI-RPA, etc. The goal is to provide good basic software, connect relevant global norms and technologies, and serve the huge software demand market in China.

If you or your company are interested in the work of the Jakarta EE Working Group, please visit our membership pages and get in touch! 


Jakarta Tech Talks

We had quite a few new Jakarta Tech Talks! Please visit the Jakarta Tech Talk playlist on Jakarta EE YouTube channel to view the recordings, here are a few:

If you have a topic / talk related to enterprise java development you’d like to share with the community, please let us know. Fill out this form and we’ll help you out to set it up and promote it! 

Jakarta EE 10 is Taking Shape!

I am beyond excited to see all the progress we see related to Jakarta EE 10 in GitHub (label EE10). The creation/plan review for Jakarta EE Core Profile 10 was approved by the Jakarta EE Specification Committee. Jakarta EE Web Profile 10 and Jakarta EE Platform 10 issues are in discussion and plan reviews are expected soon. Please join the discussion and Jakarta EE Platform call to provide your input, refer to Jakarta EE Specifications Calendar (public url, iCal)  for details on all technical calls.


Jakarta EE Individual Specifications and Project Teams 

All meetings in the various specification projects are published in the public Jakarta EE Specifications Calendar (public url, iCal).Everyone interested is welcome to join the calls. Do note that the Jakarta EE Platform team is extremely busy and productive. The call is public and is welcome to all people who would like to contribute to technical discussions.

Select the one that you are interested in and help out. Each specification team is eager to welcome you! 

Want To Learn How To Use Jakarta EE?  

The Eclipse Cargo Tracker is a fantastic example of an end-to-end Jakarta EE application that showcases core Jakarta EE technologies. Thanks to Scaleforce and Jelastic for providing resources to deploy the demo application to the cloud.

Give the Cargo Tracker a try and consider contributing to the project at Cargo Tracker GitHub repository.


EclipseCon 2021 recordings! 

We had a great conference and presence at the EclipseCon 2021! The Jakarta EE Community Day was fabulously organized by the community! Many thanks to Reza Rahman, Werner Keil and Petr Aubrecht. The presentations are available in the folder.  

The conference talk recordings are now available on YouTube in the EclipseCon 2021 Playlist, and in Swapcard. In Swapcard, go to Agenda to locate a talk (Tuesday, Wednesday, and Thursday only), and click on the title to watch the video. We are hoping to see you next year in person!

Adopt A Spec!

Attention all JUGs: get recognized for your involvement in the specification development!

We need help from the community! All JUGs out there, please choose the specification of your interest and adopt it. Here is the information about the Adopt-A-Spec program. 

 

Stay Connected With the Jakarta EE Community

The Jakarta EE community is 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. Subscribe to your preferred channels today:

·  Social media: Twitter, Facebook, LinkedIn Group, LinkedIn Page

·  Mailing lists: jakarta.ee-community@eclipse.org, jakarta.ee-wg@eclipse.org, project mailing lists, Slack workspace

·  Calendars: Jakarta EE Community Calendar, Jakarta EE Specification Meetings Calendar 

·  Newsletters, blogs, and emails: Eclipse Community Newsletter, Jakarta EE blogs, Hashtag Jakarta EE

·  Meetings: Jakarta Tech Talks, Jakarta EE Update, and Eclipse Foundation events and conferences

You can find the complete list of channels here.

To help shape the future of open source, cloud native Java, get involved in the Jakarta EE Working Group.

 

 


by Tanja Obradovic at November 16, 2021 10:23 PM

You are invited!!! JakartaOne Livestream 2021 the Jakarta EE event of the year!

by Tanja Obradovic at November 16, 2021 07:12 PM

The biggest celebration of Jakarta EE is always our JakartaOne Livestream 2021 annual event! This year is no exception, so save the date December 7th, 2021 and please register  and let us know you’ll be there!!

This year again, it will be a twelve hour virtual event that will provide you with a variety of talks and discussions related to Jakarta EE. Join us to find out what are the future plans for the individual specifications but also plans for the platform and the profiles. We have a great lineup of speakers for the main talks; to avoid missing anyone here is the picture from the website. 

NOTE: please refer to the website for updates and possible sessions time changes 

We’ll be having quite a few surprises for the Studio Jakarta EE sessions, as well! So stay tuned for these. 

As we are having a long day, we’ll be having pizza! So make your own, create it as Jakarta EE as possible and share the picture on social media. Do not forget to tag us (@JakartaOneCong and @JakartaEE) or show it on the day of the event! We want to celebrate all of your work related to Jakarta EE including pizza!

 

 

 


by Tanja Obradovic at November 16, 2021 07:12 PM

OSPO Alliance Announces the OSS Good Governance Handbook

by Jacob Harris at November 09, 2021 01:00 PM

The OSPO Alliance today announced the publication of the first version of the Open Source Good Governance Handbook. Collaboratively developed in the framework of the OW2 Open Source Good Governance initiative, the handbook introduces a methodology to implement professional management of open source software in an organisation. It addresses the need to use open source software properly and fairly, safeguarding organisations from technical, legal and IP threats, and maximising for them the advantages of open source.

This methodology goes beyond compliance and liability. It is about building awareness in communities of end-users (open software developers themselves) and systems integrators, and developing mutually beneficial relationships within the FOSS ecosystem.

The Good Governance Handbook provides a comprehensive methodology based on a few key concepts. From a generic perspective, the approach is structured along five Goals (Usage, Trust, Culture, Engagement and Strategy), each supported by five Canonical Activities described in the handbook. At execution stage, the methodology requires adapting the Canonical Activities to the specific condition of each organisation by transferring them into Customized Activity Scorecards which, put together, constitute a roadmap for setting up and running an Open Source Program Office (OSPO) and a management system to monitor progress.

The OSS Good Governance Handbook is the first major publication of the OSPO Alliance to help companies and public institutions implement an Open Source Program Office (OSPO).  The OSPO Alliance provides an organisation-neutral venue for contributors to share resources, experience and skills. Supporters can opt to contribute in several ways: at the new OSPO.Zone website, contribute directly to the next steps of the Good Governance Initiative methodology, and share their experiences (both successes and failures!) as case studies or with more informal short interviews. 

“This publication is the result of nearly two years of collaborative work with OW2 members and OSS practitioners. We are now moving to the implementation and customization phase with some key adopters of the methodology. We are excited to publish this effort with the OSPO Alliance,” said Cédric Thomas, CEO of OW2.

The OSPO Alliance is also pleased to welcome eight new supporters, including the Free Software Foundation Europe, SAP, and WiPro.

Quotations From Supporters About Their Participation In the OSPO Alliance: 

APELL
“APELL (Association Professionnelle Européenne du Logiciel Libre), Europe’s Open Source Business Association, and its national members, are eager to support the mission of the OSPO Alliance. Europe is an open source champion, and there is still massive potential to tap everywhere from large and small software vendors to big open source users, both in the private and public sectors. We see that this partnership will be very important to strengthening not only Europe's but the world's capacity to use and contribute to open source at an even greater scale. Increased understanding of open source governance and the establishment of Open Source Programme Offices hold massive potential to enable open innovation at large in society,” said Timo Väliharju, Founder and board member of APELL.

CNLL 
“The CNLL, the association representing the free software sector in France, has long supported the creation of OSPOs, or "free software missions", in France, at the level of the Government but also at the level of major local authorities, as well as at the European level. The mission of these OSPOs in France should be to make concrete the notion of "encouraging the use of free software" within the administration, as provided for in Article 16 of the Digital Republic Act (or Lemaire Act) of 2016. These OSPOs should network with each other and with organizations representing the industry in order to fully realize the economic and strategic benefits of OSS in Europe,” said Stéfane Fermigier, co-president of CNLL.

OSBA
“The OSB Alliance – Bundesverband für digitale Souveränität e.V. represents about 170 companies from the Open Source economy. We are committed to sustainably anchoring the central importance of open source software and open standards for a digitally sovereign society in the public consciousness.

“For the OSB Alliance establishing an OSPO is a great strategic approach for public or private organisations to professionalize their engagement with the Open Source Ecosystem. So we see the OSPO Alliance as an exciting new European initiative to support organisations in the public, private or academia sector with information and best practices on OSPOs. Such support can especially accelerate the process of setting up important OSPOs as planned e.g. at EU level or the planned Zendis in Germany,” declared Peter Ganten, Chairman of the OSBA-Board.

FSFE     
“The Free Software Foundation Europe (FSFE) is a charity that empowers users to control technology. Since 2001 the FSFE has been enhancing users' rights by abolishing barriers for software freedom. For 20 years FSFE has been helping individuals and organisations to understand how Free Software contributes to freedom, transparency, and self-determination.
 
Joining OSPO.Zone is another brick in the wall to ensure that more Free Software is developed and used - be it in the private or governmental sector. Free Software gives everybody the right to use, study, share and improve software. To make sure that these rights are understood and used an OSPO can make a difference,” said Matthias Kirschner, President Free Software Foundation Europe

About the OSPO Alliance: 
The OSPO Alliance was established by leading European open source non-profit organisations, including OW2, Eclipse Foundation, OpenForum Europe, and Foundation for Public Code, and experienced practitioners with the aim to grow awareness for open source in Europe and to globally promote structured, responsible and professional management of open source by companies and administrations. OSPO.Zone is the new website for delivering the resources and collaboration envisaged by the OSPO Alliance. Learn more at https://ospo.zone.

Media contacts:
Schwartz Public Relations
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
+49 (89) 211 871 – 43 / -35 / -70
 


by Jacob Harris at November 09, 2021 01:00 PM

Register for TheiaCon 2021 now!

by Jonas, Maximilian & Philip at November 09, 2021 08:42 AM

EclipseCon 2021 has just closed its doors and we are happy to already announce the next highlight of the year, TheiaCon...

The post Register for TheiaCon 2021 now! appeared first on EclipseSource.


by Jonas, Maximilian & Philip at November 09, 2021 08:42 AM

How I generate the JavaFlight Recorder Docu

by Tom Schindl at November 03, 2021 11:05 PM

From a tweet von Gunnar Morling

I learned today that my work on JFR-Doc is used for JfrUnit. In a follow up Gunnar asked me how those JSON-Files are generated and I promised to write up a blog what I hacked together in an evening to get this going.

Get the input

The first and most important thing is to get all JFR-Events (those commands are executed eg in your Java-17-Install-Dir)

./java -XX:StartFlightRecording:filename=/tmp/out-bin.jfr \
-version # Dump JFR Data
./jfr metadata /tmp/out-bin.jfr &gt; /tmp/openjdk-17.jfr

The final file holds content like this

class boolean {
}
class byte {
}
class char {
}
class double {
}
class float {
}
class int {
}
class long {
}
class short {
}

@Name("java.lang.Class")
@Label("Java Class")
class Class {
  @Label("Class Loader")
  ClassLoader classLoader;

  @Label("Name")
  String name;

  @Label("Package")
  Package package;

  @Label("Access Modifiers")
  int modifiers;

  @Label("Hidden")
  boolean hidden;
}
...

Looks like these are Java-Classes so one strategy could be to just compile those and use Reflection to extract meta informations but I went another route

Parsing the .jfr-File

Handcrafting a parser is certainly not the way to go. I needed something that could provide me a fairly simple Logical-AST. There are BNF-Definitions for Java but I wanted something much simpler so I fired up my Eclipse IDE and created an Xtext-Project using the wizards and replaced the content in the .xtext-File with

grammar at.bestsolution.jfr.JFRMeta with org.eclipse.xtext.common.Terminals

generate jFRMeta "http://www.bestsolution.at/jfr/JFRMeta"

Model:
  classes+=Clazz*;

Clazz:
  annotations+=Annotation*
  'class' name=ID ( 'extends' super=QualifiedName )? '{'
    attributes += Attribute*
  '}';

Attribute:
  annotations+=Annotation*
  type=[Clazz|ID] array?='[]'? name=ID ';'
;

Annotation:
  '@' type=[Clazz|ID] ('(' (values+=AnnotationValue |
   ('{' values+=AnnotationValue
   (',' values += AnnotationValue)* '}')) ')')?
;

AnnotationValue:
  valueString=STRING | valueBoolean=Boolean | valueNum=INT
;

enum Boolean:
  TRUE="true" | FALSE="false"
;

QualifiedName:
  ID ('.' ID)*;

That’s all required because the .jfr-File is extremly simple so we don’t need a more complex definition.

How to convert

Well although Xtext is primarily used to develop DSL-Editors for the Eclipse IDE one can run the generated parser in plain old Java. So all now needed is to write a generator who parses the .jfr-File(s) and generate different output from it (HTML, JSON, …) and because although Java now has multiline strings Xtend is the much better choice to write a “code”-generator.

package at.bestsolution.jfr

import org.eclipse.xtext.resource.XtextResourceSet
import org.eclipse.xtext.resource.XtextResource
import java.util.ArrayList
import org.eclipse.emf.common.util.URI
import java.nio.file.Files
import java.nio.file.Paths
import at.bestsolution.jfr.jFRMeta.Model
import java.nio.file.StandardOpenOption
import at.bestsolution.jfr.jFRMeta.Clazz

import static extension at.bestsolution.jfr.GenUtil.*
import at.bestsolution.jfr.jFRMeta.Attribute

class JSONGen {
     def static void main(String[] args) {
         val versions = createVersionList(Integer.parseInt(args.get(0)))
         val injector = new JFRMetaStandaloneSetup().createInjectorAndDoEMFRegistration();
         val resourceSet = injector.getInstance(XtextResourceSet);
         resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE);

         val models = new ArrayList
         for( v : versions ) {
             val resource = resourceSet.getResource(
                 URI.createURI("file:/Users/tomschindl/git/jfr-doc/openjdk-"+v+".jfr"), true);
             val model = resource.getContents().head as Model;
             models.add(model)
         }

         for( pair : models.indexed ) {
             val model = pair.value
             var version = versions.get(pair.key)
             val preModel = pair.key == 0 ? null : models.get(pair.key - 1)
             Files.writeString(Paths.get("/Users/tomschindl/git/jfr-doc/openjdk-"+version+".json"),model.generate(preModel,version), StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.CREATE)
         }
     }

     def static generate(Model model, Model prevModel, String ver) '''
         {
             "version": "«ver»",
             "distribution": "openjdk",
             "events": [
                 «val evts = model.classes.filter[c|c.super == "jdk.jfr.Event"]»
                 «FOR e : evts»
                     «e.generateEvent»«IF e !== evts.last»,«ENDIF»
                 «ENDFOR»
             ],
             "types": [
                 «val types = model.classes.filter[c|c.super === null]»
                 «FOR t : types»
                     «t.generateType»«IF t !== types.last»,«ENDIF»
                 «ENDFOR»
             ]
         }
     '''

     def static generateEvent(Clazz clazz) '''
         {
             "name": "«clazz.name»",
             "description": "«clazz.description»",
             "label": "«clazz.label»",
             "categories": [
                 «val cats = clazz.categories»
                 «FOR cat : cats»
                     "«cat»"«IF cat !== cats.last»,«ENDIF»
                 «ENDFOR»
             ],
             "attributes": [
                 «FOR a : clazz.attributes»
                     «a.generateAttribute»«IF a !== clazz.attributes.last»,«ENDIF»
                 «ENDFOR»
             ]
         }
     '''

     def static generateType(Clazz clazz) '''
         {
             "name": "«clazz.name»",
             "attributes": [
                 «FOR a : clazz.attributes»
                     «a.generateAttribute»«IF a !== clazz.attributes.last»,«ENDIF»
                 «ENDFOR»
             ]
         }
     '''

     def static generateAttribute(Attribute a) '''
         {
             "name": "«a.name»",
             "type": "«a.type.name»",
             "contentType": "«a.contentType»",
             "description": "«a.description»"
         }
     '''
}

All sources are available at https://github.com/BestSolution-at/jfr-doc if you look at this code keep in mind that it was hacked together in an evening


by Tom Schindl at November 03, 2021 11:05 PM

Support for OAuth2 client credentials flow for HTTP connections

November 03, 2021 12:00 AM

The upcoming release of Eclipse Ditto version 2.2.0 supports HTTP connections that authenticate their requests via OAuth2 client credentials flow as described in section 4.4 of RFC-6749.

Detailed information can be found at Connectivity API > HTTP 1.1 protocol binding.

This blog post shows an example of publishing a twin event to an HTTP endpoint via OAuth2 client credentials flow. For simplicity, we will use webhook.site for both the token endpoint and the event publishing destination. Feel free to substitute them for real OAuth and HTTP servers.

Prerequisites

This example requires 2 webhooks. We will use

  • https://webhook.site/785e80cd-e6e6-452a-be97-a59c53edb4d9 for access token requests, and
  • https://webhook.site/6148b899-736f-47e6-9382-90b1d721630e for event publishing.

Replace the webhook URIs by your own.

Configure the token endpoint

Configure the token webhook to return a valid access token response. Here is an example for a token expiring at 00:00 on 1 January 3000. The field expires_in is an arbitrary big number not reflecting the actual expiration time of the access token.

  • Status code: 200
  • Content type: application/json
  • Response body:
    {
      "access_token": "ewogICJhbGciOiAiUlMyNTYiLAogICJ0eXAiOiAiSldUIgp9.ewogICJhdWQiOiBbXSwKICAiY2xpZW50X2lkIjogIm15LWNsaWVudC1pZCIsCiAgImV4cCI6IDMyNTAzNjgwMDAwLAogICJleHQiOiB7fSwKICAiaWF0IjogMCwKICAiaXNzIjogImh0dHBzOi8vbG9jYWxob3N0LyIsCiAgImp0aSI6ICI3ODVlODBjZC1lNmU2LTQ1MmEtYmU5Ny1hNTljNTNlZGI0ZDkiLAogICJuYmYiOiAwLAogICJzY3AiOiBbCiAgICAibXktc2NvcGUiCiAgXSwKICAic3ViIjogIm15LXN1YmplY3QiCn0.QUJD",
      "expires_in": 1048576,
      "scope": "my-scope",
      "token_type": "bearer"
    }
    

The access token has the form <headers>.<body>.<signature>, where <headers> and <body> are base64-encoding of the headers and the body in JSON format, and <signature> is the base-64 encoded signature computed according to the issuer’s key pair. Since the token webhook is not a real OAuth2 server, the signature in the example is a placeholder. The unencoded headers and body are as follows.

Headers

{
  "alg": "RS256",
  "typ": "JWT"
}

Body

{
  "aud": [],
  "client_id": "my-client-id",
  "exp": 32503680000,
  "ext": {},
  "iat": 0,
  "iss": "https://localhost/",
  "jti": "785e80cd-e6e6-452a-be97-a59c53edb4d9",
  "nbf": 0,
  "scp": [
    "my-scope"
  ],
  "sub": "my-subject"
}

Create the connection

Create a connection publishing twin events to the event publishing webhook using OAuth2 credentials. The tokenEndpoint field is set to the access token webhook.

{
  "id": "http_oauth2",
  "name": "http_oauth2",
  "connectionType": "http-push",
  "connectionStatus": "open",
  "uri": "https://webhook.site:443",
  "targets": [
    {
      "address": "POST:/6148b899-736f-47e6-9382-90b1d721630e",
      "topics": ["_/_/things/twin/events"],
      "authorizationContext": ["integration:ditto"]
    }
  ],
  "credentials": {
    "type": "oauth-client-credentials",
    "tokenEndpoint": "https://webhook.site/785e80cd-e6e6-452a-be97-a59c53edb4d9",
    "clientId": "my-client-id",
    "clientSecret": "my-client-secret",
    "requestedScopes": "my-scope"
  }
}

Generate a thing-created event

Create a thing granting read access to the connection’s subject. The thing-created event will be distributed to the connection for publishing.

{
  "_policy": {
    "entries": {
      "DEFAULT": {
        "subjects": {
          "{{ request:subjectId }}": {
            "type": "the creator"
          },
          "integration:ditto": {
            "type": "the connection"
          }
        },
        "resources": {
          "policy:/": {
            "grant": ["READ", "WRITE"],
            "revoke": []
          },
          "thing:/": {
            "grant": ["READ", "WRITE"],
            "revoke": []
          }
        }
      }
    }
  }
}

HTTP requests made by the HTTP connection

Before the HTTP connection publishes the thing-created event, it makes an access token request against the token endpoint to obtain a bearer token.

POST /785e80cd-e6e6-452a-be97-a59c53edb4d9 HTTP/1.1
Host: webhook.site
Accept: application/json
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials
&client_id=my-client-id
&client_secret=my-client-secret
&scope=my-scope

The request should appear at the access token webhook. The webhook should return the configured access token response.

{
  "access_token": "ewogICJhbGciOiAiUlMyNTYiLAogICJ0eXAiOiAiSldUIgp9.ewogICJhdWQiOiBbXSwKICAiY2xpZW50X2lkIjogIm15LWNsaWVudC1pZCIsCiAgImV4cCI6IDMyNTAzNjgwMDAwLAogICJleHQiOiB7fSwKICAiaWF0IjogMCwKICAiaXNzIjogImh0dHBzOi8vbG9jYWxob3N0LyIsCiAgImp0aSI6ICI3ODVlODBjZC1lNmU2LTQ1MmEtYmU5Ny1hNTljNTNlZGI0ZDkiLAogICJuYmYiOiAwLAogICJzY3AiOiBbCiAgICAibXktc2NvcGUiCiAgXSwKICAic3ViIjogIm15LXN1YmplY3QiCn0.QUJD",
  "expires_in": 1048576,
  "scope": "my-scope",
  "token_type": "bearer"
}

The HTTP connection will cache the access token and use it to authenticate itself at the event publishing webhook for each thing event, including the first thing-created event.

POST /6148b899-736f-47e6-9382-90b1d721630e HTTP/1.1
Host: webhook.site
Content-Type: application/vnd.eclipse.ditto+json
Authorization: Bearer ewogICJhbGciOiAiUlMyNTYiLAogICJ0eXAiOiAiSldUIgp9.ewogICJhdWQiOiBbXSwKICAiY2xpZW50X2lkIjogIm15LWNsaWVudC1pZCIsCiAgImV4cCI6IDMyNTAzNjgwMDAwLAogICJleHQiOiB7fSwKICAiaWF0IjogMCwKICAiaXNzIjogImh0dHBzOi8vbG9jYWxob3N0LyIsCiAgImp0aSI6ICI3ODVlODBjZC1lNmU2LTQ1MmEtYmU5Ny1hNTljNTNlZGI0ZDkiLAogICJuYmYiOiAwLAogICJzY3AiOiBbCiAgICAibXktc2NvcGUiCiAgXSwKICAic3ViIjogIm15LXN1YmplY3QiCn0.QUJD

{
  "topic": "<namespace>/<name>/things/twin/events/created",
  "headers": {},
  "path": "/",
  "value": {
    "policyId": "<policy-id>"
  },
  "revision": 1
}

The HTTP connection will obtain a new token from the access token webhook when the previous token is about to expire.

Please get in touch if you have feedback or questions regarding this new functionality.

Ditto


The Eclipse Ditto team


November 03, 2021 12:00 AM

Moving Embedded Software Development Tools Into the Cloud

by Brian King at November 02, 2021 12:11 PM

In this article, we introduce the embedded special interest group (embedded SIG), hosted by the Eclipse Foundation. The embedded SIG is an open collaboration of embedded vendors and service providers, with the goal of strengthening the open source ecosystem for building web- and cloud-based tools used for embedded development. The SIG provides the structure for participants to coordinate efforts, share insights and collaborate on technical initiatives and standards.

The Eclipse Foundation has a strong track-record with embedded tools, in particular with the Eclipse CDT project. In recent years, many adopters of CDT are striving towards web and cloud-based tools. “We can observe a trend in our customer base that the embedded domain leads the way in terms of adopting modern tool technologies,” says Jonas Helming from EclipseSource. “This is great for the ecosystem, because many of these embedded vendors are migrating from the CDT ecosystem; they are experienced in adopting open source technology and they are traditionally strong contributors”.

The move by the Eclipse Cloud DevTools Working Group to setup the embedded SIG and to support tools in the cloud in this domain, is driven by trends we are seeing in the market. Because of this, we, along with our members, are motivated to accelerate the adoption of cloud-based embedded tools. Current members of the group include Arm, EclipseSource, Ericsson, Renesas, and STMicroelectronics. If you are interested in joining, let us know. The group meets monthly to determine priorities, assign tasks, and work through technical initiatives. Let’s now look at some selected initiatives to get an overview of what the SIG is all about.

Technical Initiatives

All embedded SIG technical initiatives are defined using a collaborative process. Each member can suggest topics. If other members are interested in a particular topic, joint initiatives are then started. While there is typically a subset of members working on a specific topic, any progress and results are discussed and shared with the entire group.

CDT.cloud Blueprint

This initiative is led by EclipseSource and aims at providing guidelines for the technology selection when creating web-based C/C++ tools. On the desktop, CDT provided a very good basis for building custom tools. Achieving similar results in the web/cloud typically requires the selection and integration of various technologies from different sources. To address this, EclipseSource has conducted a survey among the members of the SIG and also within their customer base to find out which technologies are most frequently adopted (e.g. language servers, debug adapters, VS Code extensions, etc.).

CDT.cloud BlueprintCDT.cloud Blueprint

Based on feedback received, they are assembling a blueprint tool (similar to Eclipse Theia Blueprint), called CDT.cloud Blueprint. It provides an excellent demonstration of how to build web-based C/C++ tools. Even more, it can be used as a starting point to create a custom tool distribution. Check out https://cdt-cloud.io to download the blueprint, and please make sure to provide feedback!

Memory Inspector

One of many components needed for a good C/C++ tool in the web/cloud is a way to inspect the memory in detail, while debugging a program. The memory inspector adds useful functionality for inspecting memory during debugging, including: dynamic updating of memory, multiple memory views, view comparison (diffing), and register viewing. This initiative is led and contributed by Ericsson. Arm and other members are evaluating, providing feedback and adopting the result.

Memory Inspector in Arm Keil StudioMemory Inspector in Arm Keil Studio

To follow along with the work being done to integrate this into Eclipse Theia, have a look at the repository on GitHub. More information can be found in this blog post.

TraceCompass

Eclipse TraceCompass is a popular open source application to solve performance and reliability issues by reading and analyzing traces and logs of a system. Its goal is to provide views, graphs, metrics, and more to help extract useful information from traces, in a way that is more user-friendly and informative than huge text dumps.

Trace Compass in actionTrace Compass in action (click image for animation)

As an initiative of the embedded SIG, TraceCompass is currently being migrated to a web-based interface and to run as a distributed cloud-based application. It is also led and contributed by Ericsson, while other parties are evaluating it for adoption. Again, to follow along with the work being done to integrate TraceCompass into Eclipse Theia, see this pull request. For more information, please follow this link: https://www.eclipse.org/tracecompass/.

Multiple Contexts for indexes in clangd

Most vendors use clangd as a C/C++ language server. It offers a convenient option for enabling source code editing on the web. One missing piece, however, is the notion of a “context” in terms of source files considered by the language server. As an example, you might have multiple projects in a workspace, the language server should consider them independently. On this initiative, several members are currently collaborating. Ericsson contributed their solution, allowing to start multiple language servers per workspace. STMicroelectronics, in collaboration with EclipseSource, is working on a mechanism to dynamically specify and switch the context of a running clangd language server. Such a solution would even allow different language processing depending on the current build target (e.g. for debugging or release). Stay tuned for more information about this ongoing initiative!

CDT GDB Adapter

The Eclipse CDT GDB Adapter is an implementation of the Debug Adapter Protocol (DAP), allowing the connection of web-based tools to any device supporting GDB. The library provided by CDT can be included into VS Code, Theia or any client that supports DAP. For example, Renesas, ARM and Blackberry/QNX all have VS Code or Theia extensions that can allow the IDE to connect to their respective hardware and ecosystem. Whether your editor is a traditional IDE, or you are using the new generation of editors in the cloud, the adapter is a key piece that allows communication between that editor and GDB.

In addition to the third-party adapters that are built on top of CDT GDB Adapter, the adapter is also delivered as an extension for Theia via the Open VSX Registry. The embedded SIG is also making plans to deliver the adapter as an extension for VS Code in the near future.

Conclusion

Embedded tool vendors are at different stages of their journey to the cloud. Many of them still remain invested in legacy platforms, including the Eclipse IDE. However, embedded vendors are currently also leading the way towards web and cloud-based tools. Arm, as an example, have built their Mbed Studio based on Eclipse Theia, and recently moved in-browser with Keil Studio. The embedded special interest group is a great place to collaborate on this innovative ecosystem, share experiences and drive technical initiatives. If you are interested in learning more about or joining this group, please contact us here.


by Brian King at November 02, 2021 12:11 PM

The Eclipse IDE Turns 20

by Shanda Giacomoni at November 02, 2021 11:00 AM

One of the world’s most popular open source desktop development environments continues to evolve to support a new generation of developers 

BRUSSELS – November 2, 2021 – The Eclipse Foundation, one of the world’s largest open source software foundations, together with the Eclipse IDE Working Group, today announced the 20th anniversary of the Eclipse Platform suite of products, related technologies, and ecosystem. Throughout that time, the Eclipse Platform has been instrumental in driving the adoption of open source, as well as serving as the core technology for building some of the most advanced applications in the world. From the Eclipse Java development tools, to NASA’s Mars Rover mission planning software, to massive semiconductors, and myriad other technologies that power our lives, the Eclipse Platform continues to support developers building new applications. 

“As the project that gave our organization its name, it is with great pride that I’ve watched this platform evolve to meet the challenges of today,” said Mike Milinkovich, executive director of the Eclipse Foundation. “The wonderful community that has driven this evolution, as well as our new working group, continue to ensure the Eclipse IDE platform will meet the needs of developers for another 20 years.”

20 years after the Eclipse family of projects was first launched, the Eclipse Platform and ecosystem continue to be relied upon worldwide by developers and businesses to create commercially viable products in a variety of industry sectors. With millions of users, tens of millions of downloads annually, and billions of dollars in shared investment, the Eclipse IDE is one of the world’s most popular desktop development environments.

The Eclipse Foundation recently formed the Eclipse IDE Working Group to support this global community. This new working group provides governance, guidance, and funding for the communities that support the delivery and maintenance of the Eclipse IDE products. Founded by multiple participants, including Bosch, EclipseSource, IBM, Kichwa Coders, Renesas, SAP, VMware, and Yatta Solutions, this governance structure will enable broad collaboration to ensure the Eclipse IDE meets the latest market requirements. All consumers and adopters of Eclipse Platform technologies are highly encouraged to join and participate in this new working group.

The goal of the Eclipse IDE Working Group is to ensure the continued success, vibrancy, quality, and sustainability of the Eclipse Platform, desktop IDE, and underlying technologies. This effort includes support for planning and delivery processes, as well as the related delivery technology. If the Eclipse IDE is important to your organization’s development efforts, the new working group represents an opportunity to help shape the future of this critical platform. For more information, visit ide-wg.eclipse.org.

To learn more about how to get involved with the Eclipse IDE Working Group, visit the Eclipse Foundation membership page or see the working group’s Charter and Participation Agreement. Working group members benefit from a broad range of services, including exclusive access to detailed industry research findings, marketing assistance, and expert open source governance. Sponsorship is also welcomed as a way for companies that want to support the Eclipse IDE without joining the working group. 

Quotes from Strategic Members

IBM

"20 years ago, when IBM contributed our Java development tools to a consortium of organizations which later on became the Eclipse Foundation, we hoped to create an open process that would excite developers to participate in the shaping and development of the tools they would use every day to create applications,” said Todd Moore, IBM’s VP of Open Technology. “At the time we hoped this would ignite the industry around Java, and the Eclipse Foundation did just that. Here's to 20 more successful years as Java moves into the cloud native world.”

Renesas Electronics

“Renesas’ embedded tools environment is built through the utilization of the groundbreaking Eclipse platform and the fully functional C/C++ Developers Toolkit (CDT),” said Akyiya Fukui, vice president, IoT and Infrastructure Business Unit, Software Development Division. “The open tools environment, the diverse partners and third party tools integration have quickly become the de facto IDE platform for embedded software for customers around the world. Renesas will continue to support the platform and work closely with the Foundation to ensure the projects build on this success.” 

Robert Bosch GmbH

"We have been using the Eclipse platform for designing and developing solutions for Automotive and IoT use cases. One of the key success factors in software industry is a widely adopted open source platforms, which can be used to create not only developer ecosystems but also commercial solutions. Thanks to contributions from many developers in the Eclipse community, tools and standards are created on an open platform that many companies benefit from. As an Eclipse IDE Strategic group member, we are excited to contribute to the platform and help to keep it powerful for many more years to come," said Vadiraj Krishnamurthy, Head Technology & Innovation, Robert Bosch Engineering and Business Solutions.

SAP

“SAP has delivered development tools for SAP NetWeaver based on the Eclipse platform from its very beginning 20 years ago,” said Karl Kessler, vice president of Product Management ABAP Platform, SAP. “Developers have used the SAP tools to build successful applications for the SAP customer base and ecosystem that run more than 70% of the worldwide business transactions around the globe. SAP continues to invest into its tools portfolio, in particular the ABAP development tools (ADT) for Eclipse. ADT helps to build Cloud applications powered by SAP HANA that run on SAP Business Technology Platform and SAP S/4HANA. SAP Partners have used the tool plugins from SAP to deliver tailored tool extensions. SAP will continue to contribute to the Eclipse Foundation to enrich the value of the Eclipse Platform and community.”

Vector Informatik GmbH

"With PREEvision, we provide an Eclipse-based tool for the automotive industry to develop electronic systems (E/E) of modern vehicles. The Eclipse IDE builds a both solid and versatile basis for us to meet the demands of our customers for a model-based development platform and central E/E data backbone," says Georg Zimmermann, director for PREEvision. "We started our journey with Eclipse over 15 years ago and the fact that Vector still launches new Eclipse-based products like the DaVinci Developer Adaptive speaks for itself. As an Eclipse IDE Working Group member, we are excited to contribute to the platform and help to keep it powerful for the next 20 years."

Yatta Solutions GmbH 

“To improve development, we need to enable developers. This includes providing them with the best possible tooling,” said Dr. Leif Geiger, product manager, Software Engineer and Co-Founder, Yatta Solutions. “Since the beginning, Eclipse has played a key role in my career. An IBM Eclipse innovation grant funded my research. And Yatta’s first product, UML Lab, is based on Eclipse. Over time, we have increased our commitment towards Eclipse: I became project lead of the Eclipse Marketplace Client open-source project, and I was recently elected Package Maintainer of the Eclipse IDE for Java Developers.”

Dr. Geiger continued, “I think that now more than ever, we need a vendor-neutral, open-source IDE for businesses and developers alike. By keeping this precious open ecosystem alive and kicking, we can remain independent. But to ensure the best possible future for Eclipse, the IDE needs to become more attractive for businesses and developers alike, and win developers as users and committers again. In the end, the Eclipse IDE is about collaboration among developers and across corporate borders. Let’s keep it that way. Here’s to another 20 years of the Eclipse IDE!”

About the Eclipse Foundation

The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.

Third-party trademarks mentioned are the property of their respective owners.

###

Media contacts 

Schwartz Public Relations for the Eclipse Foundation, AISBL

Julia Rauch / Sophie Dechansreiter / Tobias Weiß

Sendlinger Straße 42A

80331 Munich

EclipseFoundation@schwartzpr.de

+49 (89) 211 871 – 43 / -35 / -70

 

Nichols Communications for the Eclipse Foundation, AISBL

Jay Nichols

jay@nicholscomm.com

+1 408-772-1551


by Shanda Giacomoni at November 02, 2021 11:00 AM

Moving Embedded Software Development Tools into the Cloud

by Christopher Guindon (webdev@eclipse-foundation.org) at November 02, 2021 12:00 AM

In this article, we introduce the embedded special interest group (embedded SIG), hosted by the Eclipse Foundation. The embedded SIG is an open collaboration of embedded vendors and service providers, with the goal of strengthening the open source ecosystem for building web- and cloud-based tools used for embedded development. The SIG provides the structure for participants to coordinate efforts, share insights and collaborate on technical initiatives and standards.

by Christopher Guindon (webdev@eclipse-foundation.org) at November 02, 2021 12:00 AM

The unparalleled design of Eclipse Collections

by Donald Raab at November 01, 2021 04:49 AM

Exploring the evolutionary design of parallelism in Eclipse Collections

Photo by Jason Yuen on Unsplash

Plenty of data, memory, and cores

In 2006, I was working on a proprietary distributed Java caching architecture in a large financial services company. We cached and indexed all of the firm’s trades and positions in a complex object graph in memory so we could slice and dice through it at high speed. By this time, I had already built and was extensively leveraging the serial eager API of an internal library named Caramel. This library would eventually become what we now know as Eclipse Collections.

In the area I was working in 2006, we had many caches that were tens of gigabytes in size, networked together. There were many large collections (millions of objects) that we would iterate through in memory to perform various pipelined calculations which most often involved grouping, netting and aggregating various balances.

Around this time, I would discover the Fork/Join framework from Doug Lea in the original EDU.oswego concurrent utility library. The Fork/Join framework was initially left out of java.util.concurrent when Java 5 was released. It would later be included in Java 7. I learned about the Fork/Join framework reading about it in “Concurrent Programming in Java” (CPJ) and this paper on “A Java Fork/Join Framework” by Doug Lea.

I went looking for my copy of CPJ on my bookshelf as I was writing this blog and when I couldn’t find it, I bought myself a brand new copy. This book is a must read for all aspiring senior Java developers.

Eager Serial, Parallel and Fork/Join

The initial methods in the Caramel library were all serial and eager. I occasionally would add fused methods to combine a couple operations together to increase performance. For example, the method collectIf is a combination of select (inclusive filter) and collect (map or transform). It would be a few years before we would add lazy methods to the API in Eclipse Collections.

For more information and examples of fused methods, please check out the following blog.

From Eager to Fused to Lazy

The initial implementation of the parallel API in Caramel was eager. There is a utility class that is still available in Eclipse Collections today that provides this eager parallel functionality. The class is named ParallelIterate. The class initially used the Fork/Join framework from the EDU.oswego concurrent library. It would later be converted to use Executor after the java.util.concurrent package was introduced in Java 5 without the Fork/Join framework. When the Fork/Join framework was added in Java 7, a new utility class named FJIterate was added to GS Collections. FJIterate is included in its own module in Eclipse Collections and is distributed in a separate jar file. FJIterate has existed since mid-2013, which was two years after Java 7 was released (July 2011). It will require an extra Maven dependency if you want to use it.

<dependency>
<groupId>org.eclipse.collections</groupId>
<artifactId>eclipse-collections-forkjoin</artifactId>
<version>${eclipse-collections.version}</version>
</dependency>

The methods available on ParallelIterate and FJIterate are almost the same. The implementations are fairly similar, with the primary difference being that ParallelIterate uses Executor and and FJIterate uses the Fork/Join framework. Using Executor makes ParallelIterate more suitable for some tasks. For raw, in-memory compute performance, FJIterate is sometimes the better option.

Both ParallelIterate and FJIterate were built for the same reason. We wanted raw parallel performance for large in memory data sets that were backed by arrays. Both classes will parallelize execution for a fixed set of algorithms for any Iterable type. The primary workhorse for both ParallelIterate and FJIterate is a parallel forEach. All of the other parallel algorithms are implemented using parallel forEach. There are twelve overloaded forms of forEach on ParallelIterate and FJIterate. The overloads take different parameters to give as much control as possible to developers. The design rationale for this is simple. We believed that if someone was able to prove that they would benefit from parallelism, then they would be in the best position to decide how to tune various parameters to squeeze as much performance as possible out of the hardware for parallel use cases they had.

ParallelIterate

Here are the methods available on ParallelIterate.

ParallelIterate (Eclipse Collections - 10.4.0)

FJIterate

Here are the methods available on FJIterate

FJIterate (Eclipse Collections - 10.4.0)

ParallelIterate vs. FJIterate

The symmetric difference and intersection of the methods on the two utility classes are as follows.

Symmetric Difference and Intersection of ParallelIterate and FJIterate methods

The biggest difference is that several sumBy methods were added to ParallelIterate but not ported over to FJIterate.

The Futility of Utility

The downside of utility classes like ParallelIterate and FJIterate is that methods can only return a single type. You only get one choice, so if you want to return different implementations from a method based on the input parameter type, you have to choose a common parent type. Methods on ParallelIterate and FJIterate take any java.lang.Iterable as an input parameter, and methods that return collections (e.g. select, reject, collect) have to unfortunately return java.util.Collection. Developers can control the return type by using overloaded methods with the same name which take a target collection as a parameter. If the Iterable used as the source parameter implements the BatchIterable interface, it will be optimized for parallelism for both ParallelIterate and FJIterate. If the source does not implement BatchIterable, or does not implement java.util.List, both utility classes will default to copying the elements to an array before parallelizing.

Here are some examples of ParallelIterate using the basic form of select (inclusive filter) and the overloaded form of select that takes a target collection.

https://medium.com/media/33bcec800b6e1e1c018b3c66ebddb4cd/href

The behavior of ParallelIterate select method is to return a type similar to the Iterable type that is passed in. For a List, a List implementation will be returned. For a Set, a Set implementation is returned. Unfortunately, since there can only be one signature for this method, the return type has to be the most abstract type which is Collection. Collection as an interface is not terribly useful. If I ever get around to refactoring the utility, I will return MutableCollection or RichIterable instead of Collection. This will make the utility methods a lot more useful, and maybe just slightly less futile.

Lazy asParallel

We took a different approach when it came to designing and implementing the lazy parallel API in Eclipse Collections. We decided we would require developers to provide an Executor and a batch size instead of offering up multiple combinations of knobs and switches to configure via overloads as we did with our parallel utility classes. Based on our experience with supporting eager parallelism for seven years, these two parameters seemed to be the most important configuration options that developers wanted control over. This makes the lazy parallel API in Eclipse Collections slightly harder to use than parallelStream in the JDK. This is by design. It should be harder for a developer to write parallel code, because they first need to determine if using a parallel algorithm will speed up or slow down an operation. If a developer understands exactly what they are doing, because they ran benchmarks and have proven parallelism will indeed help the performance of a specific use case, then they will be in the best position to determine how to configure the parallelism for optimal performance.

The other more important difference between the eager and lazy parallel API, is that the algorithms are available through data structures themselves for lazy, instead of being located in a utility class like ParallelIterate.

Here’s an example that takes a million integers and filters all of the prime values into a Bag. I show a fluent approach first, and then break the fluent calls into their intermediate results to show the intermediate return types.

https://medium.com/media/5d77ae7f378a01314f099feaf722bb7b/href

Notice there is a very specific type named ParallelListIterable that is returned from asParallel. This type is lazy, so no real computation occurs until a terminal operation is called. The same type is returned after calling select. The method toBag is a terminal operation and results in a MutableBag being created. Now let’s look at what happens to our types if the initial collection is a MutableSet instead of a MutableList.

https://medium.com/media/06b093536ea85fac922cefdd35faf407/href

Notice the return type for asParallel for a MutableSet is ParallelUnsortedSetIterable.

ParallelListIterable vs. ParallelIterate

If we compare the methods available on ParallelListIterable with the methods available on ParallelIterate, it will become evident that a lot more investment has been made in growing the parallel lazy API in Eclipse Collections. The following shows the symmetric difference and intersection of methods available between both.

Symmetric Difference and Intersection of ParallelListIterable and ParallelIterate methods

JDK stream vs. parallelStream

Have you ever noticed the return type for stream and parallelStream in the JDK is the same type? They both return Stream. You might think that perhaps the implementations that are returned for the methods are different classes implementing the same interface, but they are not. Both stream and parallelStream return a new instance of ReferencePipeline.Head. The difference between them is a boolean parameter named parallel. What this means is that the serial and parallel code paths are mixed together, and usually split on a boolean expression involving a call to a method named isParallel where parallelism might choose a different path. I searched for usages of isParallel in AbstractPipeline and found there are 48 usages in the parent class and four subclasses (ReferencePipeline, IntPipeline, LongPipeline, DoublePipeline) .

The upside here is that the serial lazy and parallel lazy API in the JDK with streams is identical. Having a single implementation class for both serial and parallel guarantees this as they share the exact same code paths. The downside is that the code paths are hard to understand just by reading the code and very difficult to trace, even with the help of a debugger.

Eclipse Collections asLazy vs. asParallel

We’ve already seen that the return types for asParallel are covariant for the types the method is defined on. The return type will always be a subtype of ParallelIterable. ParallelIterable has no direct relation to RichIterable. The method asLazy, which is defined on RichIterable returns a LazyIterable. LazyIterable extends RichIterable.

The following class diagram shows the inheritance relationships between RichIterable, LazyIterable and ParallelIterable.

RichIterable, LazyIterable and ParallelIterable Interfaces

RichIterable is the parent type for LazyIterable and all of the container types in Eclipse Collections (e.g. MutableList/ImmutableList, MutableSet/ImmutableSet, etc.). LazyIterable provides serial lazy algorithm implementations.

ParallelIterable is the parent type for all corresponding parallel lazy adapters. There is a distinct split between serial and parallel API in Eclipse Collections. This means there is asymmetry between LazyIterable and ParallelIterable. This allows us to limit the parallel API to only those algorithms where there would be a reasonable performance benefit if parallelized. This also allows the serial implementations to be as simple as possible, and the parallel implementations can be optimized for specific types (e.g. Bag, List, Set).

LazyIterable vs. ParallelIterable

There are a lot more methods available on LazyIterable than on ParallelIterable. This can always change over time, if we determine that there is a need and a benefit to implementing a parallel version of a lazy serial method.

Symmetric Difference and Intersection of LazyIterable and ParallelIterable methods

Performance Benchmarks

I wrote some benchmarks a few years ago comparing filter, map, reduce and filter+map+reduce for a combination of serial, parallel, eager, lazy, object, and primitive types. The code and the results for the benchmarks were captured in the following blog. As you’ll see in the blog, I ran the benchmarks on JDK 8.

The 4 am Jamestown-Scotland ferry and other optimization strategies

I decided when I started writing this blog, I wanted to write new benchmarks. I wanted to run the benchmarks on JDK 17 so I could see how the older eager parallel and fork/join utility classes held up with all of the optimizations that have arrived in the last nine versions of the JDK. I also wanted to make the benchmark code immediately available in open source for developers to experiment with on their own, and arrive at their own conclusions on their own hardware. The benchmarks are part of the JMH Kata module in the BNYM Code Katas repo. This time I focused on a use case for filter+map. There is a fused method for filter+map on the ParallelIterate and FJIterate utility classes named collectIf. This method is also available on the serial API for

CodeKatas/FilterMapJMHBenchmark.java at master · BNYMellon/CodeKatas

The JMH Kata is what I refer to as a “sandbox kata”. You can use it as a sandbox to run your own experiments and try out your own benchmarks. It’s set up to run a few starter JMH benchmarks, and saves you the time of setting up a project to do the same.

Hardware

I used my MacPro “trash can” with the following hardware specs to measure the benchmarks:

Processor Name: 12-Core Intel Xeon E5
Processor Speed: 2.7 GHz
Number of Processors: 1
Total Number of Cores: 12
L2 Cache (per Core): 256 KB
L3 Cache: 30 MB
Memory: 64 GB

Software and Benchmark Configuration

I used OpenJDK 17 with Java Streams and Eclipse Collections 11.0.0.M2. I used JMH version 1.33 as the benchmark harness for the tests. I ran with 10 warmup iterations, and 10 measurement iterations with 2 forks. The warmup time and measurement time are both 5 seconds. I am using Mode.Throughput with the tests so they are easy to read. The numbers are in Operations per Second. The bigger the number, the better the result.

Data

I ran the benchmarks using a simple class named Person. Person has a name (String), age (int), heightInInches (double), weightInPounds (double). I ran the benchmarks for the the following data sizes.

  • 10,000 (filters and maps 4,995 values)
  • 100,000 (filters and maps 49,942 values)
  • 1,000,000 (filters and maps 499,615 values)
  • 8,675,309 (filters and maps 4,337,179 values)

The Charts

I sorted the columns in the chart from least to greatest, so it would be easy to find the slowest (far left) and fastest (far right) results. So be aware that the columns may be different for different data sizes.

Results — 10K People

Fastest Parallel: Eclipse Collections Eager Parallel (ParallelIterate)
Slowest Parallel: JDK Parallel Stream.toList()

Fastest Serial: Eclipse Collections Eager Serial
Slowest Serial: JDK Serial Stream Collectors.toList()

Filter / Map — Ops per second — 10,000 People

Results — 100K People

Fastest Parallel: Eclipse Collections Eager Parallel (ParallelIterate)
Slowest Parallel: JDK Parallel Stream Collectors.toList()

Fastest Serial: Eclipse Collections Eager Serial
Slowest Serial: JDK Serial Stream Collector.toList()

Filter / Map — Ops per second — 100,000 People

Results — 1 Million People

Fastest Parallel: Eclipse Collections Eager Fork/Join (FJIterate)
Slowest Parallel: Eclipse Collections Lazy asParallel()

Fastest Serial: Eclipse Collections Eager Serial
Slowest Serial: JDK Serial Stream Collector.toList()

Filter / Map — Ops per second — 1,000,000 People

Results — 8,675,309 People

Fastest Parallel: Eclipse Collections Eager Fork/Join (FJIterate)
Slowest Parallel: JDK Parallel Stream Collectors.toList()

Fastest Serial: Eclipse Collections Eager Serial
Slowest Serial: JDK Serial Stream Collectors.toList()

Filter / Map — Ops per second — 8,675,309 People

Results — JMH Output

Below is the raw consolidated JMH output used in the graphs above. There are also three mega sizes I tested with (25M, 50M, 100M) that I have not included graphs for. I had to switch from operations per second to milliseconds per operation on them so I didn’t want the graphs to be confusing. For the mega sizes, smaller numbers are better. The results with the mega sizes were consistent with Eclipse Collections Eager Fork/Join (FJIterate) being the fastest for parallel. Eclipse Collections Eager Serial was the fastest for the serial in all but the largest test, where JDK Serial Stream.toList() came out on top.

https://medium.com/media/527fbef4a785d8cfc316ef07b028b83a/href

Some Lessons Learned

After more than 15 years of building parallel eager utility classes in Eclipse Collections, I’ve learned a few things. I had forgotten some of the lessons I learned along the way, but writing this blog has helped me re-discover some of them while pouring over the code. Writing efficient parallel algorithms is extremely hard work, and you will spend a lot of time running and re-running benchmarks. It is a rabbit hole, and you will lose days or weeks of your life if you fall into it.

You can sometimes tune performance for specific eager algorithms so that maybe you will get a 5%, 10% or maybe even 20% speedup over more general lazy algorithms. If performance is really important to you, then you may find implementing specific use cases with lower level frameworks like Fork/Join or Executors will be beneficial. Sometimes even hand coding an algorithm using a higher level construct like a parallel forEach with an efficient concurrent data structure will give good returns.

In 2013, buying a personal desktop machine with a decent number of cores and RAM that I could run parallel benchmarks against seemed like it would be a good long term investment for Eclipse Collections. In retrospect, I think it was a good investment, as I have used the machine to prepare benchmarks for various talks and blogs over the years. My plan has been to not even look at upgrading my personal desktop again until 10 years have passed. Surprisingly, even with all the promise of multiple cores showing up in laptops and desktop machines, it hasn’t been until relatively recently that we’ve seen a decent uptick in the number of cores and RAM for less than a totally outrageous prices, like I paid for my Mac Pro “trash can” in 2013.

Even though I have run a lot of benchmarks on the MacPro over the years, I haven’t actually done much tuning at all of any of the parallel algorithms in Eclipse Collections. I had previously tested Eclipse Collections with an extremely large machine at my previous employer (24 cores, 256GB RAM). We were already seeing good speedups for many of the parallel eager and lazy algorithms we implemented. As I mentioned above, our parallel lazy algorithms were implemented more recently than the parallel eager, but also haven’t really been tuned much since late 2014. Craig Motlin gave a great talk in June 2014 on the Eclipse Collections parallel lazy implementation approach. It has some great explanations and lessons on how three different implementations (Java 8, Scala, Eclipse Collections previously GS Collections) were tuned for specific parallel algorithms. I will link to it here for anyone who is looking to learn some great lessons about optimization strategies for parallel algorithms.

Parallel-lazy Performance: Java 8 vs Scala vs GS Collections

The Future

Now that JDK 17 is released, and there are new, cheaper machines with more cores available on the market, it might be worthwhile testing and tuning the parallel algorithms in Eclipse Collections again. It might also be useful to expand on the current parallel lazy implementation. Java Streams seem to be improving for some parallel use cases, and can probably still benefit from approaches that Eclipse Collections uses to optimize specific algorithms like filter and map. Craig describes the approach we use in his talk above, so it is definitely worthwhile watching. Often the future can benefit from lessons learned in the past.

I would like to refactor and clean up the parallel eager implementations in Eclipse Collections and improve the symmetry between ParallelIterate and FJIterate. The biggest change I would like to make will be to change the return type from Collection to either RichIterable or MutableCollection. in ParallelIterate and FJIterate.

I would also like to see some folks opportunistically pick up and continue the work on parallel lazy implementation of Eclipse Collections. There are a lot of methods that have not been added yet as I illustrated above showing the difference between LazyIterable and ParallelIterable. There is a cost and a benefit to improving symmetry. So far, the cost for adding more parallel methods has outweighed the benefits, which is why we haven’t done much more work in this space. But for the right person, who might looking to cut their teeth on parallel programming, and maybe test out all the cores in their newly purchased MacBook Pro with an M1 Max, the benefits of learning how to build optimized parallel algorithms might outweigh the costs.

I believe that parallel programming will become increasingly important for a larger population of Java developers. Learning how to program and tune parallel algorithms effectively will be something many developers will need to learn. The knowledge and experience from books like CPJ from Doug Lea and “Java Concurrency in Practice” (JCIP) from Brian Goetz will become important and popular again. Now that I have my second brand new copy of CPJ, and my previously signed copy of JCIP, I am ready to re-learn the lessons of concurrency and parallelism all over again.

Final Thoughts

My goal for this blog was to share some lessons I learned from the past 15 years that otherwise might have gone undiscovered or completely forgotten. I doubt most developers who use Eclipse Collections will have dug into the parallel algorithms available in the library before reading this blog. I hope some Java developers read this blog and find it useful for helping them learn more about parallel programming approaches they may not have been previously aware of. If you read it and liked it, you can let me know by clapping and/or commenting. I generally dislike including micro-benchmarks in blogs, but I think folks find them interesting enough to start investigating and learning more. Take my benchmarks with a huge grain of salt and two pounds of skepticism. I wouldn’t recommend basing any decisions on them. I highly recommend writing your own application benchmarks for your own specific use cases and determining for yourself whether a particular approach will help you achieve better or worse performance. As I’ve recommended in my previous blog linked above:

Prove it before going Parallel.

Thanks for reading!

I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.


The unparalleled design of Eclipse Collections was originally published in Javarevisited on Medium, where people are continuing the conversation by highlighting and responding to this story.


by Donald Raab at November 01, 2021 04:49 AM

Eclipse JKube 1.5.1 is now available!

October 28, 2021 03:00 PM

On behalf of the Eclipse JKube team and everyone who has contributed, I'm happy to announce that Eclipse JKube 1.5.1 has been released and is now available from Maven Central.

Thanks to all of you who have contributed with issue reports, pull requests, feedback, spreading the word with blogs, videos, comments, etc. We really appreciate your help, keep it up!

What's new?

Without further ado, let's have a look at the most significant updates:

Kubernetes and OpenShift Gradle Plugins (Preview)

Eclipse JKube 1.5.1 finally brings the new Kubernetes Gradle Plugin and OpenShift Gradle Plugin. We're releasing these plugins as a preview including most of the standard functionality that you can find in the homologous Maven plugins. However, there's still work to do, so please share your feedback

Getting started

The first step is to add the plugin to your project:

plugins {
  id 'org.eclipse.jkube.kubernetes' version '1.5.1'
  /* ... */
}

Or in case of OpenShift:

plugins {
  id 'org.eclipse.jkube.openshift' version '1.5.1'
  /* ... */
}

If your application is based on Spring Boot, then this is all the configuration you'll need.

Available tasks

This is still a preview, more tasks are yet to come. Following is the list of the currently supported Gradle tasks:

TaskDescription
k8sBuildBuild container images
k8sPushPushes the built images to the container image registry
k8sResourceGenerate resource manifests for your application
k8sApplyApplies the generated resources to the connected cluster
k8sHelmGenerate Helm charts for your application
k8sDebugDebug your Java app running on the cluster
k8sLogShow the logs of your Java app running on the cluster
k8sUndeployDeletes the kubernetes resources that you deployed via the k8sApply task

The tasks can be executed as in the following example:

gradle build k8sBuild k8sPush k8sResource k8sApply

You can also check the recording of my EclipseCon 2021 session to learn more about the Gradle Plugins.

Hacktoberfest

This year we've been active members of the Hacktoberfest. This is aligned with our all year round first-timers-only issue strategy.

The 1.5.1 release includes around 30 contributions from members of the community who took part on Hacktoberfest 2021. On behalf of the core maintainer team I want to thank you all for your participation and making JKube even better with your contributions.

Using this release

If your project is based on Maven, you just need to add the kubernetes maven plugin or the openshift maven plugin to your plugin dependencies:

<plugin>
  <groupId>org.eclipse.jkube</groupId>
  <artifactId>kubernetes-maven-plugin</artifactId>
  <version>1.5.1</version>
</plugin>

If your project is based on Gradle, you just need to add the kubernetes gradle plugin or the openshift gradle plugin to your plugin dependencies:

plugins {
  id 'org.eclipse.jkube.kubernetes' version '1.5.1'
}

How can you help?

If you're interested in helping out and are a first time contributor, check out the "first-timers-only" tag in the issue repository. We've tagged extremely easy issues so that you can get started contributing to Open Source and the Eclipse organization.

If you are a more experienced developer or have already contributed to JKube, check the "help wanted" tag.

We're also excited to read articles and posts mentioning our project and sharing the user experience. Feedback is the only way to improve.

Project Page | GitHub | Issues | Gitter | Mailing list | Stack Overflow

Eclipse JKube Logo

October 28, 2021 03:00 PM

The Eclipse Foundation Joins Bosch, Microsoft, and Other Industry Leaders to Create an Open Source Working Group for the Software-Defined Vehicle

by Shanda Giacomoni at October 28, 2021 09:00 AM

Open source leader actively recruiting interested enterprises to develop a new vendor-neutral, working group focused on building the next-generation vehicles based on the open source model 

BRUSSELS – October 28, 2021The Eclipse Foundation, one of the world’s largest open source foundations, along with multiple industry leaders, including Bosch, Microsoft and others, today announced an open invitation for technology leaders to help define a new working group focused specifically on the Software-Defined Vehicle. The ultimate goal will be the creation of a vendor-agnostic, open source ecosystem with a vivid, contributing community focused on building the foundation for a new era in automotive software development. This announcement serves as a “call to action” for all interested parties to join this initiative and help shape the future of mobility. 

Today, next-generation vehicle developers are turning to software-based solutions for their new designs. The Eclipse Foundation believes this will lead to an open source revolution that results in software-defined vehicles. Software-defined vehicles will enable vehicle manufacturers as well as automotive suppliers to put software at the very center of vehicle development, with hardware considerations to follow. 

“We’re very excited to develop this new effort here at the Eclipse Foundation. Although we have extensive roots with the automotive community, a project of this scope and scale has never been attempted before,” said Mike Milinkovich, executive director of the Eclipse Foundation. “This initiative enables participants to get in at the ‘ground level” and ensure they each have an equal voice in this project.”

To achieve this significant change in the design process, this new working group will build the foundation of an open ecosystem for deploying, configuring, and monitoring vehicle software in a secure and safe way. Vehicle manufactures around the world may use this foundation to focus on differentiating customer features, like mobility services and end-user experience improvements, while saving time and cost on the non-differentiating elements, like operating systems, middleware or communication protocols.
 
To support the transformation to software-defined vehicles, major players from the technology industry as well as the automotive industry are encouraged to collaboratively  develop an open source in-vehicle application runtime stack, cloud-based vehicle operations as well as highly integrated development toolchains. The ultimate goal of the open source software-defined vehicle initiative is to scale in-vehicle software across vehicle models, product lines, brands, organizations, and time. 

The Eclipse Foundation and its decades of experience managing the governance of complex technology initiatives and multi-vendor organizations make it the ideal organization to help manage such an endeavor. Its commitment to transparency, vendor-neutrality, and a shared voice will ensure that all participants have the opportunity to shape the future of the working group.  

To learn more about getting involved with the Eclipse Foundation’s Software-Defined Vehicle initiative, please visit us at sdv.eclipse.org, or email us at membership@eclipse.org. 


Quotes from Members 

BlackBerry
“This Eclipse Foundation Software-Defined Vehicle collaboration will be an important factor in influencing next-generation Software-Defined Vehicle architectures,” said Grant Courville, vice-president of product management and strategy at BlackBerry QNX. “BlackBerry QNX has a long history of embracing industry standards and we continue to work very closely with our customers and partners to help define and enable future automotive architectures. As a founding member, for 20 years BlackBerry has had a front row seat to The Eclipse Foundation’s relentless pursuit to help spur developer innovation and we’re thrilled to be part of this new initiative with a view to accelerating the software-defined future of automotive.”

Bosch
“Technological, organizational, and cultural innovations pave the way for the software-defined vehicle. The use of open-source software and technology neutrality are the pillars for a strong community to actively shape the transformation in automotive software engineering together with our customers and partners,” said Sven Kappel, vice president - Head of Project Software Defined Vehicle at Bosch. “For Bosch, collaboration across industries is key to realize the software-defined vehicle. Together with the Eclipse Foundation and other participants we are driving this change and looking forward to welcoming additional contributors to the initiative.”

EPAM Systems
“The automotive industry is undergoing a period of rapid transformation, with the next generation of vehicles transitioning to software-defined,” said Alex Agizim, CTO, Automotive & Embedded Systems, EPAM. “EPAM is proud to bring its embedded engineering and digital orchestration expertise to this industry-first initiative for open-source software-defined vehicles. In partnership with Bosch, Microsoft, The Eclipse Foundation and more, this collaboration will help usher in the new era in automotive development.”

ETAS
“The software-defined vehicle will play a key role in the future of mobility,” said Christoph Hartung, president and chairman of the ETAS Board of Management. “The explosive increase in complexity can only be mastered by working closely together as we do in this initiative.” 

Microsoft
​​“With digital technologies unlocking the future of accessible, sustainable and safe transportation experiences, mobility services providers are increasingly looking to differentiate through software innovation,” said Ulrich Homann, corporate vice president and Distinguished Architect, Microsoft. “By standardizing the development, deployment and management of software-defined vehicles through collaboration in the open-source space, businesses can bring tailored mobility solutions to their customers faster and can focus on innovations.” 

Red Hat
“Since our founding, Red Hat has clearly seen and advocated for open source collaboration as a force multiplier for software quality and value,” said Francis Chow, vice president, In-Vehicle Operating System, Red Hat. “We are pleased to collaborate on software-defined vehicles built with an open source backbone alongside the other member organizations of the Eclipse Software-Defined Vehicle initiative.”

SUSE
“Defining and developing the software-defined vehicle will transform the automotive industry, enabling manufacturers to truly address the rapidly changing concerns and pain points the market is experiencing today,” said Thomas Di Giacomo, SUSE chief technology and product officer. “For nearly 30 years, SUSE has been a trusted partner supporting systems and essential workloads in some of the most challenging and critical industries, including the automotive industry. We are eager to contribute our experience and ready-to-use open source technologies to help advance the automotive software industry.”

About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.


Third-party trademarks mentioned are the property of their respective owners.

###

Media contacts: 

Schwartz Public Relations for the Eclipse Foundation, AISBL
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 – 43 / -35 / -70

Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
 


by Shanda Giacomoni at October 28, 2021 09:00 AM

Introducing Oniro: A Vendor Neutral, Open Source OS for Next-Gen Devices

by Mike Milinkovich at October 26, 2021 12:01 PM

It’s a rare event when a new operating system comes along. And it’s even rarer to have the opportunity to influence the direction of that OS at its earliest stages. So I’m delighted to tell you that today we are announcing a new working group and top-level project that gives you that opportunity. The Oniro community will nurture and evolve the Oniro operating system, a transparent, vendor-neutral, and independent OS for the next generation of distributed systems.

The Oniro OS will provide a true, community-driven open source solution that runs on a wider spectrum of devices than today’s operating systems. And it will make it far easier to integrate different types of next-gen hardware and software.

Architected to Go Beyond Today’s Operating Systems

The Oniro OS can run on more devices than current operating systems because it features a multi-kernel architecture:

  • A Linux Yocto kernel allows the OS to run on larger embedded devices, such as Raspberry Pi-class devices 
  • A Zephyr kernel allows the OS to run on highly resource-constrained devices, such as a coffee maker or a thermostat

With the ability to run the same OS on different classes of devices, Oniro will provide an ideal solution to support the future of IoT, machine economy, edge, mobile, and other next-gen devices:

  • Consumers and adopters of the Oniro OS will have a more seamless experience than they have with the current generation of operating systems.
  • Devices will be able to directly connect to one another and share data, enabling a much higher degree of interoperability than is possible today.
  • Data exchanged between devices can flow directly to one another rather than always being shared via the cloud, enabling low latency architectures which are also inherently more secure and private. 

We expect the initial use cases for Oniro will be in the IoT and industrial IoT domains with applications for mobile devices coming later as the community evolves, grows, and establishes its roadmap.

Enabling the Global Ecosystem for OpenHarmony

Oniro is an independent open source implementatio of OpenAtom’s OpenHarmony. To deliver on the promise of Oniro, the community will deliver an independent, but compatible implementation of the OpenHarmony specifications, tailored for the global market. OpenHarmony is based on HarmonyOS, a multi-kernel OS that was developed by Huawei and contributed to the OpenAtom Foundation last year. In the future Oniro will also deliver additional specifications to help drive global adoption.

By creating a compatible implementation of OpenHarmony, the Oniro community can ensure that applications built for Oniro will run on OpenHarmony and vice versa. This interoperability will allow the Oniro community to create a global ecosystem and marketplace for applications and services that can be used across both operating systems, anywhere in the world. 

Join an Innovative Open Source Community

I truly believe that Oniro is open source done right. It’s a huge opportunity to build an operating system that rethinks how devices across many different device classes can interoperate in a secure and privacy-preserving way. 

Because Oniro’s evolution is being guided by an open and vendor-neutral community using the Eclipse Development Process, openness and transparency are a given. This will go a long way towards building the engagement and stakeholder trust necessary to create the global ecosystem.

The founding members of the Oniro Working Group include telecom giant, Huawei, Arm software experts Linaro, and industrial IoT specialists Seco. As more organizations become aware of Oniro, we expect the community to encompass organizations of all sizes and from all industries. 

I strongly encourage everyone with an interest in next-gen devices — corporations, academics, individuals — to take the opportunity to get involved in Oniro in its earliest stages. To get started, join the Oniro conversation by subscribing to the Oniro working group list.


by Mike Milinkovich at October 26, 2021 12:01 PM

Open Source Leader the Eclipse Foundation Launches Vendor-Neutral Operating System for Next-Generation Device Interoperability

by Jacob Harris at October 26, 2021 07:00 AM

FOR IMMEDIATE RELEASE

Oniro will provide a true open source solution to make multi-device hardware and software integration easier

Brussels, October 26, 2021The Eclipse Foundation, a European open source foundation, furthering the recently announced cooperation with the OpenAtom Foundation, announced today the launch of the Oniro project and working group. 

Oniro aspires to become a transparent, vendor-neutral, and independent alternative to established IoT and edge operating systems. To achieve this goal and ensure Oniro has a global reach, the Eclipse Foundation and its members will deliver a compatible independent implementation of OpenHarmony, an open source operating system specified and hosted by the OpenAtom Foundation.

“Oniro is open source done right,” said Mike Milinkovich, executive director of the Eclipse Foundation. “It represents a unique opportunity to develop and host a next-generation operating system to support the future of mobile, IoT, machine economy, edge and many other markets.”

With the creation of the Oniro top-level project, the Eclipse Foundation aims to strengthen the global technology ecosystem, while bringing a vendor-neutral, open source OS to the global market.

To facilitate the governance for the Oniro device ecosystem, the Eclipse Foundation is also launching a new dedicated working group. The Eclipse Foundation’s working group structure provides the vendor neutrality and legal framework that enables transparent and equal collaboration between companies.

“We’re very proud to be hosting a major European open source project with worldwide contribution aiming to develop an independent OS,” says Gaël Blondelle, vice president of European ecosystem development. “To achieve this, we want to welcome developers and companies from Europe and the rest of the world to join our working group at the Eclipse Foundation and bring this groundbreaking project to life together.”

Quotes from Supporters

Huawei
“We have been working hard with Linaro, Seco, Array, NOITechPark, Synesthesia to prepare Oniro’s initial code contribution and public cloud CI/CD infrastructure, and it is so exciting to see everything moving under the expert governance of the Eclipse Foundation,” said Davide Ricci, Director of the Huawei’s Consumer Business Group European Open Source Technology Center. “Under the Eclipse Foundation the project will have its greatest chance at onboarding new contributing members and bringing real products on the shelves of consumer electronics stores around the world. We reckon Oniro is not a sprint, rather a marathon, and we are thrilled and committed to this world changing journey.”

Linaro 
“Over the past year, Linaro has worked closely with Huawei and other Oniro members on preparing the OS foundations of Oniro, leveraging the work Linaro is already doing on open source projects such as MCUboot, the Yocto project, Trusted Substrate and multiple RTOSs,” said Andrea Gallo, VP of Business Development. “Formalizing the governance of this project through the Eclipse Foundation is the natural next step in delivering a truly vendor-neutral and independent operating system.” 

SECO
“Oniro will be the future of the open source OS, it will mark a new trend for its deeply innovative nature and defining it only as an operating system would be extremely reductive. In fact, it focuses on the end-user with an incredible user-experience, but it is also oriented to the content creators and OEMs at the same time, bringing to all of them certainty, choice and convenience,” said Gianluca Venere, Chief Innovation Officer, SECO. “It is born for device collaboration at the edge, to be hardware architecture independent, to create a swarm intelligence, and to enable ambient computing. For more than 40 years SECO has been designing and manufacturing innovative products and services for OEMs and we strongly believe that Oniro is a game changer in supporting our customers to the digital transformation.”

About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.

Media Contacts:

Schwartz Public Relations for Eclipse Foundation
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 – 43 / -35 / -70

Nichols Communications for Eclipse Foundation in North America
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551

PR Paradigm for Eclipse Foundation in France
Oscar Barthe
oscar@prparadigm.com
(+33) 06 73 51 78 91 
 

MSL Group for Eclipse Foundation in Italy
Rosa Parente
rosa.parente@mslgroup.com
+39 340 8893581


by Jacob Harris at October 26, 2021 07:00 AM

The Eclipse IoT Working Group Celebrates its 10th Anniversary

by Jacob Harris at October 25, 2021 11:00 AM

The world’s largest open source community for edge and IoT continues to drive innovation that benefits a broad range of industries and applications 

 

BRUSSELS – October 25, 2021 – The Eclipse Foundation, one of the world’s largest open source software foundations, today celebrated the 10th Anniversary of the Eclipse IoT Working Group. Eclipse IoT is the largest open source IoT community in the world with 47 working group members, 47 projects, 360 contributors, and more than 32 million lines of code.

“It would be challenging to measure the industry impact of the Eclipse IoT Working Group over the past 10 years,” said Mike Milinkovich, executive director of the Eclipse Foundation. “From day one, this working group had a vision focused on developing actionable code as opposed to blueprints or standards, which has enabled it to stand apart from other organizations. This focus, along with the broad and diverse mix of Eclipse IoT ecosystem participants, has led to an extremely vibrant community that has helped drive commercial innovation and adoption at scale.”
 
In addition to original founding members, IBM and Eurotech, the current Eclipse IoT ecosystem now includes globally recognized players such as Bosch.IO, Red Hat, Huawei, Intel, SAP, and Siemens. The community is further enriched with Industrial IoT (IIoT) specialists like Aloxy, Cedalo, itemis, and Kynetics; along with edge IoT innovators that include ADLINK Technology and Edgeworx.
    
Eclipse IoT is home to open source innovation that has delivered some of the industry’s most popular IoT protocols. CoAP (Eclipse Californium), DDS (Eclipse Cyclone DDS), LwM2M (Eclipse Leshan), MQTT (Eclipse Paho, Eclipse Mosquitto and Eclipse Amlen) and OPC UA (Eclipse Milo) are all built around Eclipse IoT projects. Other popular Eclipse IoT production-ready platforms cover use cases such as digital twins (Eclipse Ditto), energy management (Eclipse VOLTTRON), contactless payments (Eclipse Keyple), Smart cities (Eclipse Kura) in addition to Eclipse Kapua  — a modular IoT cloud platform that manages data, devices, and much more.
 
To learn more about how to get involved with Eclipse IoT, Edge Native, Sparkplug or other working groups at the Eclipse Foundation, visit the Foundation’s membership page. Working group members benefit from a broad range of services, including exclusive access to detailed industry research findings, marketing assistance, and expert open source governance.

For further IoT & edge related information, please reach us at:
IoT@eclipse.org
Edgenative@eclipse.org

Quotes from Eclipse IoT Working Group pioneers

Andy Stanford-Clark, IBM UK CTO & Co-Inventor of MQTT
“Our original vision for the IoT Working Group was to create and curate a software stack which would enable developers to write ‘applications for platforms’, rather than ‘custom code for specific devices.’ Over the 10 years, I think we’ve made that vision a reality. I’m immensely proud of what we’ve achieved together.”

Andy Piper, Developer Advocate & Founding Project Lead, Eclipse Paho 
“It is inspiring to see the range and scope of projects that make up the Eclipse IoT Working Group, 10 years on - we knew that the keys to success would be open source, interoperability, and open standards. I’m hugely proud of the success of MQTT and Mosquitto, and the wider ecosystem in this space.” 

Marco Career, CTO, Eurotech
“Eclipse IoT WG has shattered the silos of monolithic M2M applications and proprietary connectivity by promoting open standards and open architectures while creating a vibrant community of interoperable projects. Eurotech is proud of having been part of this journey and we wish Eclipse IoT WG 10 more successful years”.

Deb Bryant, Senior Director, Open Source Program Office, Red Hat
“The 10th anniversary of the Eclipse Foundation IoT Working Group is a significant milestone not only for its members and partners, but for the technology and open source communities. Many solutions to challenges within global IoT ecosystems are the result of the Eclipse Foundation IoT Working Group’s dedication over the last decade to creating a vendor-neutral community of open source projects. Red Hat is proud to be a member of the Eclipse Foundation and looks forward to continuing our support for the IoT Working Group and helping to foster open source IoT achievements.”

Benjamin Cabé, Principal Program Manager, Microsoft:
“It is both exciting and humbling to see how our initial vision of enabling an Internet of Things based on open source and open standards has effectively turned into a reality, ten years down the road. The Eclipse IoT Working Group and its community of passionate individuals have been a catalyst for IoT innovation, and I am looking forward to ten more years of success!”

About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.
Third-party trademarks mentioned are the property of their respective owners.

###

Media contacts 

Schwartz Public Relations for the Eclipse Foundation, AISBL
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 – 43 / -35 / -70

Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
 


by Jacob Harris at October 25, 2021 11:00 AM

What Cloud Developers Want

by Mike Milinkovich at October 22, 2021 12:30 PM

The results of our first-ever Cloud Developer Survey are in, providing important insight into the development tools being used today, the role of open source, and the capabilities developers are looking for in next generation cloud-based tools and IDEs.  

The Cloud Developer Survey was conducted April 22-May 1, 2021, with more than 300 software developers, DevOps specialists, architects, and IT leaders in the US, UK, France, and Germany being interviewed. It’s important to point out that this survey was fielded by an independent team of analysts with the express purpose of minimizing bias, and to provide a clear market perspective to our member community. 

In commissioning this research project, our primary objective was to gain a better understanding of cloud-based developer trends by identifying the requirements, priorities, and challenges faced by organizations that deploy and use cloud-based development solutions, including those based on open source technologies. Our expectation is that through these findings, we can better ensure developers have the tools and technologies they need for cloud native application development.

An interesting finding is that more than 40 percent of survey respondents indicated that their company’s most important applications are now cloud native. And only three percent said their company has no cloud migration plans for important on-premise applications. This bodes well for the growth in cloud-based tools to help accelerate this trend and migration.

Developers Expect Open Source Tools and Technologies

One of the most significant trends revealed by the survey is the extremely high value developers place on open source. This is a rare number to see in survey results, but 100 percent of participating organizations said they allow their developers to use open source technologies for software development; though 62 percent do place at least some restrictions on usage.

Looking ahead, developers expect open source to continue to grow in popularity, with more than 80 saying they consider open source to be important both now and in the future. With the focus on cloud native applications and growing reliance on open source, it’s safe to say that open source and cloud development go hand-in-hand, and are here to stay.

Flexibility, Better Integrations, and Innovation are Attractive 

The Cloud Developer Survey also revealed that while developers use a variety of tools, they prefer using those with which they’re already familiar. This is reflected by the fact that 57 percent of survey respondents are still using desktop IDEs, including the Eclipse IDE. What this means is that there remains a huge developer community that has yet to benefit from open source cloud IDE technologies like Eclipse Theia, Eclipse Che, and Open VSX Registry, along with the ecosystem and products built around them.

Developers that do use cloud-based tools aren’t necessarily tied to using what their cloud provider recommends. Instead, they prefer open source options that offer opportunities for customization and innovation. No matter which technologies developers opt to use, increasing productivity is crucial. Developers are looking for better integrations of APIs and other features and tools that help save them time and effort.

Developers also want the flexibility to choose best-of-breed products and tools as needed to work more efficiently and to support the next wave of innovation in artificial intelligence, machine learning, and edge technologies. Open source drives innovation in these technologies, and flexible, open source tools will be key to attracting top talent to these cutting-edge development opportunities.

Read the Full Report and Recommendations

To review the complete Cloud Developer Survey results and the associated recommendations, download the survey report.

For more information about the Eclipse Cloud DevTools ecosystem and its benefits for members, visit the website.


by Mike Milinkovich at October 22, 2021 12:30 PM

OSGi Services with gRPC - Let's be reactive

by Scott Lewis (noreply@blogger.com) at October 20, 2021 02:54 AM

ECF has just introduced an upgrade to the grpc distribution provider.   Previously, this distribution provider used ReaxtiveX java version 2 only.  With this release, ReactiveX java version 3 is also supported.

As many know, gRPC allows services (both traditional call/response [aka unary] and streaming services) to be defined by a 'proto3' file.  For example, here is a simple service with four methods, one unary (check) and 3 streaming (server streaming, client streaming, and bi-directional streaming)
syntax = "proto3";

package grpc.health.v1;

option java_multiple_files = true;
option java_outer_classname = "HealthProto";
option java_package = "io.grpc.health.v1.rx3";

message HealthCheckRequest {
string message = 1;
}

message HealthCheckResponse {
enum ServingStatus {
UNKNOWN = 0;
SERVING = 1;
NOT_SERVING = 2;
SERVICE_UNKNOWN = 3; // Used only by the Watch method.
}
ServingStatus status = 1;
}

service HealthCheck {
// Unary method
rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
// Server streaming method
rpc WatchServer(HealthCheckRequest) returns (stream HealthCheckResponse);
// Client streaming method
rpc WatchClient(stream HealthCheckRequest) returns (HealthCheckResponse);
// bidi streaming method
rpc WatchBidi(stream HealthCheckRequest) returns (stream HealthCheckResponse);
}
The gRPC project provides a plugin so that when protoc is run, java code (or other language code) is generated that can then be used on the server and/or clients.

With some additional plugins, the classes generated by protoc can use the ReactiveX API for generating code.   So, for example, here is the java code generated by running protoc, grpc, reactive-grpc, and the osgi-generator plugins on the above HealthCheck service definition.  

Note in particular the HealthCheckService interface generated by the osgi-generator protoc plugin:
package io.grpc.health.v1.rx3;

import io.reactivex.rxjava3.core.Single;
import io.reactivex.rxjava3.core.Flowable;

@javax.annotation.Generated(
value = "by grpc-osgi-generator (REACTIVEX) - A protoc plugin for ECF's grpc remote services distribution provider at https://github.com/ECF/grpc-RemoteServiceSProvider ",
comments = "Source: health.proto. ")
public interface HealthCheckService {
/**
* <pre>
* Unary method
* </pre>
*/
default Single<io.grpc.health.v1.rx3.HealthCheckResponse> check(Single<io.grpc.health.v1.rx3.HealthCheckRequest> requests) {
return null;
}
/**
* <pre>
* Server streaming method
* </pre>
*/
default Flowable<io.grpc.health.v1.rx3.HealthCheckResponse> watchServer(Single<io.grpc.health.v1.rx3.HealthCheckRequest> requests) {
return null;
}
/**
* <pre>
* Client streaming method
* </pre>
*/
default Single<io.grpc.health.v1.rx3.HealthCheckResponse> watchClient(Flowable<io.grpc.health.v1.rx3.HealthCheckRequest> requests) {
return null;
    }
    /**
* <pre>
* bidi streaming method
* </pre>
*/
default Flowable<io.grpc.health.v1.rx3.HealthCheckResponse> watchBidi(Flowable<io.grpc.health.v1.rx3.HealthCheckRequest> requests) {
return null;
}
}

Note that it uses the two ReactiveX 3 classes: io.reactivex.rxjava3.core.Single, and io.reactivex.rxjava3.core.Flowable. These two classes provide api for event-driven/reactive sending and receiving of unary (Single) and streaming (Flowable) arguments and return values.

The ReactiveX API...particularly Flowable...makes it very easy to implement both consumers and implementers of the streaming API, while maintaining ordered delivery and non-blocking communication.

For example, this is a simple implementation of the HealthCheckService. Note how the Single and flowable methods are able to express the implementation logic through methods such as Flowable.map.
Here is a simple implementation of a consumer of the HealthCheckService.

The use of the ReactiveX API simplifies both the implementation and the consumer use of both unary and streaming services. As an added bonus: the reactive-grpc library used in the ECF Distribution provider provides *flow-control* using backpressure.

In next article I'll describe how OSGi Remote Services can be easily used to export, publish, discover, and import remote services with full support for service versioning, security, and dynamics. I'll also describe one can use tools like maven or bndtools+eclipse to generate source code (as above) from a proto3 file and easily run a generated service as an OSGi Remote Service.


by Scott Lewis (noreply@blogger.com) at October 20, 2021 02:54 AM

Eclipse Foundation Projects are OpenChain Conformant

by Mike Milinkovich at October 19, 2021 01:46 PM

Today we announced that the Eclipse Foundation is the first open source foundation to confirm its open source development process conforms with the OpenChain ISO 5230 international standard for open source license compliance. This means that every Eclipse Foundation project is being developed under a process which conforms to the ISO 5230 standard. The announcement is great news for our open source software contributors, users, adopters, and stakeholders globally.

The OpenChain ISO 5230 standard is officially known as the OpenChain 2.1 ISO/IEC 5230:2020 standard, and is maintained by the OpenChain Project. Its goal is to provide a clear and effective process management standard, so that organizations of all sizes, in all industries, and in all markets can benefit from a more efficient and effective open source supply chain.  

The time and effort we put into documenting that our existing development processes comply with the OpenChain ISO 5230 standard will help strengthen global supply chain integrity, and showcases our commitment to supporting our members and all of our projects’ downstream adopters.

Supported by Leading Organizations Globally

Before it became an official ISO/IEC standard in December 2020, the OpenChain initiative was the de facto standard for several years. The standard was developed based on the contributions of more than 100 project participants, and supported by organizations including Arm, BMW Car IT, Bosch, Cisco, Comcast, Ericsson, Facebook, Fujitsu, Google, Hitachi, Huawei, Microsoft, MOXA, OPPO, Panasonic, Qualcomm, Siemens, Sony, Toshiba, Toyota, and Uber. 

The breadth, depth, and diversity of organizations involved in developing the OpenChain ISO 5230 standard clearly demonstrate the importance with which the initiative is viewed across industries. The availability of the official, published standard is expected to increase conformance from hundreds of organizations to thousands. But to my knowledge, the Eclipse Foundation is the first open source foundation that has done the work necessary to document that all of our projects are developed under an OpenChain conformant process. This is an important milestone for both the Eclipse Foundation and for the OpenChain standard and its community.

Learn More and Get Involved

Because the OpenChain ISO 5230 standard is open, everyone with an interest in the initiative can engage with the community, share their knowledge, and contribute to the future of the standard. 

Follow the links below to learn more:


by Mike Milinkovich at October 19, 2021 01:46 PM

Open Source Software Leader the Eclipse Foundation Announces It Has Achieved OpenChain ISO 5230 Conformance

by Jacob Harris at October 19, 2021 11:00 AM

BRUSSELS – October 19, 2021 – The Eclipse Foundation AISBL, a global community fostering a mature, scalable, and business-friendly environment for software collaboration and innovation, has announced that it is the first open source software foundation to confirm that its open source development and license management processes are OpenChain ISO 5230 conformant. This means that all Eclipse Foundation open source projects are developed under an  ISO 5230 conformant program which fulfills the license compliance requirements of the standard. 

“Certifying that our development process is OpenChain ISO 5230 conformant is another step in showcasing our foundation’s role in the global open source ecosystem which is critical to today’s innovation-driven economy,” said Mike Milinkovich, Executive Director of the Eclipse Foundation. “We are thrilled to provide our worldwide contributors, users, adopters, and stakeholders the opportunity to benefit from a more efficient and effective open source supply chain."

OpenChain ISO 5230 is a simple, clear and effective process management standard for open source license compliance. The OpenChain Project maintains the International Standard for open source license compliance. This allows companies of all sizes and in all sectors to adopt the key requirements of a quality open source compliance program. 

Interested parties can find out more about this open standard here - https://www.openchainproject.org/about 

Supporting Quotes

Bosch
"Open Source is at the center of many products within Bosch," says Marcel Kurzmann, representative of Bosch in the OpenChain Governing Board, Robert Bosch GmbH. "Having OpenChain compliant supply chains is a key building block  for an efficient handling of the Open Source parts. Thus, we welcome the initiative of the Eclipse Foundation to develop Open Source projects in an OpenChain compliant way."

SAP
“Open source is at the heart of many SAP solutions and our innovation strategies in segments such as Industry 4.0,” said Peter Giese, Director of SAP Open Source Program Office, SAP. “Being able to both contribute to and consume Eclipse Foundation projects developed under OpenChain conformant processes simplifies and enhances the open source supply chain for us, our partners and customers.”

Daimler 
“FOSS is everywhere! It is in the vehicles we sell, in the mobile apps we provide, in our backend systems and websites, and even used on the shop floor every day. To foster OpenChain conformance in our open source supply chain we recommend our software suppliers to get certified and commit to this ISO standard”, says Christian Wege, member of FOSS CoC at Daimler.

OpenChain Project
“The heart of open source is collaboration and Eclipse Foundation is an exemplary example of where such collaboration takes place,” says Shane Coughlan, OpenChain General Manager. “I look forward to our ongoing engagement as we help foster a new phase in open source supply chains. We are reaching an era where OpenChain ISO 5230 and related standards are the key to rapid, clear management of code."

About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org.

Third-party trademarks mentioned are the property of their respective owners.


###


Media contacts 

Schwartz Public Relations for the Eclipse Foundation, AISBL
Julia Rauch / Sophie Dechansreiter / Tobias Weiß
Sendlinger Straße 42A
80331 Munich
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 – 43 / -35 / -70

Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
 


by Jacob Harris at October 19, 2021 11:00 AM

Alice’s adventures in Sirius Web Land

October 11, 2021 10:00 AM

Since my early childhood I have loved stories, listening to books read by my mum, then reading by myself comics or classical literature for school and now, as I dedicate not so much time to reading, mostly blog posts and news on the internet. One of my favorite novels remains “Alice’s Adventures in Wonderland”. Alice's Adventures in Wonderland

A young girl named Alice falls through a rabbit hole into a fantastic world of weird creatures. She meets people, she experiences, she tastes, she has to make decisions, sometimes she’s scared, and the minute after she’s happy. This book is like a roller coaster full of events and emotions.

When I think about our job at Obeo, when we have to create a tool dedicated to a specific domain for one of our customers, I feel like we are all small Alices experiencing the Sirius Land. We start by meeting people, trying to understand their jobs, their needs, we make decisions about what concepts we will specify, how they will be represented… Sometimes it works “Yes! I did it!” and sometimes the user’s feedback is not so good and we rework the tool “Oh, no, try again ;(“…

One year ago, we at Obeo released a fist version of the Sirius Web project and I had this little Alice in mind…

Alice was beginning to get very tired of creating DSL graphical editors and of having too many things to do: start Eclipse, describe her domain with Ecore, generate the EMF code, launch another Eclipse runtime, specify her graphical mappings with Sirius Desktop, test with another Eclipse runtime, package everything to an update site, send it to Bob so that he can install it, help Bob who can’t find how to install the modeler, reiterate from the beginning to update the tool according to Bob feedbacks and needs…

“Oh dear! Would you tell me, please, which way I ought to go from here?” she asked,

“That depends a good deal on where you want to get to,” said the Cat.

Alice prayed for a framework to easily create and deploy her studios to the web!

Curiouser and curiouser! This exists!

I have a talk at EclipseCon 2021 to tell you about Alice in Sirius Web Land! In this session, I will introduce and demonstrate:

  • how to describe your domain
  • how to specify your graphical editor
  • how to deploy your studio to your end-users … everything from your browser, thanks to Sirius Web!

This is not a dream, this is really happening!

Sirius Web Domain and View definitions

I will demonstrate all examples using 100% open-source software. Come and join me! You have no excuse, register at EclipseCon. As it is a virtual event you can attend from anywhere, even from Wonderland!


October 11, 2021 10:00 AM

Back to the top