planeteclipse.org
Open in
urlscan Pro
198.41.30.200
Public Scan
Submitted URL: http://planeteclipse.org/
Effective URL: https://planeteclipse.org/planet/
Submission: On January 25 via api from DE — Scanned from CA
Effective URL: https://planeteclipse.org/planet/
Submission: On January 25 via api from DE — Scanned from CA
Form analysis 1 forms found in the DOM
POST https://eclipsecon.us6.list-manage.com/subscribe/post
<form action="https://eclipsecon.us6.list-manage.com/subscribe/post" method="post" target="_blank">
<div class="form-group">
<input type="hidden" name="u" value="eaf9e1f06f194eadc66788a85">
<input type="hidden" name="id" value="46e57eacf1">
</div>
<input type="submit" value="Subscribe" name="subscribe" class="button btn btn-warning">
</form>Text Content
Cookie settings
Some Eclipse Foundation pages use cookies to better serve you when you return to
the site. You can set your browser to notify you before you receive a cookie or
turn off cookies. If you do so, however, some areas of some sites may not
function properly. To read Eclipse Foundation Privacy Policy click here.
DeclineAllow cookies
Skip to main content
* Manage Cookies
Donate
* About
* Add your blog
* Community
* Marketplace
* Events
* Planet Eclipse
* Newsletter
* Videos
* Blogs
* Participate
* Report a Bug
* Forums
* Mailing Lists
* Wiki
* IRC
* Research
* Eclipse IDE
* Download
* Documentation
* Getting Started / Support
* How to Contribute
* IDE and Tools
* Newcomer Forum
* More
* * Community
* Marketplace
* Events
* Planet Eclipse
* Newsletter
* Videos
* Blogs
* Participate
* Report a Bug
* Forums
* Mailing Lists
* Wiki
* IRC
* Research
* Eclipse IDE
* Download
* Documentation
* Getting Started / Support
* How to Contribute
* IDE and Tools
* Newcomer Forum
Toggle navigation
1. Home
2. Community
3. Planet Eclipse
* Latest Posts
* Blogs
JANUARY 22, 2024
John Kellerman
UNVEILING THE POWER OF OPEN VSX: AN OPEN HUB FOR TOP VS CODE EXTENSIONS
by John Kellerman at January 22, 2024 07:12 PM
Unveiling the Power of Open VSX: An Open Hub for Top VS Code Extensions
Open VSX is an open-source registry for VS Code extensions, providing a
decentralized and community-driven alternative to the Visual Studio Code
Marketplace. Created to foster collaboration and innovation, Open VSX offers
developers a space to share, discover, and contribute to a growing repository of
extensions. Open VSX offers a curated selection of extensions that caters to
various programming languages and development workflows. It's not about
quantity; it's about quality and relevance to the community's needs.
Image
Open VSX boasts a collection that includes all of the most popular (top 100) VS
Code extensions available on the Visual Studio Code Marketplace under open
source licenses. These extensions cover a wide range of functionalities, from
code formatting and linting to language support, debugging, and version control.
For example, you can find extensions for editing and debugging Python and
Jupyter notebooks, editing and debugging Java, and Gitlens, a powerful tool for
improved collaboration and productivity with Git.
What sets Open VSX apart is its commitment to openness and inclusivity. Anyone
can contribute to the platform and its extensions can be used in any compatible
IDE, making it a true reflection of the diverse needs and preferences of the
developer community.
Open VSX stands as a testament to the collaborative spirit of the developer
community. It's not just a registry; it's a thriving ecosystem where developers
come together to elevate their coding experience.
If you'd like to become part of the Open VSX community, consider publishing an
extension; contributing to one of the projects that comprise the deployment,
eclipse/openvsx, EclipseFdn/open-vsx.org, and open-vsx/publish-extensions;
subscribe to our mailing list; or join us as part of the Open VSX Working Group.
John Kellerman Mon, 2024-01-22 14:12
--------------------------------------------------------------------------------
by John Kellerman at January 22, 2024 07:12 PM
John Kellerman
ECLIPSE CLOUD DEVTOOLS CONTRIBUTOR AWARD 2023 GOES TO ECLIPSESOURCE AND TYPEFOX
by John Kellerman at January 22, 2024 02:45 PM
Eclipse Cloud DevTools Contributor Award 2023 goes to EclipseSource and TypeFox
The Eclipse Cloud DevTools Contributor Award for the year 2023 is being jointly
awarded to two remarkable companies, EclipseSource and TypeFox, in
acknowledgment of their enormous, continuous, strategic, and sustainable
contributions to the Eclipse Cloud DevTools ecosystem.
Throughout 2023, EclipseSource and TypeFox have demonstrated exceptional
commitment and expertise in various projects within the ecosystem,
including Eclipse Theia, CDT Cloud, Eclipse GLSP, Eclipse Sprotty, EMF Cloud,
and Eclipse Langium. Their leadership role is evident as they provide project
leads and several committers to these open source projects. Their excellence was
already recognized in monthly awards in January, July, October, and December,
showcasing their consistent and impactful contributions.
Their involvement in the Eclipse Cloud DevTools ecosystem is not just technical;
both companies have been pivotal in strategic initiatives, which significantly
supported the growth of the community and nurtured the adoption of its
open-source technologies sustainably. As active participants and leading
architects in the Eclipse Cloud DevTools working group, they have shown
foresight in shaping the future of cloud development tools.
TypeFox and EclipseSource play a unique and vital role in the ecosystem. As
service providers specializing in building tools and IDEs, they provide an
essential resource for companies aiming to develop their own tool offerings.
Their investment in the maintenance and evolution of projects in the ecosystem
is therefore not only a testament to their dedication but also strategically
vital for their operations.
In addition to their extensive contributions, EclipseSource and TypeFox provide
a unique model of sponsored open source development. By contracting a service
provider for sponsored development, adopters can directly engage experts who
contribute to open source projects on their behalf, enabling a highly tailored
and impactful approach to advancing open source initiatives that are of
strategic importance for the adopter. This allows other companies to leverage
the expertise of EclipseSource and TypeFox for specific fixes, feature
developments, and general project maintenance, enabling a broader group of
organizations to contribute to and strengthen the open-source ecosystem. The
approach also allows for resource pooling, where multiple companies can
collectively sponsor a full-time expert committer, thereby enhancing the
efficiency and impact of contributions. The model of sponsored development has
proven to be highly successful in the Eclipse Cloud DevTools Ecosystem, leading
to increased and more sustainable contributions, thereby significantly enriching
the ecosystem.
Project websites contain information about which companies provide support and
sponsored development.
Service providers like EclipseSource and TypeFox are cornerstone elements of a
thriving open-source ecosystem. They offer important support for custom projects
and play a crucial role in fostering sponsored development for open-source
components. We congratulate and thank both EclipseSource and TypeFox for being
the recipients of the Eclipse Cloud DevTools Contributor Award for the year
2023. Your consistent dedication and impactful contributions have significantly
advanced the Eclipse Cloud DevTools landscape, and we are profoundly grateful
for your commitment and excellence.
This Eclipse Cloud DevTools contributor award is sponsored by the Eclipse Cloud
DevTools Working Group. The working group provides a vendor-neutral ecosystem of
open source projects focused on defining, implementing and promoting
best-in-class web and cloud-based development tools. It is hosted at the Eclipse
Foundation, current members of the group
include AMD, Arm, EclipseSource, Ericsson, Obeo, RedHat, Renesas, STMicroelectronics
and TypeFox.
John Kellerman Mon, 2024-01-22 09:45
--------------------------------------------------------------------------------
by John Kellerman at January 22, 2024 02:45 PM
Jonas, Maximilian and Philip
HOSTING IDES AND TOOLS ONLINE - LESSONS LEARNED
by Jonas, Maximilian & Philip at January 22, 2024 12:00 AM
The transition to cloud-based tools and IDEs is reshaping the landscape of
software development. However, the details of hosting tools and IDEs online
present unique challenges. If you’re...
The post Hosting IDEs and tools online - lessons learned appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at January 22, 2024 12:00 AM
JANUARY 18, 2024
Jonas, Maximilian and Philip
CDT CLOUD BLUEPRINT: TRACING WITH TRACECOMPASS CLOUD
by Jonas, Maximilian & Philip at January 18, 2024 12:00 AM
In the world of C/C++ development, especially when doing performance tuning,
tracing plays a pivotal role. CDT Cloud Blueprint, the web-based C/C++
development environment, provides advanced Tracing...
The post CDT Cloud Blueprint: Tracing with TraceCompass Cloud appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at January 18, 2024 12:00 AM
JANUARY 17, 2024
John Kellerman
ECLIPSE CLOUD DEVTOOLS DIGEST - NOVEMBER AND DECEMBER 2023
by John Kellerman at January 17, 2024 07:57 PM
Eclipse Cloud DevTools Digest - November and December 2023
THEIA ANNOUNCES FULL COMPATIBILITY WITH VS CODE EXTENSION API
In his blog, Mike Milinkovich announced a significant achievement in the
development of Theia: to wit, full compatibility with the Visual Studio Code (VS
Code) extension API. This is a major milestone in the evolution of Theia toward
a universally adaptable development environment.
CONTRIBUTOR AWARDS TO TOBIAS ORTMAYR AND DOMINIK BORK
The Cloud Dev Tools Working Group presented Contributor of the Month awards to
Tobias Ortmayr for his continued work improving the performance of Theia and to
Dominik Bork bringing academia, industry and open source closer together.
ON BUILDING CLOUD NATIVE MODELING TOOLS
Jonas, Maximilian & Philip, in this article, wrote about a talk they gave at
EclipseCon 2023 on building cloud native modeling tools using modern web-based
open source technologies like EMF Cloud, Langium and GLSP.
ON BUILDING DIAGRAMS WITH GLSP
In another article, Jonas, Maximilian & Philip also write about another talk
they gave at EclipseCon 2023 about building diagramming tools using GLSP that
are more testable, collaborative, and accessible (through improved keyboard
navigation and metadata annotations).
THEIA RELEASES 1.44 AND 1.45
Theia released 1.44 and 1.45 adding support for a "portable mode" keeping user
data with the Theia application, language icons, improvements for secondary
windows, search history, and saving untitled files.
THEIA COMMUNITY RELEASE 2023-11
Theia also released their Community Release 2023-11 based on Theia 1.43.
Community releases are provided once a quarter with a dedicated release branch
that allows contributors to further harden and even hotfix a community release.
To learn more about the advantages of the Theia community release, visit the
Theia release page.
OTHER RECENT RELEASES
* JKube 1.15.0
* Langium 2.1.3
CLOUD TOOL TIME WEBINARS
We are now scheduling Cloud Tool Time webinars for 2023. Be sure to Sign up now
to get on the calendar and let us help tell your story. You can see past
sessions on our Youtube channel.
ECLIPSE CLOUD DEVTOOLS PROJECTS
Explore the Eclipse Cloud DevTools ecosystem! Check out our projects page to
find out more about open source innovation for cloud IDEs, extension
marketplaces, frameworks and more.
GETTING LISTED ON THE CLOUD DEVTOOLS BLOG
If you are working with, or on, anything in the Cloud DevTools space, learn how
to get your writings posted in our blog section.
John Kellerman Wed, 2024-01-17 14:57
--------------------------------------------------------------------------------
by John Kellerman at January 17, 2024 07:57 PM
Donald Raab
WHAT IF JAVA HAD NO FOR?
by Donald Raab at January 17, 2024 03:10 AM
These loops look like objects to me!
Photo by Etienne Girardet on Unsplash
WHERE FOR ART THOU?
This blog is intended to make you think about and discover alternatives to
modeling for loops in an object-oriented (OO) programming language. It is
convenient to have a versatile and performant eager for statement built in the
Java language. It is also convenient to have lazy versions of numeric range
based for loops in the form of IntStream and LongStream.
In my previous blog, I introduced a new lazy abstraction for an int range based
for loop, without giving much of an explanation. This is the quote in the
previous blog where I introduced the concept.
> In the active Boolean version of the the code, I use an IntInterval from
> Eclipse Collections to represent an OO version of the for loop.
I will explain what an IntInterval from Eclipse Collections is later in
the blog.
The following are the topics I will cover in this blog.
* For Loops in Java
* OO For Loops in Smalltalk
* OO For Loops in Java
* OO For Loops in Eclipse Collections
In this blog, I explain some of the versatility of for statements in Java with
examples. I explain how some of the language (lambdas) and library (Streams)
work including in Java 8 release have improved the level of abstraction of
looping constructs for Java developers. Java does not go as far as Smalltalk
does on the OO abstraction level for looping constructs. I show and explain how
Smalltalk makes some things amazingly simple in its pure object-oriented
approach to looping. Finally, I explain some features that Eclipse Collections
provides that enables additional levels of abstraction for Java developers to
enhance their productivity.
This blog does not include anything about parallelism.
1. FOR LOOPS IN JAVA
THREE PARTS OF THE FOR
Looping is part of control flow in a programming language. For loops are used to
do things until a condition is met, or infinitely if no condition is specified.
There is a for statement in Java that is well structured and extremely useful
for executing a block of code a number of times. The example I used in the
previous blog was to output a String parameter a specified number of times.
public static void main(String[] args)
{
int numberOfTimes = Integer.parseInt(args[0]);
for (int i = 0; i < numberOfTimes; i++)
{
System.out.println(args[1]);
}
}
The code will throw an exception if less than two arguments are passed in. This
code will output the String at args[1] the number of times specifed at args[0].
The String at args[0] is converted to an int and stored in the variable
numberOfTimes.
The structure of a for loop in Java includes three statements inside of
parentheses after the for keyword, each separated by a semi-colon. The
statements are as follows.
* Initialization— executed once to initialize one or more variables
* Continue Condition — a boolean expression that when true will continue to
loop and when false will cause the loop to exit
* Advancement Expression— an expression that may cause a change in the result
of the Continue Condition, like incrementing or decrementing a counter or
calling next on an Iterator.
FOR EXAMPLE — SUMMING NUMBERS 1 TO 10
A very simple example of a for loop in Java is summing the numbers from 1 to 10.
The following test is an example of this.
@Test
public void sumNumbersFromOneToTen()
{
int sum = 0;
for (
int i = 1; // Intialization
i <= 10; // Continue Condition
i++) // Advancement Expression
{
sum += i;
}
Assertions.assertEquals(55, sum);
}
FOR EXAMPLE — SUMMING NUMBERS 10 TO 1
This code could also be written as summing the numbers from 10 to 1. The
following test is an example of this.
@Test
public void sumNumbersFromTenToOne()
{
int sum = 0;
for (
int i = 10; // Intialization
i > 0; // Continue Condition
i--) // Advancement Expression
{
sum += i;
}
Assertions.assertEquals(55, sum);
}
INLINING THE THREE STATEMENTS
I previously broke the three expressions over multiple lines so they are easy to
parse and read. Normally, the expressions will all be on the same line,
as follows:
// For loop from 1 to 10 incrementing by 1
for (int i = 1; i <= 10; i++)
// For loop from 10 to 1 decrementing by 1
for (int i = 10; i > 0; i--)
The for loop in Java is very versatile. Before the Java language had lambdas,
the for loop was the preferred mechanism for iterating over an array or
Collection.
SUM ARRAY OF INTS —INDEXED ACCESS
The following for loop uses indices for summing up elements of an int array.
@Test
public void sumArrayOfIntsUsingIndexedAccess()
{
int sum = 0;
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (
int i = 0; // Intialization
i < array.length; // Continue Condition
i++) // Advancement Expression
{
sum += array[i];
}
Assertions.assertEquals(55, sum);
}
SUM ARRAY OF INTS — JAVA 5 FOR LOOP
The following for loop uses the simplified version of the for loop introduced in
Java 5 for iterating over each element of a an int array.
@Test
public void sumArrayOfIntsUsingForEachLoop()
{
int sum = 0;
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int each : array)
{
sum += each;
}
Assertions.assertEquals(55, sum);
}
The first part of the for loop includes the type and name of a varaible for each
element in the array. In this case, I use int each.The second part, separated by
a :, is the array to loop over.
SUM LIST OF INTEGERS — INDEXED ACCESS
If we have a List of Integer objects, we have a few ways we can write a for loop
to calculate the sum. We can loop using indexed access.
@Test
public void sumListOfIntegersUsingIndexedAccess()
{
int sum = 0;
List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
for (
int i = 0; // Intialization
i < list.size(); // Continue Condition
i++) // Advancement Expression
{
sum += list.get(i).intValue();
}
Assertions.assertEquals(55, sum);
}
SUM LIST OF INTEGERS — ITERATOR
We can loop using an explicit iterator.
@Test
public void sumListOfIntegersUsingIterator()
{
int sum = 0;
List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
for (
Iterator<Integer> it = list.iterator(); // Intialization
it.hasNext(); // Continue Condition
// No Advancement Expression
)
{
sum += it.next().intValue(); // Advancement in statement via next()
}
Assertions.assertEquals(55, sum);
}
SUM LIST OF INTEGERS — JAVA 5 FOR LOOP
We can loop using the enhanced for loop available since Java 5, which is really
a shorthand for using the iterator approach above.
@Test
public void sumListOfIntegersUsingJava5ForLoop()
{
int sum = 0;
List<Integer> list = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
for (Integer each : list)
{
sum += each.intValue();
}
Assertions.assertEquals(55, sum);
}
ALL FOR ONE, AND FOR FOR ALL
The versatile nature of a for loop makes it a tough competitor for looping. Oleg
Pliss commented on my post of this article in LinkedIn:
> A few important features of ‘for’ loops are missing in the article: access to
> the locals outside the loop; ‘continue’ and ‘break’ statements (potentially
> with a label); and ‘return’ (from the method).
This is some of what I was alluding to by the versatility of the for statement,
and Oleg did a masterful job of identifying the functionality I did not cover in
a single sentence. Here are links to further tutorials on for and the branching
statements I didn’t cover here for those interested in learning more.
In the rest of the blog I will demonstrate how for loops are implemented in
Smalltalk, and show how in Java 8 and with Eclipse Collections, Java has
advanced towards a more object-oriented and functional model of for loops. I
have been working on replacing unnecessary for loops in Java applications for
the past 20 years as I explain in the following blog. Usually there is a higher
level algorithm like filter, map, or reduce that is implemented imperatively
with a for loop. It’s more readable if you can hide the implementation details
of a for loop behind a higher level abstraction that explains what you are doing
with an intention revealing name. It’s also potentially better for performance
for different types to optimize for specific iteration patterns, instead of
requiring developers to write different for loops for different types because
one is faster with indexed access vs. being faster with an iterator.
My ten year quest for concise lambda expressions in Java
2. OO FOR LOOPS IN SMALLTALK
The following is a quote from my last blog about Smalltalk and control flow.
> Smalltalk is a programming language that models control flow in its class
> library, instead of the language. There are no if statements, for loops, while
> statements in Smalltalk. There are instead methods on classes that make
> control flow possible. Methods are the abstraction that are used to model all
> control flow, along with code blocks, which are also known as lambdas or
> closures.
An object-oriented version of a for loop will result in looping behavior
distributed across many classes. The behavior of different kinds of for loops
are aligned with the object that makes the most sense to be responsible for that
behavior.
There are both eager and lazy forms of a for loop in an object-oriented model.
The statement version of a for loop in Java is always eager.
SMALLTALK INTERVAL — SUM
I will start by showing how to sum the numbers from 1 to 10 using Smalltalk’s
Interval type. Interval is a lazy for loop. Interval is also a lazy
SequqencedCollection.
testSumNumbersFromOneToTen
|sum|
sum := (1 to: 10) sum.
self assert: sum equals: 55.
In my two previous “What if…” blogs, I explained that “everything is an object”
in Smalltalk. I will explain one step at a time what all the objects are in the
code above, and which are receiving the messages that are accomplishing the task
at hand.
The first object instance encountered in the code is the literal 1. The object
instance represented by the literal 1 is of type SmallInteger. The message to:
is sent to the object 1 with the parameter 10, which is also an instance of
SmallInteger. If I inspect the result of the code (1 to: 10) in Pharo Smalltalk,
the result is an instance of an Interval. The following is a screen capture of
the result.
The Code (1 to: 10) returns an Interval in Smalltalk
Interval is lazy because it knows about the range of data (1 to 10 by 1) but has
yet to do anything with that data. The Interval class in Smalltalk is designed
as follows.
Interval in the Smalltalk Class Hierarchy
The decision to make Interval a SequencedCollection brings a lot of convenience.
The internal iterator support for Interval is extensive. There are class methods
on Interval which allow for construction. The convenient shorthand I used about
calling to: on SmallInteger can be searched in the Smalltalk class library
quickly to show how the Interval is constructed.
The to: method defined on the Number class which is a parent class for
SmallInteger
The ^ means return in Smalltalk, so the code 1 to: 10 is going to result in
Interval from: 1 to: 10 by: 1. An Interval in Smalltalk is inclusive for both
the start and stop.
The final step to understanding how the loop itself is implemented in the sum of
the integers from 1 to 10 example is to look at the sum method.
The implementation of sum on Interval
What we discover here is that sum is optimized for Interval. It uses a formula
instead of iteration with a loop. This is one of the benefits of having loops
represented by objects. They can provide encapsulate and optimized behaviors.
SMALLTALK INTERVAL — DO:
In the interest of demonstrating the actual loop, I will implement an iterative
sum by hand in a test.
testSumNumbersFromOneToTenWithDo
|sum|
sum := 0.
(1 to: 10) do: [ :each | sum := sum + each ].
self assert: sum equals: 55.
I use the do: method here with a Block (lambda) which updates the sum variable
with the value of sum plus the value of each SmallInteger. The implementation of
do: on Interval looks as follows.
The implementation of do: on Interval class in Pharo Smalltalk
The implementation of do: uses a Block (Condition Continue Block) with
whileTrue: followed by Block (Execution Block) to perform the looping. The
Condition Continue Block and Execution Block both require access to the index
variable which is scoped outside of the blocks, and the Execution Block actually
increments the index variable. I will not be implementing whileTrue: for
educational purposes in Java as it would require using a final int array or
AtomicInteger, LongAdder or equivalent for index to be able to be incremented.
There is a tweet reply from Vladimir Zakharov that shows how whileTrue could be
implemented on a Functional Interface if someone wanted.
SMALLTALK INTERVAL — INJECT:INTO:
There is another internal iterator that I can use in Smalltalk that will not
require updating a local variable for each element in the Interval. That method
is named inject:into:, or as I like to call it, the Continuum Transfunctioner.
Here is a sum implemented using inject:into:.
testSumNumbersFromOneToTenWithInjectInto
|sum|
sum := (1 to: 10) inject: 0 into: [ :result :each | result + each ].
self assert: sum equals: 55.
The way the above inject:into: code works can be explained as follows as each
element is visited in the Interval.
result := 0
result + each = ?
=================
0 + 1 = 1
1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15
15 + 6 = 21
21 + 7 = 28
28 + 8 = 36
36 + 9 = 45
45 + 10 = 55
The result of each iteration is “injected” into the block for the next iteration
as the first parameter. The implementation of inject:into: for the Interval
class in Pharo Smalltalk is as follows.
The implementation of inject:into: on the Collection class in Pharo Smalltalk
SMALLTALK INTERVAL —IN REVERSE ORDER
In order to reverse an Interval, I will need to add a negative step value using
the to:by: method on SmallInteger as follows.
testSumNumbersFromTenToOne
|sum|
sum := (10 to: 1 by: -1) sum.
self assert: sum equals: 55.
There are also methods named reverseDo: and reversed on Interval which can take
forward Interval and walk through it in reverse. The reversed method will wind
up creating an array in reverse, which is why I didn’t demonstrate it here.
SMALLTALK INTERVAL — ANY NUMBER
The abstraction of Interval and the benefits of dynamic typing really become
evident when you learn about the existence of Fraction in Smalltalk. Take the
code 1/3 in Smalltalk. If you execute this code in Java for an int, you will
expect a result of 0. The following is the result in Pharo Smalltalk.
Dividing Small integer 1 by 3 results in a Fraction of 1/3 in Smalltalk
If we want to represent a range from 1 to 10 by 1/4, we can achieve this simply
by writing the following code.
Interval will support any number, so understanding the types of Number that are
provided in Smalltalk is helpful. The following class diagram shows the
hierarchy for Number in Pharo Smalltalk.
The class hierarchy for Number in Pharo Smalltalk
SMALLTALK INTERVAL — MORE THAN JUST A LOOP
The Interval abstraction provides more than just a lazy for loop. Interval is a
lazy Collection. All of the algorithms available to SequencedCollection are also
available to Interval. For example, it’s possible to collect all of the numbers
in an Interval as a collection of String.
testPrintString
|strings expected|
strings := (1 to: 5) collect: #printString.
expected := Array with: '1' with: '2' with: '3' with: '4' with: '5'.
self assert: strings equals: expected.
The method named collect: is defined on Collection, and can be used to transform
from one type to another. Here I am converting SmallInteger to String by
applying the method printString to each element of the Interval.
The following code filters the even values of an Interval using the select:
method, and then converts the SmallInteger values to their square values and
converts them to an array of String.
testEvensPrintString
|strings expected|
strings := ((1 to: 10) select: #even) squared collect: #printString.
expected := Array with: '4' with: '16' with: '36' with: '64' with: '100'.
self assert: strings equals: expected.
SMALLTALK — NUMBER MEETS COLLECTION
Looping with a range of values in Interval is useful but somewhat limited.
Looping over a collection of arbitrary values is more useful. There are many
methods available on the Collection class that provide internal iterators. I am
going to show what some of these methods do, and then explain how they do them.
The how is where an eager loop provided by the Number class in a method named
to:do: arrives.
The following is the method for do: in OrderedCollection, which is one of the
most commonly uses collection types in Smalltalk. OrderedCollection in Smalltalk
is the equivalent of ArrayList in Java.
The method do: on OrderedCollections calls to:do: on Number
The method do: is the equivalent of forEach defined on Iterable in Java. In this
code, the first part, firstIndex to: lastIndex do: calls the to:do: method on
Number. The code for to:do: looks as follows.
The method to:do: on the Number class
This code uses a Block whileTrue: method to execute another Block the number of
times covered by the range from self to stop. If we go back to look at the do:
method in Interval, it looks somewhat similar, but requires a bit more math due
to Interval having a start, stop and step value.
Again, the method do: on the Interval class
The following code looks very similar, but winds up taking two different paths.
One goes through Number to:do:, and the other goes through Interval do:. See if
you can figure out which is which.
1 to: 10 do: [:each | Transcript show: each].
(1 to: 10) do: [:each | Transcript show: each].
The code Transcript show: is the equivalent of System.out.print() in Java. If
you guessed the first line uses Number to:do: and the second uses Interval do:,
then you are correct, and I am finished with the Smalltalk part of the Interval,
Number, and Collection looping.
3. OO FOR LOOPS IN JAVA
Since Java 8, we have IntStream and LongStream, both which can represent lazy
for loops over a range of int or long values.
JAVA INTSTREAM — RANGE SUM
The method range on IntStream is inclusive on the from and exclusive on the to.
@Test
public void sumIntStreamRangeOneToElevenExclusive()
{
int sum = IntStream.range(1, 11).sum();
Assertions.assertEquals(55, sum);
}
JAVA INTSTREAM — RANGECLOSED SUM
The method rangeClosed on IntStream is inclusive on both the from and the to.
@Test
public void sumIntStreamRangeClosedOneToTenInclusive()
{
int sum = IntStream.rangeClosed(1, 10).sum();
Assertions.assertEquals(55, sum);
}
Both calls to sum on IntStream have a potential silent overflow issue to be
aware of. It would have been better if IntStream sum returned a long value. So
long as your sum result is less than Integer.MAX_VALUE you will be ok. If it is
greater than Integer.MAX_VALUE, the int value sum could wind up negative or some
other unexpected positive value.
JAVA INTSTREAM — FOREACH SUM
IntStream is lazy, so you have to call a terminal method like sum or forEach to
force iteration to happen. If we want to calculate a sum by hand, we can use the
forEach method. With this version of sum, we can widen the result ourselves to
long by using LongAdder.
@Test
public void sumIntStreamRangeClosedForEach()
{
LongAdder sum = new LongAdder();
IntStream.rangeClosed(1, 10).forEach(sum::add);
Assertions.assertEquals(55, sum.intValue());
}
I use the LongAdder class to create an instance of an object that will be
effectively final and can be used as a method reference in the forEach.
LongAdder internally keeps a long value. To illustrate how LongAdder handles
larger numbers and avoids int overflow, where sum does not, I will create a
small range in the billions.
@Test
public void sumIntStreamRangeClosedInBillions()
{
LongAdder sum = new LongAdder();
IntStream.rangeClosed(2_000_000_000, 2_000_000_001).forEach(sum::add);
Assertions.assertEquals(4_000_000_001L, sum.longValue());
// Overflow happened silently here with IntStream.sum
int intSum = IntStream.rangeClosed(2_000_000_000, 2_000_000_001).sum();
Assertions.assertEquals(-294_967_295, intSum);
}
JAVA LONGSTREAM — SUM
Another alternative to IntStream.sum that is almost always safe from overflow is
LongStream.sum. The following is an example of sum on LongStream.
@Test
public void sumLongStreamRangeClosedOneToTenInclusive()
{
long sum = LongStream.rangeClosed(1L, 10L).sum();
Assertions.assertEquals(55L, sum);
long bigSum = LongStream.rangeClosed(2_000_000_001L, 2_000_000_010L).sum();
Assertions.assertEquals(20_000_000_055L, bigSum);
}
JAVA INTSTREAM — TOLIST
If we want the elements of an IntStream to be represented in a List, we have to
use the IntStream API to box the stream and convert it to a List<Integer>.
@Test
public void filterIntStreamRangeClosedEvensToList()
{
List<Integer> list = IntStream.rangeClosed(1, 10)
.filter(i -> i % 2 == 0)
.boxed()
.toList();
List<Integer> expected = List.of(2, 4, 6, 8, 10);
Assertions.assertEquals(expected, list);
}
JAVA ITERABLE — FOREACH
In Java 8, we got support for concise lambda expressions and the Java Stream
API. We also got a forEach method on the Iterable interface, which allows all
Collection types in Java to provide internal iterators that are optimized for
each type.
The following code can be used to sum the List<Integer> of even numbers from 1
to 10 that I created above.
@Test
public void sumListOfEvensUsingForEach()
{
List<Integer> list = List.of(2, 4, 6, 8, 10);
LongAdder sum = new LongAdder();
list.forEach(sum::add);
Assertions.assertEquals(30L, sum.longValue());
}
4. OO FOR LOOPS IN ECLIPSE COLLECTIONS
One of the first custom Collection types I created in Eclipse Collections was
the Interval class. I though it would be very useful to have a List<Integer>
that you could create simply by specifying a range. I also thought it would be
useful to have a full complement of rich internal iterators on Interval, so I
had it also implement LazyIterable<Integer>. We have used Interval extensively
in unit tests in Eclipse Collections. It is often the fastest way to create a
List, Set, Bag, Stack or any other type where having some Collection of Integer
is all we need. The following image shows the number of usages on Interval in
the Eclipse Collections project.
Interval usages in Eclipse Collections Project
There are ~1,900 usages in the tests module alone. The Interval class has proven
itself very useful in Eclipse Collections unit tests.
ECLIPSE COLLECTIONS INTERVAL — SUM
The following code will create an Interval from 1 to 10 and return a sum using
sumOfInt. The method sumOfInt knows to widen the sum to a long.
@Test
public void sumIntervalOneToTen()
{
long sum = Interval.oneTo(10).sumOfInt(Integer::intValue);
Assertions.assertEquals(55L, sum);
}
ECLIPSE COLLECTIONS INTERVAL — SUM EVENS
The following code will include only the even numbers from 1 to 10 and sum them.
@Test
public void sumIntervalEvensOneToTen()
{
long sum = Interval.evensFromTo(1, 10).sumOfInt(Integer::intValue);
Assertions.assertEquals(30L, sum);
}
ECLIPSE COLLECTIONS INTERVAL — AS A LIST AND AS A LAZYITERABLE
There are three possible types that Interval can be used as — Interval, List,
LazyIterable.
@Test
public void intervalIsListAndLazyIterable()
{
Interval interval = Interval.oneTo(5);
List<Integer> list = interval;
LazyIterable<Integer> lazyIterable = interval;
Assertions.assertEquals(List.of(1, 2, 3, 4, 5), list);
Assertions.assertEquals(Set.of(1, 2, 3, 4, 5), interval.toSet());
Assertions.assertEquals(
Interval.oneTo(10),
lazyIterable.concatenate(Interval.fromTo(6, 10)).toList());
}
The following diagram shows the design of the Interval class in Eclipse
Collections.
Class diagram for Interval class in Eclipse Collections
ECLIPSE COLLECTIONS INTINTERVAL — SUM
Interval has proved itself extremely useful for quickly creating List<Integer>
instances, especially in test code. For production use cases, where memory and
performance matter, IntInterval may be a better alternative. IntInterval is an
ImmutableIntList. The internal iterators on IntInterval are not lazy by default
like Interval, but IntInterval does support lazy iteration via an explicit call
to asLazy.
The following code shows how to calculate a sum using IntInterval using both
eager and lazy approaches.
@Test
public void sumIntIntervalOneToTen()
{
IntInterval intInterval = IntInterval.oneTo(10);
long eagerSum = intInterval.sum();
LazyIntIterable lazy = intInterval.asLazy();
long lazySum = lazy.sum();
Assertions.assertEquals(55L, eagerSum);
Assertions.assertEquals(55L, lazySum);
}
I reuse the instance of IntInterval to create the LazyIntIterable, after already
calculating the eager sum. I did this to illustrate that an IntInterval can be
reused, unlike an IntStream from Java, which may only be used once.
ECLIPSE COLLECTIONS INTINTERVAL — USAGE
The usage of IntInterval in Eclipse Collections is more modest than Interval,
but still quite good.
Usages of IntInterval in Eclipse Collections
ECLIPSE COLLECTIONS LONGINTERVAL — SUM
Eclipse Collections provides primitive Interval support for both int and long.
The long support is provided by LongInterval.
The following code shows how to calculate a sum using LongInterval using both
eager and lazy approaches.
@Test
public void sumLongIntervalBillionOneToBillionTen()
{
LongInterval longInterval =
LongInterval.fromTo(1_000_000_001L, 1_000_000_010L);
long eagerSum = longInterval.sum();
LazyLongIterable lazy = longInterval.asLazy();
long lazySum = lazy.sum();
Assertions.assertEquals(10_000_000_055L, eagerSum);
Assertions.assertEquals(10_000_000_055L, lazySum);
}
I reuse the instance of LongInterval to create the LazyLongIterable, after
already calculating the eager sum. I did this to illustrate that a LongInterval
can be reused, unlike a LongStream from Java, which may only be used once.
ECLIPSE COLLECTIONS LONGINTERVAL — USAGE
The usage of LongInterval in Eclipse Collections is more modest than both
Interval and IntInterval.
Usages of LongInterval in Eclipse Collections
ECLIPSE COLLECTIONS INTINTERVAL AND LONGINTERVAL CLASS HIERARCHY
I have included both hierarchies for IntInterval and LongInterval in this
diagram to show that they do ultimately share a root parent interface named
PrimitiveIterable. The following is the UML class hierarchy for both IntInterval
and LongInterval.
Class hierarchies for IntInterval and LongInterval in Eclipse Collections
There was an evolution in design approach from Interval to IntInterval and
LongInterval. Interval was one of the earliest containers in Eclipse
Collections, and was created before immutable and primitive types were added to
the framework. Interval is heavily used already so it is too late to revisit its
design as it would cause too much pain to convert it to an
ImmutableList<Integer> just for consistency sake. This ship has sailed, and this
is now just a historical implementation decision. There are things I continue to
like about both design approaches.
FINAL THOUGHTS
I hope this blog helped you learn about different approaches and levels of
abstraction for looping in an object-oriented language. I believe it is useful
to have both language and library constructs available in Java to enhance the
productivity of developers when it comes to looping.
Smalltalk takes a novel approach to implementing control flow that I found
extremely insightful when I first learned about it in 1994. I hope the Smalltalk
examples and explanations helped you learn something insightful about this
venerable programming language. I believe there is still so much we can learn
from the past in programming languages, and only by learning this storied past
can we hope to create a better future for programmers.
I intentionally did not explain either eager parallel or lazy parallel looping
in this blog. This can be a natural progression once you have understood how
eager serial and lazy serial looping works using lambdas. The inclusion of
lambdas in Java 8 has opened up many new possibilities for productivity
enhancements for Java developers. I expect that we will continue to see
improvements in the language and libraries of Java further leveraging this
critical feature.
Thank you for reading!
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at January 17, 2024 03:10 AM
JANUARY 15, 2024
Jonas, Maximilian and Philip
THE CHOICE OF AN IDE AND TOOL PLATFORM: ECLIPSE THEIA VS. CODE OSS
by Jonas, Maximilian & Philip at January 15, 2024 12:00 AM
Building custom tools and IDEs are strategic and long term investments. Choosing
the right platform for building custom tools and IDEs is a critical decision for
stakeholders. To aid in this crucial...
The post The Choice of an IDE and Tool Platform: Eclipse Theia vs. Code OSS
appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at January 15, 2024 12:00 AM
Wayne Beaton
COLLABORATIVE SPECIFICATION DEVELOPMENT
January 15, 2024 12:00 AM
Originally posted in the the February 2019 Eclipse Foundation Newsletter. The
Eclipse Foundation Specification Process (EFSP), which extends the Eclipse
Foundation Development Process (EDP), defines a blueprint for collaborating on
specification development in open source. Committers are the ones who tend to
develop most of the content. Committers have the ability to push their own
contributions into their project’s source code repositories and decide whether
or not to accept contributions from others.
--------------------------------------------------------------------------------
January 15, 2024 12:00 AM
JANUARY 08, 2024
Donald Raab
WHAT IF JAVA HAD NO IF?
by Donald Raab at January 08, 2024 02:34 AM
What would you do?
Photo by Jon Tyson on Unsplash
WHERE ART THOU CONTROL FLOW?
Programming in Java would be pretty hard in Java if we didn’t have if
statements, for loops, while statements. These are convenient language artifacts
that help us determine if, how, and when the code in our programs execute. This
is the essence of control flow in a program. All programming languages have
mechanisms that enable control flow to occur. Most programming languages provide
control flow mechanisms in the language itself, via built-in statements.
The following code shows some basic control flow statements in Java.
public static void main(String[] args)
{
if (args.length > 1)
{
int i = Integer.parseInt(args[1]);
for (int j = 0; j < i; j++)
{
System.out.println(args[0]);
}
}
else if (args.length > 0)
{
System.out.println(args[0]);
}
else
{
System.out.println("Hello World!");
}
}
This code checks the args String array length to see if zero, one, or two
arguments are supplied to the program. If zero arguments are passed, the program
outputs “Hello World!”. If one argument is passed, the program outputs the
argument which is arg[0]. If two arguments are passed, the program outputs the
first argument (arg[0]) the number of times specified in the second argument
(arg[1]). There is no safety check in this code to make sure the second
parameter is actually a number.
> What would you do if you didn’t have an if statement in Java?
MODELING CONTROL FLOW WITH OBJECTS AND METHODS
Smalltalk is a programming language that models control flow in its class
library, instead of the language. There are no if statements, for loops, while
statements in Smalltalk. There are instead methods on classes that make control
flow possible. Methods are the abstraction that are used to model all control
flow, along with code blocks, which are also known as lambdas or closures. When
I was first learning Smalltalk, I had to learn where these control flow methods
were and how to use them with lambdas. I believe this enabled me to become
familiar with lambdas very quickly, as I had to use them everywhere I needed
control structures in my Smalltalk programs.
The place I first learned to look for control structures in Smalltalk was the
class hierarchy for Boolean. The following is a UML class diagram showing how
the Boolean type is modeled in Smalltalk.
The class hierarchy for Boolean in Smalltalk and literal instances of true
and false
The Boolean class in Smalltalk defines methods and:, or:, ifTrue:, ifFalse:,
ifTrue:ifFalse:, and ifFalse:ifTrue. Each of these methods take one or two Block
parameters. A Block in Smalltalk is a type that can be represented with a
literal lambda syntax. The basic syntax for a Block is square brackets with a
pipe that separates parameters on the left, with expression on the right. If
there are zero parameters in the Block, there will be no pipe. The following are
examples of literal blocks, also known as lambdas or closures.
* [] — An empty Block which returns nil when evaluated.
* [true] — Zero argument Block which returns true when evaluated
* [:a | a] — One argument Block which returns a when evaluated
* [:a :b | a + b] — Two argument Block which returns a + b
* [:a :b :c | a + b + c] — Three argument Block which returns a + b + c when
evaluated.
EVALUATING CONDITIONALS IN SMALLTALK
Without an if statement in Smalltalk, you learn to use the instances (true and
false) of the two subclasses of Boolean (True and False) with lambdas (via
Block) to perform conditional logic.
The following tests in Smalltalk show how conditional logic can be accomplished
using the methods on the True and False classes that I documented in the
diagram above.
Here is a test demonstrating various results for True.
testTrue
self assert: (true and: [ true ]).
self assert: (true or: [ true ]).
self deny: (true and: [ false ]).
self assert: (true or: [ false ]).
self assert: (true ifTrue: [ true ]).
self assert: (true ifTrue: [ true ] ifFalse: [ false ]).
self deny: (true ifFalse: [ true ] ifTrue: [ false ]).
self assert: (6 > 5 ifTrue: [ true ]).
self assert: (4 > 5 ifTrue: [ true ]) equals: nil.
Here is a test demonstrating various results for False.
testFalse
self deny: (false and: [ true ]).
self assert: (false or: [ true ]).
self deny: (false and: [ false ]).
self deny: (false or: [ false ]).
self assert: (false ifFalse: [ true ]).
self assert: (false ifTrue: [ false ] ifFalse: [ true ]).
self deny: (false ifFalse: [ false ] ifTrue: [ true ]).
self assert: (6 > 5 ifFalse: [ true ]) equals: nil.
self assert: (4 > 5 ifFalse: [ true ]).
PASSIVE VS. ACTIVE BOOLEAN CLASS
Java has both a primitive and Object form of boolean. The primitive version is
named boolean. The object version is named Boolean. The Boolean class acts as a
wrapper for the primitive boolean type in Java so that the primitive values can
be used in generic collections like List, Set, and Map. The Boolean class only
defines six instance methods as of Java 21. The methods are toString, hashCode,
equals, compareTo, describeConstable, and booleanValue. This class contains no
active methods that do anything. Most of the methods return a different type
representation of the booleanValue contained in the wrapper. The current Boolean
class in Java is what I would refer to as a passive class. It is merely an
object data holder for primitive boolean.
It is possible to make Boolean an active class in Java. As an experiment I
defined a new Boolean sealed interface and defined True and False
implementations.
public sealed interface Boolean permits Boolean.True, Boolean.False
{
Boolean TRUE = new True();
Boolean FALSE = new False();
static Boolean valueOf(boolean value)
{
return value ? TRUE : FALSE;
}
default Boolean and(Supplier<Boolean> block)
{
return null;
}
default Boolean or(Supplier<Boolean> block)
{
return null;
}
default <R> R ifTrue(Supplier<R> trueBlock)
{
return null;
}
default <R> R ifFalse(Supplier<R> falseBlock)
{
return null;
}
default <R> R ifTrueIfFalse(
Supplier<R> trueBlock,
Supplier<R> falseBlock)
{
return null;
}
default <R> R ifFalseIfTrue(
Supplier<R> falseBlock,
Supplier<R> trueBlock)
{
return null;
}
final class True implements Boolean {}
final class False implements Boolean {}
}
I had to provide a static method to convert a primitive boolean to the Boolean
interface for this to work. I will leave it to your imagination how I overrode
the default implementations of the parent Boolean interface in the True and
False classes.
When I had completed the implementation, I rewrote the Control Flow Java example
in the first section of this blog using the new Boolean interface. This is what
the code looks like with Supplier and Boolean instances in variables to
provide clarity.
public static void main(final String[] args)
{
Supplier<Object> moreThanOneSupplier = () ->
{
IntInterval.oneTo(Integer.parseInt(args[1]))
.forEach(j -> System.out.println(args[0]));
return null;
};
Supplier<Object> moreThanZeroSupplier = () ->
{
System.out.println(args[0]);
return null;
};
Supplier<Object> noArgumentSupplier = () ->
{
System.out.println("Hello World!");
return null;
};
Boolean argsGreaterThanOne = Boolean.valueOf(args.length > 1);
Boolean argsGreaterThanZero = Boolean.valueOf(args.length > 0);
argsGreaterThanOne.ifTrueIfFalse(
moreThanOneSupplier,
() -> argsGreaterThanZero.ifTrueIfFalse(
moreThanZeroSupplier,
noArgumentSupplier));
}
In the active Boolean version of the the code, I use an IntInterval from Eclipse
Collections to represent an OO version of the for loop. The active Boolean
version of the code is composable and easier to move logic around with
everything clearly compartmentalized. If I inline the Supplier instances, the
code looks as follows.
public static void main(final String[] args)
{
Boolean argsGreaterThanOne = Boolean.valueOf(args.length > 1);
Boolean argsGreaterThanZero = Boolean.valueOf(args.length > 0);
argsGreaterThanOne.ifTrueIfFalse(
() ->
{
IntInterval.oneTo(Integer.parseInt(args[1]))
.forEach(j -> System.out.println(args[0]));
return null;
},
() -> argsGreaterThanZero.ifTrueIfFalse(
() ->
{
System.out.println(args[0]);
return null;
},
() ->
{
System.out.println("Hello World!");
return null;
}));
}
For less scrolling and easier comparison, this was the original Java code from
above with if statements and the for loop.
public static void main(String[] args)
{
if (args.length > 1)
{
int i = Integer.parseInt(args[1]);
for (int j = 0; j < i; j++)
{
System.out.println(args[0]);
}
}
else if (args.length > 0)
{
System.out.println(args[0]);
}
else
{
System.out.println("Hello World!");
}
}
The code in the primitive boolean example with if statements is less verbose,
but would require more copying and pasting to move logic around.
The verbosity using the active Boolean interface is caused partially because I
chose to use Supplier, which more closely models how Smalltalk uses its Block
with Boolean. Smalltalk Boolean methods with Block allow for Boolean expressions
to be formed as results from methods. If I don’t care about returning a value
from a Boolean expression, I could model the methods using Runnable.
The following code shows how code would look if I used Runnable instead.
public static void main(final String[] args)
{
Boolean argsGreaterThanOne = Boolean.valueOf(args.length > 1);
Boolean argsGreaterThanZero = Boolean.valueOf(args.length > 0);
argsGreaterThanOne.ifTrueIfFalse(
() -> IntInterval.oneTo(Integer.parseInt(args[1]))
.forEach(j -> System.out.println(args[0])),
() -> argsGreaterThanZero.ifTrueIfFalse(
() -> System.out.println(args[0]),
() -> System.out.println("Hello World!")));
}
The curly braces all disappear because each branch of the if statement can be
covered by a single line of code. Lambdas in Java allow me to remove the curly
braces for single line lambda expressions. This removes a bunch of unnecessary
lines of code, at the cost of some potential readability due to text compression
and loss of natural whitespace.
If I extract the Runnable instances into their own variables, the code will look
as follows.
public static void main(final String[] args)
{
Boolean argsGreaterThanOne = Boolean.valueOf(args.length > 1);
Boolean argsGreaterThanZero = Boolean.valueOf(args.length > 0);
Runnable moreThanOneRunnable = () ->
IntInterval.oneTo(Integer.parseInt(args[1]))
.forEach(j -> System.out.println(args[0]));
Runnable moreThanZeroRunnable = () -> System.out.println(args[0]);
Runnable noArgumentRunnable = () -> System.out.println("Hello World!");
argsGreaterThanOne.ifTrueIfFalse(
moreThanOneRunnable,
() -> argsGreaterThanZero.ifTrueIfFalse(
moreThanZeroRunnable,
noArgumentRunnable));
}
FINAL THOUGHTS
This blog was intended to explain in simple terms the differences between true
and false in Java, and true and false in Smalltalk. Java uses statements
provided by the language for user management of program control flow. Smalltalk
uses Objects, Methods and Lambdas to accomplish the same. Both approaches have
pros and cons. Composability and verbosity are sometimes at odds with each
other. If we extract methods in the branches of logic, we can achieve better
composability and less verbosity with both approaches.
The active Boolean approach I demonstrated and described here could be added to
the Boolean class in Java to make it an active Boolean object. This would enable
the Boolean class to manage control flow through methods. The benefit of this
approach would be to enable more complex if expressions which may be hard to
emulate and make readable with the current Java mechanism of ternary
expressions.
Update: One downside that makes the active Boolean object approach impractical
in Java is if you need access to any local variables outside of the lambdas used
in the conditionals. This would require messy tricks using final arrays to
potentially allow for updates to local variables outside of the lambda scopes.
The if statement approach has access to any variables defined outside of its
conditional scopes. Another downside is that Java lambdas do not have support
for non-local returns, which would limit returning out of the method from the
conditionals. Thanks to Oleg Pliss for pointing out these important difference
between Java Lambdas and Smalltalk blocks on LinkedIn.
Learning multiple languages that use different strategies to address the same
problems is useful. Learning a whole new language takes time. My hope is that
this bitesize comparison of basic control flow in Java and Smalltalk is useful
for you to be able to understand the pros and cons different approaches.
Thanks for reading!
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at January 08, 2024 02:34 AM
Jonas, Maximilian and Philip
THE ECLIPSE THEIA PROJECT UPDATE 2023
by Jonas, Maximilian & Philip at January 08, 2024 12:00 AM
2023 has been an extraordinary year for the Eclipse Theia project, marked by
significant community advancements and key feature enhancements such as the
improved startup performance, the introduction...
The post The Eclipse Theia Project Update 2023 appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at January 08, 2024 12:00 AM
JANUARY 05, 2024
Donald Raab
WHAT IF NULL WAS AN OBJECT IN JAVA?
by Donald Raab at January 05, 2024 06:54 PM
Brace yourself and get ready to try the red pill.
Photo by Brett Jordan on Unsplash
OBJECT-ORIENTED PURITY
Smalltalk is often referred to as a pure object-oriented programming language.
Smalltalk was created by Alan Kay, who was also the person who coined the term
“object-oriented." Part of the pure object-oriented nature of Smalltalk is that
“everything is an object” in Smalltalk. Because everything is an object, you
accomplish programming tasks by sending messages to objects.
Java is also object-oriented, but is not a pure object-oriented programming
language. Java has things in it that are not objects (e.g. primitives), that
require special mechanisms for handling them. Java also has a special case for
handling null.
In this blog, I will demonstrate and explain how Java and Smalltalk deal with
absent values, referred to as null in Java, and nil in Smalltalk. This blog will
not provide a full explanation of Java or Smalltalk syntax. There are resources
available on the internet for both if you want to learn more. The blog will only
cover what is necessary to explain the code examples I share. I will do my best
to explain the examples in detail so that syntax is not a barrier to
understanding. This blog is intended to make you ponder larger possibilities,
not struggle with minutiae of language syntax.
In the sections that follow, I will compare solutions to the same simple
problems using both Java and Smalltalk. I will be using Java 21 with IntelliJ
IDEA CE 2023.3.2 for the Java code examples. I will be using Pharo Smalltalk
11.0 for the Smalltalk code examples.
NULL VS. NIL
THE LITERAL NULL IN JAVA
In Java, there is a literal named null. You can assign null to any variable that
has an Object type, but the reference the variable points to is not an instance
of an Object. I like to think of null as an instance of the Spoon in the movie,
“The Matrix”. There is no Spoon.
The following test code illustrates some of the properties of null in Java.
@Test
public void nullIsNotAnObject()
{
// Assert things about null
Assertions.assertFalse(null instanceof Object);
final Set<?> set = null;
Assertions.assertFalse(set instanceof Set);
// Assert things about exceptions thrown when calling methods on null
Assertions.assertThrows(
NullPointerException.class,
() -> set.getClass());
Assertions.assertThrows(
NullPointerException.class,
() -> set.toString());
// Assert things about a non-null variable named set2
final Set<?> set2 = new HashSet<>(Set.of(1, 2, 3));
set2.add(null);
Assertions.assertNotNull(set2);
Assertions.assertNotNull(set2.getClass());
Assertions.assertTrue(set2 instanceof Set);
// Filter all of the non-null values from set2 in the Set named set3
// Uses a static method refererence from the Objects class
final Set<?> set3 = set2.stream()
.filter(Objects::nonNull)
.collect(Collectors.toUnmodifiableSet());
Assertions.assertEquals(Set.of(1, 2, 3), set3);
}
In this test, I assert that null is not an instance of Object. I initialize a
final variable of type Set<?> named set to null, and further assert that set ,
which is null, is not an instance of Set. I assert that when I call getClass()
or toString() on set, which is still null, a NullPointerException is thrown.
This happens because null is not an Object. Note, I made the first declaration
of the set variable final here, in order to reference the variable set in the
two lambdas in the first section where I assert that NullPointerException is
thrown. I could have left it as “effectively final” by not trying to reset the
value, but thought I would just go with having it be explicitly final.
In the second section, I create a mutable Set and store it in a variable named
set2. I add null to the set. Set.of() will not accept null values, so I had to
convert the immutable Set to a HashSet, which does accept null values. I add
null manually to set2. I assert that set2 is not null, that its class is not
null, and that set2 is in fact an instance of a Set as the compiler says it is.
Finally, I filter the instances contained in set2 into a new set3 as long as
they respond true to the method reference Objects::nonNull, which references a
static method on Objects that returns a Predicate that checks that object !=
null. Once again, since null is not an object, you cannot call any methods on it
that could be used to construct a valid method reference as a Predicate.
This is the null in Java that we are all used to. It is not an Object. We’ve all
learned to deal with null when coding in Java. Former Smalltalkers will know
there is a different way.
THE LITERAL NIL IN SMALLTALK
In Smalltalk, there is a singleton object instance named nil. The literal nil,
is an instance of the class UndefinedObject. UndefinedObject is a subclass of
Object. The Object class is a subclass of… nil. This circular definition has
melted many programmers brains, including mine. Somehow, this all just works. It
is one of the magical aspects of Smalltalk. There’s a turtle at the top, sitting
on top of another turtle, and it’s just turtles all the way down.
The following test code passes using Pharo Smalltalk 11.0.
testNilIsAnObject
|set setNoNils|
# Assert things about nil
self assert: nil isNil.
self assert: 'nil' equals: nil printString.
# Assert things about the set variable which is nil
set := nil.
self assert: set isNil.
self assert: set equals: nil.
self assert: set class equals: UndefinedObject.
self assert: (set ifNil: [ true ]).
self assert: set isEmptyOrNil.
# Assert things about the set variable which is not nil
set := Set with: 1 with: 2 with: 3 with: nil.
self deny: set isNil.
self assert: set isNotNil.
self deny: set equals: nil.
self deny: set isEmptyOrNil.
self assert: set class equals: Set.
# Select all the non-nil values into a new Set name setNoNils
setNoNils := set select: #isNotNil.
self assert: (Set with: 1 with: 2 with: 3) equals: setNoNils.
Above is what a method definition looks like in Smalltalk. I wrote a unit test
method named testNilIsAnObject. I define two temporary variables named set and
setNoNils by declaring them between the two vertical pipes after the method name
like this |set setNoNils|. In the first section of code I assert a few things
about nil, in order to demonstrate it is in fact an instance of an Object. The
literal self is the equivalent of this in Java, and refers to the instance of
the class that testNilIsAnObject is defined on, which has methods it inherits
named assert:, deny:, and assert:equals:. I assert that nil can respond to
messages like any other object in Smalltalk. I assert that nil responds true to
isNil. I also assert that calling printString on nil results in the String ‘nil’
being returned.
The := operator is used for variable assignment in Smalltalk. I assign the
instance referenced by the literal nil to the variable named set. I assert that
set responds true when sent the message isNil. I assert that the object
reference contained in the set variable is an instance of UndefinedObject. I
assert that calling the ifNil: message on set returns true. The code [ true ] is
a zero argument block or lambda. In Java, the equivalent would be the a lambda
typed as a Supplier. Finally, I assert that set responds to true when sent the
message isEmptyOrNil.
In the second section of code, I create an instance of a Set by using the class
method named with:with:with:with: which takes four parameters. I then deny that
the set isNil. I assert that that the set isNotNil. I assert the set is not
equal to nil. I deny the set isEmptyOrNil, since it it neither nil or isEmpty. I
then assert that the class of set is Set.
In the third section of code, I select all instances contained in set into a new
Set named setNoNils, if the instance returns true to the message isNotNil. The
important thing here is that every subclass of Object in Smalltalk responds true
or false to the message isNotNil.
Here’s a final example of one of the methods available to all objects in
Smalltalk, including nil. The method name is ifNil:ifNotNil:. It is a control
structure method which takes two block (aka lambda) parameters. The result is
determined polymorphically by the type. The set here knows it is not nil, so it
will automatically execute the second block and return the result which here is
the String, ‘not nil’. The literal nil will know it is nil, so it will
automatically execute the first block and return the result which here is the
String, ‘nil’.
# Use the built in control structures around nil on all objects
self assert: (set ifNil: [ 'nil' ] ifNotNil: [ 'not nil']) equals: 'not nil'.
self assert: (nil ifNil: [ 'nil' ] ifNotNil: [ 'not nil']) equals: 'nil'.
WHAT IF NULL WAS AN OBJECT IN JAVA?
The following code is speculative, won’t compile, is untested, and unproven by
Java language experts. But perhaps if null were an instance of some class named
Null, the following code might be possible.
@Test
// NOTE THIS CODE WILL NOT COMPILE AND IS PURELY SPECULATIVE!!!
public void nullIsNotAnObject()
{
// Assert things about null
Assertions.assertTrue(null instanceof Object);
final Set<?> set = null;
Assertions.assertFalse(set instanceof Set);
// Assert things about calling methods on null as an object
Assertions.assertTrue(set.isNull());
Assertions.assertEquals(Null.class, set.getClass());
Assertions.assertEquals("null", set.toString());
// Assert things about a non-null variable
final Set<?> set2 = Set.of(1, 2, 3);
Assertions.assertNotNull(set2);
Assertions.assertNotNull(set2.getClass());
Assertions.assertTrue(set2 instanceof Set);
// Filter all of the non-null values from set2 in the Set named set3
// Uses an instance method refererence from the Object class
final Set<?> set3 = set2.stream()
.filter(Object::isNotNull)
.collect(Collectors.toUnmodifiableSet());
// Calling methods defined on Object, that would be overridden in Null
Assertions.assertEquals("null", null.ifNull(() -> "null"));
Assertions.assertNull(null.ifNotNull(() -> "notNull"));
Assertions.assertEquals("not null", set3.ifNotNull(() -> " not null"));
}
If null were an instance of a class named Null, it would also be possible to add
methods like ifNull, isNotNull, ifNotNull, isEmptyOrNull to both Object and Null
as Smalltalk does. The ifNull and ifNotNull methods would take some functional
interface type like Supplier, Consumer, or Function and then work with lambdas
and method references. In the example above, I changed the filter code to use a
Predicate formed from a method reference using the method named isNotNull which
would be defined on Object.
The tricky part would be how to make null capable of representing any interface
and class, and dispatching calls to a method named doesNotUnderstand for any
methods from those interfaces that null wouldn’t understand. The Null class
would have to behave like a Proxy for any type it is stored in, and forward
methods sent to a class like Set, to a single method that could handle the “I’m
not a Set” response appropriately.
Perhaps with null as an Object in Java, it would be possible to do away with a
whole variety of NullPointerExceptions.
WHY IS NIL BEING AN OBJECT USEFUL?
The fact nil is an instance of the UndefinedObject class in Smalltalk allows it
to be treated like all other objects in Smalltalk. It can respond to basic
methods that are supported on all objects. The instance nil has first class
treatment in the Object hierarchy in that every object knows that it is or isn’t
nil. This brings a nice symmetry to the language and libraries. This does not
remove the need to handle nil by avoiding or excluding it, but nil handling is
done using the same mechanisms that you would use to handle or exclude other
types, by calling methods like isNil, isNotNil, ifNil:,ifNotNil:,
ifNil:ifNotNil:.
In a language like Smalltalk where controls structures are not defined as
statements in the language, but as methods in the libraries, having nil exist
like everything else, as an object, leads to a an amazing level of consistency
and clarity. In my next blog I will delve more into how some other control
structures in Smalltalk are defined in the class library.
FINAL THOUGHTS
I’m not looking to change Java, as the null ship sailed a very long time ago.
What I am hoping is that I can help illuminate the possibilities for Java
developers who may not have seen another way of handling null in a different
object-oriented programming language.
This blog was intended to explain in simple terms the differences between null
in Java, and nil in Smalltalk. Learning multiple languages that use different
strategies to address the same problems is useful. Learning a whole new language
takes time. My hope is that this bitesize comparison is useful for you to be
able to understand the pros and cons of a different approach.
In my next blog, I plan to include two other literal objects in Smalltalk named
true and false., and compare them to their primitive Java equivalent also named
true and false. I will also compare them to the Java Object equivalent named
Boolean. I will also look to explain how control structures can be defined
effectively in a library, and not require special syntax and reserved words for
if, for, while statements.
Stay tuned, and thanks for reading!
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at January 05, 2024 06:54 PM
JANUARY 01, 2024
Donald Raab
TWELVE PLUS ONE SUNSETS IN 2023
by Donald Raab at January 01, 2024 09:10 PM
A year of biking, travel, and sunsets.
Sunset on Lake Pushaw, Maine
Sunsets are something we all have in common. I am thankful for all of the
sunsets that 2023 afforded me. Every sunset is a blessing. There are sunsets
happening around the world every minute. I hope you get to enjoy a sunset at
least a couple times a month. Just in case you missed any, the rest of this blog
includes some sunsets that I got to enjoy, each month in 2023. I hope you catch
as many sunsets as possible in 2024. They help make each day a beautiful day.
Enjoy!
JANUARY 2023
Sunset on the lake in Roosevelt Park where I ride my bike
FEBRUARY 2023
Sunset on the lake in Roosevelt Park where I ride my bike
MARCH 2023
Sunset on the lake in Roosevelt Park where I ride my bike
APRIL 2023
Sunset on the lake in Roosevelt Park where I ride my bike
MAY 2023
Sunset in Acadia National Park, Maine
JUNE 2023
Sunset on the bay in Long Beach Island, NJ
JULY 2023
Sunset on the lake in Roosevelt Park where I ride my bike
AUGUST 2023
Sunset on the bay in Long Beach Island, NJ
SEPTEMBER 2023
Sunset on the bay in Long Beach Island, NJ
OCTOBER 2023
Sunset on Lake Pushaw, Maine
NOVEMBER 2023
Sunset on the lake in Roosevelt Park where I ride my bike
DECEMBER 2023
Sunset on the lake in Roosevelt Park where I ride my bike
I hope you enjoyed a sampling of my sunsets from 2023. Again, I hope you get to
enjoy as many sunsets as possible in 2024 and beyond.
Have a safe, healthy, and Happy New Year!
I am the creator of and a Committer for the Eclipse Collections OSS project
which is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at January 01, 2024 09:10 PM
DECEMBER 29, 2023
Jonas, Maximilian and Philip
ECLIPSE THEIA 1.45 RELEASE: NEWS AND NOTEWORTHY
by Jonas, Maximilian & Philip at December 29, 2023 12:00 AM
We are happy to announce the Eclipse Theia 1.45 release! The release contains 28
merged pull requests and we welcome four new contributors. In this article we
will highlight some selected improvements...
The post Eclipse Theia 1.45 Release: News and Noteworthy appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 29, 2023 12:00 AM
DECEMBER 28, 2023
Mikael Barbero
UNDERSTANDING SOFTWARE PROVENANCE ATTESTATION: THE ROLES OF SLSA AND IN-TOTO
December 28, 2023 02:00 PM
A software provenance attestation is a signed document that associates metadata
with an artifact, encompassing details like the artifact’s origin, build steps,
and dependencies. This information is critical for verifying the artifact’s
authenticity and integrity. Featuring a cryptographic signature, provenance
attestation ensures the document remains unaltered, playing a vital role in
mitigating supply chain attacks. By scrutinizing the provenance of binaries,
users can thwart the execution of malicious code on their systems. Let’s delve
into some concrete examples:
1. Case of Compromised Package Manager: Imagine a scenario where an attacker
gains access to a developer’s package manager account for a widely-used
open-source software library. The attacker injects malicious code, builds,
and publishes an updated library version. As users update the library, the
malicious code spreads. With provenance attestation, users would have
noticed discrepancies in the attestation, revealing the code did not
originate from the official source. This proactive measure could have
averted incidents like the UAParser.js library hijacking in 2021.
2. Software Supplier Compromise Example: Consider an attacker targeting a
software supplier and tampering with their product. When customers use this
compromised product, it could lead to further software breaches or data
exfiltration. The CodeCov attack serves as a pertinent example. Here, a
malicious bash uploader artifact was uploaded to CodeCov’s repository.
Unknowingly downloaded and used this artifact by users resulted in stolen
Git credentials and amplified the supply chain attack. Provenance
attestation would have enabled users to detect the anomaly and prevent the
execution of the malicious code.
EXPLORING SLSA
SLSA (Supply chain Levels for Software Artifacts) is a framework that enhances
the security of software supply chains by defining levels for software projects
to aspire to. It emphasizes the generation, distribution, and verification of
provenance information.
The framework currently offers three Levels under the Build track in its 1.0
version. However, it’s beneficial to revisit the initial v0.1 draft for a
broader understanding of SLSA’s scope and future direction.
SLSA aims to shield against tampering at various stages of the software supply
chain. The initial levels presented a progressive approach to mitigating these
threats. The higher the level, the more robust the supply chain security. The
requirements for each level were comprehensive and provided a clear progression
path.
The 1.0 version narrowed its focus to the Build and Provenance requirements. The
introduction of “tracks” allows for future expansion, with the newly created
Build track being the sole focus in this version. Each track’s levels will
eventually measure different aspects of supply chain security.
SLSA 1.0 refined the division of requirements between the project and the build
platform. Achieving a higher Level in the Build Track implies greater trust in
the Provenance information, thereby offering better protection against threats.
The project requirements in the build track are now more straightforward,
largely depending on the build platform’s ability to produce provenance that
meets the level’s criteria.
INTRODUCING IN-TOTO
in-toto is a framework centered around software attestations, focusing on the
generation and verification of metadata of the software supply chain. Developers
and stakeholders generate metadata reflecting actions like coding and testing.
The project owner creates a layout, a critical document that defines the supply
chain’s expected steps and corresponding metadata.
Key components of in-toto include the layout (a JSON document outlining expected
the supply chain), functionaries (individuals or automated processes executing
steps), and inspections (operations that need to be performed on the final
product at the time of verification).
While similar to SLSA, in-toto offers broader attestation capabilities than just
about provenance information and without specific guidance against a threat
model, as seen in SLSA. It provides a standard format for outlining supply chain
expectations and realities.
SLSA AND IN-TOTO: HAND IN HAND
Given in-toto’s role in software attestation and SLSA’s focus on trustable
provenance, their combination is logical. SLSA recommends (but does not mandate)
the use of the in-toto format for provenance information, defining the necessary
information for each Build Level as a custom in-toto predicate type.
This Provenance predicate aligns with in-toto’s framework: it models the supply
chain as a series of steps, with each step generating attestations. These
attestations are then verified against a supply chain layout, a signed metadata
document defining the expected steps and their outcomes.
In-toto’s ability to define use-case-specific predicates complements SLSA by
providing a flexible means to capture a wide array of contextual supply chain
information. This includes code reviews, test results, and runtime traces, all
of which can be tailored to the specific needs of a project.
By integrating SLSA Provenance with in-toto attestations, software supply chains
can achieve a comprehensive verification process. This integration allows for
detailed tracking and verification of each step in the supply chain, from code
development to the final build, ensuring that all components meet the specified
security and integrity standards.
In practice, this means that when a build service performs a build, it not only
records the SLSA Provenance of the resulting artifact but also integrates this
with the broader set of in-toto attestations, encompassing various aspects of
the build process. These attestations, when combined, offer a more detailed and
trustworthy view of the software’s development and build process, enhancing the
overall security posture.
CONCLUSION
Software provenance attestation is crucial for mitigating a multitude of
security threats. Frameworks like SLSA and in-toto play a significant role in
enabling these attestations, ensuring the integrity and security of software
supply chains. In a forthcoming blog post, we’ll explore in detail the process
of creating SLSA provenance attestations specifically for Java/Maven projects.
This deep dive will provide valuable insights and practical steps for developers
looking to enhance the security of their Java applications. Keep an eye out for
this upcoming post for a comprehensive guide on implementing these security
measures.
--------------------------------------------------------------------------------
December 28, 2023 02:00 PM
DECEMBER 26, 2023
Mikael Barbero
UNDERSTANDING SOFTWARE PROVENANCE
December 26, 2023 02:00 PM
In the ever-evolving landscape of open-source software development, the creation
and distribution of artifacts—such as compiled binaries, libraries, and
documentation—represent the tangible results of a multifaceted process. These
artifacts are more than just a collection of code; they are the final product of
myriad decisions, alterations, and contributions, each with its unique
narrative. It’s essential to grasp these narratives or the provenance of these
artifacts, to secure the supply chain effectively. Moreover, the integrity and
security of these artifacts are paramount, as they underpin the trust and
reliability users expect. This post aims to demystify the concept of provenance
for these released artifacts. We will delve into why a comprehensive
understanding of their origins and the path they take—examined through the lens
of the journalistic 5W1H (Who, What, When, Where, Why, and How)—is crucial for
enhancing the security posture of an open source project’s supply chain.
UNDERSTANDING ARTIFACT PROVENANCE
Provenance in the context of released artifacts is a narrative of origin and
evolution. It’s a detailed account of an artifact’s lifecycle from its inception
in the developer’s mind to its final form when it is released to the world. This
lineage includes every modification, every build, and every individual who has
interacted with the artifact. A well-documented provenance is not just an
academic record; it’s a testament to the artifact’s integrity, a shield ensuring
that what users download and interact with is precisely what was intended,
untainted by tampering or malicious alterations.
CHALLENGES IN TRACKING ARTIFACT PROVENANCE
However, maintaining a comprehensive provenance is fraught with challenges. The
complexity of dependencies where each layer has its own story, the sheer volume
of artifacts and the speed at which they are updated, and the diverse sources
they are compiled from, all contribute to a labyrinth of information that needs
to be meticulously managed. Add to this the lack of standardized tools and
practices for documenting and verifying provenance, and the task can seem
Herculean. Yet, these challenges are not insurmountable barriers but rallying
calls for robust solutions, for the security and reliability of the software
supply chain hinge on this very capability.
PROVENANCE INFORMATION
If we consider what the provenance information of released artifacts should
comprise, it’s akin to the outcome of any solid journalistic work: it should
address the 5W1H (What, Who, Why, When, Where, and How) questions. At a
fundamental level, the answers to these questions should be as follows.
* The What concerns identifying the released artifacts themselves, giving them
an identity through an unambiguous identifier (e.g., using the Common
Platform Enumeration (CPE) scheme or a Package URL). It can also cover the
licenses of the artifacts, a list of the artifact’s dependencies, their
respective licenses, and how they have been retrieved, among other things.
This is more commonly known as a Software Bill of Materials (SBOM) and can be
considered a part of the provenance information to be released with an
artifact. Understanding the ‘What’ means having a clear, auditable trail of
the components that form the backbone of your software, enabling you to
assess, manage, and secure your software supply chain effectively.
* The Who can be as straightforward as identifying who triggered the release
(or the build of the release) of the artifacts. It might also extend to
include additional information about who contributed to the code included in
this release, whether from the project’s inception or since the last release.
Details regarding any signed Contributor License Agreement (CLA) or accepted
Developer Certificate of Origin (DCO) by contributors can also be
incorporated. Knowing who contributed what aids in tracking changes, auditing
contributions, and most importantly, ensuring that only trustworthy code is
incorporated into your projects.
* The Why pertains to understanding the reason behind the release: is it to fix
a security vulnerability? Is it a scheduled release following the regular
cadence? It might also involve tracking why a particular library was updated.
As such, the release notes can be considered a (non-structured) part of the
provenance information in this context. This aspect of provenance is about
context and rationale, which is crucial for assessing the impact of changes
on the overall security and functionality of your software.
* The When is straightforwardly about keeping track of the time of the release,
to anchor it in a broader historical context. It can also involve recording
the timing of the various contributions made prior to the release.
* The Where concerns tracing the locations of the various components that led
to the released artifact. Where was the code developed and stored? Was it in
a secure, trusted repository, or did it come from a less reliable source?
Where was it built? Knowing these details can be the difference between a
secure application and a vulnerable one. Coupled with the answer to the When,
this mirrors the journalistic approach of establishing timelines and
locations, helping you create a more comprehensive narrative of your
software’s development and enhancing security and control over your project’s
lifecycle.
* How relates to the methods, tools, and practices used to track and verify the
origins of your code. It encompasses the mechanisms you implement to ensure
that every line of code can be traced back to its source, thus ensuring
integrity and reliability. This not only refers to the build pipelines and
toolchains used to build and release the artifacts but also includes
information about software development best practices such as code review,
branch protections, secret scanning, and more.
While the full details of implementing software provenance attestation will be
covered in a future post, all this information can already be delivered to
downstream users of your project in a simple text file, for example, in the form
of buildinfo files. Although not exhaustive, buildinfo files are a testament to
the commitment to transparency and security, serving as a foundational element
for more advanced tools and practices.
THE IMPORTANCE OF ARTIFACT PROVENANCE FOR SECURITY
The narrative of provenance is critical for security. In a world where the
threat landscape is as vast as it is vicious, the lack of provenance can lead to
severe breaches. Compromised artifacts, malicious code insertions, and other
vulnerabilities are not just theoretical risks; they are stark realities. A
robust provenance framework is not just a defensive mechanism; it’s a
foundational pillar in building a secure, trustworthy supply chain. To enhance
the security posture of its projects, understanding and implementing provenance
practices is not an option; it’s an imperative.
HOW TO TRUST PROVENANCE DATA?
Trusting provenance data generated during the build process is a commendable
start. However, recognizing its limitations is crucial for establishing a more
robust system of trust
INTEGRITY OF BUILD-GENERATED PROVENANCE
The integrity of build-generated provenance is inherently fragile. It’s as
secure as the environment in which it’s stored and the transport methods used to
deliver it. Imagine if a malicious actor gains access to the storage backend or
intercepts the transport protocols; they could alter the provenance data,
rendering it unreliable. A common countermeasure involves signing the provenance
files or data. Digital signatures provide an additional layer of trust by making
any tampering with the provenance data after its creation detectable. However,
this step, while beneficial, is not a complete solution.
VULNERABILITY OF THE BUILD SCRIPT
Another critical aspect to consider is the vulnerability of the build script
itself. If the build pipeline is compromised, then so is the provenance it
generates, whether signed or not. A compromised script might produce misleading
information, feeding false data into what should be a trusted record. This
scenario underscores a crucial realization: to genuinely trust the provenance
data, the responsibility for generating it should shift away from the build
pipeline to the build platform.
THE SHIFT IN RESPONSIBILITY
By making the build platform responsible for this task and having it sign the
generated data, we create a system where the provenance is not only more
resistant to tampering but also inherently more trustworthy. The build platform,
ideally, is indeed in a unique position to observe and record the build process.
It has access to all the information needed to generate accurate provenance
data. This shift doesn’t eliminate the risk of compromise, but it does mean that
any tampering with the build pipeline won’t affect the integrity of the
provenance data we rely on.
SECURING THE BUILD PLATFORM
It’s important to note that this approach is not a silver bullet. The build
platform itself can be compromised, and securing it is a complex task that goes
beyond the scope of this discussion. However, it’s an essential consideration
for a truly trustworthy system. Even with a secured build platform, the
environment generating the provenance data must also be secure to genuinely
trust the data’s integrity.
In conclusion, while build-generated provenance is a valuable first step, it’s
essential to be aware of its limitations. Shifting the responsibility to the
build platform and securing that platform are critical moves towards a more
trustworthy and resilient system. However, remember that in the realm of
security, no solution is absolute. Each layer of trust we add is a step towards
a more secure ecosystem, but vigilance and ongoing improvement are always
necessary.
CLOSING NOTES
As we conclude our exploration of software provenance through the detailed lens
of the 5W1H framework, it’s clear that this is not merely an exercise in
compliance or best practices. It’s a fundamental shift in how we approach
software development and security. Understanding the ‘Who,’ ‘What,’ ‘When,’
‘Where,’ ‘Why,’ and ‘How’ of your artifacts isn’t just about enhancing
security—it’s about instilling a culture of transparency and excellence.
The journey we’ve outlined is challenging, with numerous complexities and
hurdles. However, the path to a secure and reliable software supply chain is not
only necessary but also attainable with the right mindset and tools. Adopting a
provenance-first approach is a paradigm shift. It means engraining the tracking
and verification of the origin and journey of artifacts into the very fabric of
the development and release process. It’s about integrating provenance tracking
into the build process, adopting tools that automate and standardize provenance
documentation, and fostering a community culture where knowledge, tools, and
best practices are shared freely and openly.
As we look forward to diving into the practicalities of implementing a robust
software provenance strategy in our next installment, remember that your
engagement and continuous learning are vital. The principles and practices
discussed here are just the beginning. With a blog post about the Supply-chain
Levels for Software Artifacts (SLSA) framework on the horizon, we will have the
guidelines and tools at our disposal to prevent tampering, improve integrity,
and secure our packages and infrastructure.
We invite you to not just read but actively participate in shaping the future of
software provenance. Join us and the Eclipse Foundation community in discussing
and advancing these crucial topics. Your insights, experiences, and commitment
are key to driving change and fostering a more secure digital world.
Together, let’s embrace the provenance-first mindset and lead the charge towards
a future where software development is synonymous with security, transparency,
and trust.
--------------------------------------------------------------------------------
December 26, 2023 02:00 PM
DECEMBER 23, 2023
Mikael Barbero
ECLIPSE FOUNDATION EMBRACES SIGSTORE
December 23, 2023 10:00 AM
As part of our ongoing commitment to fortifying the security of our software
development processes, we’re excited to announce a significant enhancement for
all Eclipse Foundation projects utilizing our Jenkins infrastructure. This
advancement comes with the integration of Sigstore, a cutting-edge solution
designed to bolster the security and integrity of software supply chains. By
exploring the integration of Sigstore within the Eclipse Foundation’s Jenkins
setup, this article sets out to demonstrate how this advancement is reshaping
secure software development and deployment for Eclipse Foundation projects.
WHAT IS SIGSTORE?
Sigstore represents a shift in the way we secure software artifacts. This
open-source tool offers a transparent and secure method for both signing and
verifying software artifacts, including binaries and container images. It’s
designed to make digital signing simpler for developers by eliminating the
complex management of keys. This allows users to confidently verify the
artifacts’ origins and integrity. At its core, Sigstore’s “keyless” signing
associates a signature with the signer’s identity, rather than a fixed set of
keys.
The process begins when a developer obtains an identity token from an identity
provider and creates a temporary public/private key pair in memory. This token,
along with the public key, is sent to Sigstore’s certificate authority, which
verifies the information against the token issuer. If the identity provider is
recognized and the token is valid, Sigstore’s authority issues a short-lived
certificate that binds the public key to the developer’s identity. This binding
is crucial as it securely attaches the identity of the signer to the artifact
being signed, ensuring traceability and accountability.
During the signing phase, a transparency log entry is created. This entry is
part of a public, tamper-evident ledger that records the artifact’s hash, the
public key used, and the signature, all with a timestamp to validate the
software’s integrity and origin at the time of signing. Once the signing is
complete, the private key is discarded, and the short-lived certificate soon
expires.
The trust in the verification process comes from this transparency log, not from
the signer’s ability to safeguard a private key. Users can validate the logged
details against the artifact to confirm its integrity and origin. This
verification can occur online, with real-time access to the transparency log for
the most up-to-date information. For environments where the transparency log is
not accessible, such as air-gapped systems, offline verification is also
possible. In these scenarios, the signed artifacts should be accompanied by the
certificate and public key, allowing verification against these components
without needing access to the transparency log. This method relies on the trust
established by the Sigstore-issued certificate, ensuring the authenticity of the
artifact as confirmed by a trusted CA.
This methodology goes beyond improving convenience; it serves as a strategic
defense against a range of cyber threats, particularly those targeting software
supply chains. By eliminating the need for developers to manage long-lived keys
and by providing a transparent log of signed artifacts, Sigstore mitigates risks
like code tampering (e.g., when used to sign commits) and unauthorized access,
which are prevalent in supply chain attacks.
USING SIGSTORE ON ECLIPSE FOUNDATION’S JENKINS INSTANCES
The Eclipse Foundation has recently become a recognized identity provider for
Sigstore’s certificate authority. This development is a game-changer for
projects within the Foundation for several reasons:
1. Managed Identity Verification: With this status, the Eclipse Foundation can
issue tokens for projects’ bot accounts. These tokens are recognized and
verified by Sigstore, which then issues certificates based on the Eclipse
Foundation’s managed identity. This process ensures a trusted link between
the artifact and the Foundation, further bolstering trust and security.
2. Streamlined Artifact Signing: Initially focusing on bot accounts, this setup
is tailored for automated processes, like those running on Jenkins
instances. Projects can seamlessly sign artifacts during the build and
release process, integrating security into the CI/CD pipeline without added
complexity.
3. Extended Trust and Compliance: Having the Eclipse Foundation as a recognized
identity provider means that artifacts signed through this process are
backed by a trusted entity, meeting higher standards of security.
It’s worth noting that Sigstore can be used by all of Eclipse Foundation
projects hosted on GitHub and using GitHub Actions, as detailed in GitHub’s blog
post. For Eclipse Foundation projects that utilize both Jenkins and GitHub, this
creates a cohesive and secure workflow for signing artifacts across platforms.
IMPLEMENTING SIGSTORE IN YOUR JENKINS WORKFLOW
If you want to start signing artifacts with Sigstore’s keyless process in your
Jenkins workflow, it’s very easy:
* The very first step is to open a help desk ticket to ask us to allow our
identity provider to issue tokens that would be verifiable by Sigstore. We
also configure your Jenkins instance with some new credentials.
* Adapt the workflow below to your use case and profit.
pipeline {
agent any
stages {
stage('Prepare') {
steps {
sh '''
echo "Hello World" > README
curl -sSL -o cosign https://github.com/sigstore/cosign/releases/latest/download/cosign-linux-amd64
chmod u+x cosign
'''
}
}
stage('Sign') {
steps {
withCredentials([usernamePassword(credentialsId: 'cbi-dev-sigstore', passwordVariable: '_BOT__PASSWORD', usernameVariable: '_BOT__USERNAME')]) {
sh '''
IDP_DATA=$(mktemp)
OID_TOKEN=$(mktemp)
chmod 600 "${IDP_DATA}" "${OID_TOKEN}"
trap 'rm -vf "${IDP_DATA}" "${OID_TOKEN}"' EXIT
cat <<EOF > "${IDP_DATA}"
username=${_BOT__USERNAME}
&password=${_BOT__PASSWORD}
&grant_type=password
&client_id=sigstore
EOF
curl -sSL -X POST \
--url https://auth.eclipse.org/auth/realms/sigstore/protocol/openid-connect/token \
--header "Content-Type: application/x-www-form-urlencoded" \
--data @"${IDP_DATA}" \
| jq -r ".access_token" \
| head -c -1 > "${OID_TOKEN}"
./cosign sign-blob README -y --bundle README.bundle --oidc-issuer=https://auth.eclipse.org/auth/realms/sigstore --identity-token="${OID_TOKEN}"
'''
}
sh '''
./cosign verify-blob README --bundle README.bundle --certificate-oidc-issuer=https://auth.eclipse.org/auth/realms/sigstore --certificate-identity=cbi-dev@eclipse.org
'''
}
}
}
}
During the Prepare phase, we just download the cosign tool, which is a CLI
client to sigstore. We could also go the hard way and only communicate with
Sigstore via its REST API with curl, but cosign make is much simpler.
During the Sign phase, we start by retrieving the project’s bot credentials and
use curl to retrieve a token from the Eclipse Foundation identity provider. We
aim at making this phase transparent to projects in the future and create the
token automatically on each workflow startup, à la GITHUB_TOKEN. We then pass
this token to the cosign tool to sign the README file.
Note that we save the file what cosign call a --bundle. This bundle is just an
aggregate of the signature and the certificate of the signature. This avoids
having to distribute 2 files along with the signed artifacts, simplifying the
transfer and the verification.
At the end of the signing process, the cosign tool prints the index of the
transparency log entry that has been created:
tlog entry created with index: 58260299
One can then check the information relative to this operation by going on the
transparency log web interface at
https://search.sigstore.dev/?logIndex=58260299.
Finally, for testing purpose, we verify the signature during the Verify phase.
We reuse the bundle we just introduced, and ask the cosign tool to verify that
the file has been signed with a certificate for the identity cbi-dev@eclipse.org
as issued by the identity provider
https://auth.eclipse.org/auth/realms/sigstore.
+ ./cosign verify-blob README --bundle README.bundle --certificate-oidc-issuer=https://auth.eclipse.org/auth/realms/sigstore --certificate-identity=cbi-dev@eclipse.org
Verified OK
CONCLUSION
We encourage all project teams within the Eclipse Foundation to adopt this new
capability. The integration is straightforward and offers significant benefits
in securing your software artifacts. By doing so, you’ll be taking a proactive
stance in securing your projects and contributing to a safer software supply
chain.
In conclusion, the adoption of Sigstore within our Jenkins infrastructure is
more than just a technical update; it’s a commitment to the security and
integrity of the Eclipse Foundation projets. We look forward to seeing its
positive impact on our community.
We welcome feedback and questions from the Eclipse Foundation community on this
journey together towards a more secure software future.
--------------------------------------------------------------------------------
This work was made possible thanks to the funding the Foundation received from
the Alpha-Omega Project.
--------------------------------------------------------------------------------
December 23, 2023 10:00 AM
DECEMBER 20, 2023
Eclipse Announcements
UNVEILING OPEN CODE EXPERIENCE
by Shanda Giacomoni at December 20, 2023 04:54 PM
Unveiling Open Code Experience Shanda Giacomoni Wed, 2023-12-20 11:54
We’re thrilled to announce Open Code Experience 2024, a new conference for our
vibrant community of communities. Watch for updates at opencode-x.org.
URL
https://blogs.eclipse.org/post/thabang-mashologu/unveiling-open-code-experience
--------------------------------------------------------------------------------
by Shanda Giacomoni at December 20, 2023 04:54 PM
DECEMBER 19, 2023
Eclipse Announcements
GOOD NEWS ON THE CYBER RESILIENCE ACT
by Shanda Giacomoni at December 19, 2023 02:09 PM
Good News on the Cyber Resilience Act Shanda Giacomoni Tue, 2023-12-19 09:09
The European Union’s proposed Cyber Resilience Act (“CRA”) as the final
revisions agreed to in the trilogue negotiations appear to largely exclude the
open source community from its scope.
URL
https://eclipse-foundation.blog/2023/12/19/good-news-on-the-cyber-resilience-ac…
--------------------------------------------------------------------------------
by Shanda Giacomoni at December 19, 2023 02:09 PM
Mike Milinkovich
GOOD NEWS ON THE CYBER RESILIENCE ACT
by Mike Milinkovich at December 19, 2023 09:01 AM
As the title says, there is good news to share on the progress of the European
Union’s proposed Cyber Resilience Act (“CRA”) as the final revisions agreed to
in the trilogue negotiations appear to largely exclude the open source community
from its scope.
I have written (here and here) and spoken extensively about our concerns with
the European Union’s proposed Cyber Resilience Act (“CRA”) in the past. As
originally drafted, the CRA would have had an enormous negative impact on both
the open source community and the EU’s innovation economy. In short, it would
have required most open source projects (and every open source project that
matters) made available in Europe to meet unrealistic regulatory requirements
related to their secure software development and maintenance. OSS projects would
have also been required to affix the CE Mark on their releases certifying that
these regulatory requirements had been met, which additionally would have
required outside audits performed for critical infrastructure projects such as
operating systems. You can read the links above if you want to get a full
understanding of the dire implications of the original draft of the CRA.
While the Eclipse Foundation has always shared the goals of the CRA to improve
the state of security in the software industry, we have been very vocal in
expressing our concerns with how unrealistic requirements could damage the open
source community and Europe’s innovation economy. We have been very active in
raising community awareness of the issues over the past year. For example, we
helped facilitate two open letters co-signed with many of our peer organizations
detailing the issues (here and here).
But we also invested a great deal of time and energy in constructively engaging
with policymakers by providing explanations of the functioning of our ecosystems
and technologies. The European Commission, the European Parliament, the Council
through the Spanish Presidency, as well as numerous policy makers at the
national level have all been open to our contributions and recognise our efforts
to protect European open innovation. I would like to thank my colleagues Gesine
Freund, Enzo Ribagnac, Mikaël Barbero, and Gaël Blondelle for their many
contributions to this process.
We were not alone in these efforts. An assuredly incomplete list of other open
source organizations that contributed to raising awareness includes: Apache
Software Foundation, Internet Society, Free Software Foundation Europe, Linux
Foundation, Mozilla Foundation, NLNet Labs, Open Source Initiative, Python
Software Foundation, The Document Foundation, and many others. OpenForum Europe
played a pivotal role in facilitating communication between these groups, and
Ciarán O’Riordan at the OFE deserves recognition for his yeoman’s effort in
coordinating the community’s input throughout the discussions on the CRA.
On December 1st it was announced that the EU co-legislators had reached
political agreement on the CRA. Although the final text is still being worked
on, we are happy to report the open source community has been listened to. The
revised legislation has vastly improved its exclusion of open source projects,
communities, foundations, and their development and package distribution
platforms. It also creates a new form of economic actor, the “open source
steward,” which acknowledges the role played by foundations and platforms in the
open source ecosystem. This is the first time this has appeared in a regulation,
and it will be interesting to see how this evolves. The Eclipse Foundation will
be investing a great deal of effort into helping refine this concept and its
implementation to ensure it aligns with the norms of the open source community.
The final revisions also extended the implementation phase to three years, which
means full compliance with the CRA will likely start in early 2027. OpenForum
Europe’s recent press release on the CRA is certainly worth a read for
additional context.
It is important to recognize and thank the many people that were involved in
achieving this significantly better outcome. Both those who were involved from
the side of the co-legislators who genuinely listened and made extensive
improvements, and the many people from the open source community who invested
their time and energy into explaining the unique requirements of the open source
community.
But this journey is only beginning.
It is important to note that while the CRA has been revised to largely exclude
the open source community from its scope, this legislation will still have an
enormous impact on the software industry as a whole.
Open source projects will not be required to directly implement the mandated
processes described in the CRA. But every commercial product made available in
the EU which is built on top of those open source projects will. For the first
time in the software industry’s history, it will soon have regulatory
requirements for secure software development and maintenance. I predict this
will put pressure on projects and communities to enhance their processes to
assist in downstream commercialization.
After all, if a project is used in hundreds of products, doing the bulk of the
CE Mark conformance work in the project rather than repeating the effort
hundreds of times makes enormous sense. But as we all know, OSS projects at the
moment simply do not have the resources to do this. It is impossible to know how
all of this will play out, but an optimistic hypothesis is that once companies
are required by law to meet secure software development practices they will be
incented to invest in the upstream projects they rely upon. The Eclipse
Foundation will be working hard to ensure that we evolve to support the needs of
our committers, projects, and members in order to support the implementation of
these new regulatory requirements. We will be discussing this early in the new
year.
Interesting times!
--------------------------------------------------------------------------------
by Mike Milinkovich at December 19, 2023 09:01 AM
DECEMBER 18, 2023
Sharon Corbett
INDUSTRY COLLABORATION IN ACTION: ECLIPSE SDV, OPENMOBILITY AND THREADX
by Sharon Corbett at December 18, 2023 04:21 PM
Industry Collaboration in Action: Eclipse SDV, OpenMobility and ThreadX
If you’ve read my two previous blog posts, you already have an understanding of
how interest groups and working groups provide two different mechanisms for
industry collaboration, how your organisation can get started on its own
collaboration journey, and the numerous benefits that come from collaborating on
open source software at the Eclipse Foundation.
But the best way to understand what joining an industry collaboration can do for
your organisation is by taking a look at some of our current collaborations.
The Eclipse Foundation currently hosts 21 Industry Collaborations focused on
various technologies and domains, from developer tools to cloud native Java, IoT
and beyond. One working group that has experienced considerable momentum
recently is Eclipse Software Defined Vehicle (SDV).
Over 40 organisations have joined Eclipse SDV since the working group’s launch
in 2022. Members range from automotive OEMs and Tier-1’s, to enterprise software
companies, to the cloud hyperscalers. This is driven by the fact that the
software defined vehicles of the future will be highly connected, and the
systems engineering requirements will span deeply embedded and safety critical
components all the way to connectivity to cloud-based IT systems.
Eclipse SDV members collaborate on non-differentiating technologies and share
best practices, which decreases their time to market and makes things easier for
their developers. The move to open source software is a significant departure
from the norm for the automotive industry, which has historically embraced
proprietary solutions where common building blocks are often replicated.
Visit the Eclipse SDV project page to see the code first approach across more
than 20 projects.
While interest groups are fairly new to the Eclipse Foundation, there are a few
active collaborations that are benefiting from the foundation’s governance
structure, like Models for Privacy Engineering, OpenMobility and Eclipse
ThreadX.
In the case of OpenMobility, a group of four members came together to work on
evolving and driving adoption of mobility modelling and simulation technologies.
Its members are interested in delivering a methodology and a framework of tools
that are based on validated models. These tools are intended to be recognised as
“standard tools” in industry applications and academia for mobility modelling
and simulation. OpenMobility has declared interest in Eclipse MOSAIC and Eclipse
SUMO and Eclipse openMCx.
ECLIPSE THREADX: A NEW ERA FOR EMBEDDED RTOS TECHNOLOGY
The Eclipse Foundation’s newest interest group is a unique case. With Microsoft
contributing Azure RTOS to the Eclipse Foundation under the Eclipse ThreadX
project last month, plans are underway to establish a working group that will
consolidate the project, preserve its certifications, promote the brand, and
grow the technology’s ecosystem and community.
However, this cannot be done without first establishing an industry-supported,
sustainable funding model for Eclipse ThreadX. This will be the focus of the new
ThreadX Interest Group. The founding members of this interest group intend to
form a working group dedicated to the project after investigating key topics
around the potential working group’s funding and goals. Any company with an
interest in embedded technology is welcome to join the interest group to define
ThreadX’s future.
While interest groups are not necessarily intended to serve as a jumping off
point for new working groups, ThreadX shows just how flexible this collaboration
model can be. With interest groups, members can come together to share a common
interest in a topic or domain in a vendor-neutral manner. What members choose to
collaborate on is up to them.
To learn more about our industry collaborations and our current showcase, please
visit eclipse.org/collaborations, and contact us if you are interested in
joining and/or forming a new collaboration!
Sharon Corbett Mon, 2023-12-18 11:21
--------------------------------------------------------------------------------
by Sharon Corbett at December 18, 2023 04:21 PM
Mikael Barbero
ELEVATING SOFTWARE SUPPLY CHAIN SECURITY: ECLIPSE FOUNDATION'S 2FA MILESTONE
December 18, 2023 04:00 PM
In the realm of open-source software, security of the supply chain is not just a
concern—it’s a crucial battleground. The Eclipse Foundation, at the forefront of
this fight, has taken a decisive step with its 2023 initiative to enforce
two-factor authentication (2FA) across its platforms. This move is more than a
security upgrade; it’s a testament to the Foundation’s commitment to
safeguarding the open-source software supply chain against escalating threats.
The traditional reliance on password-based authentication poses a significant
risk, especially in open-source software development. As highlighted in a
previous article, compromised developer accounts can become conduits for
malicious code, affecting not only the developers themselves but also downstream
users. The alarming 742% average annual increase in software supply chain
attacks in recent years underscores the urgency of robust security measures.
Recognizing this threat, the Eclipse Foundation has championed the shift to more
secure authentication methods with 2FA.
The road to comprehensive 2FA implementation was not without its challenges. One
of the main hurdles was addressing misunderstandings about what 2FA entails. For
example, there was confusion about whether 2FA required hardware tokens.
Additionally, concerns arose about what actions to take in case of a loss of the
second factor. The Foundation tackled these issues head-on through repeated
communication and education, providing clear, accessible information to
demystify 2FA and allay fears.
Feedback and insights from the Eclipse community were invaluable in shaping the
2FA initiative. A particularly unique challenge came from members who were
unable to use mobile phones or hardware tokens at their workplaces due to
internal policies. To address this, the Foundation helped identify software
solutions that facilitated TOTP-based 2FA, aligning with the IT requirements of
these members: we were committed committed to help everybody and find practical
solutions to all problems.
For the Eclipse Foundation, 2FA is just one aspect of a broader vision to harden
software supply chain security. Recognizing that the first line of defense
starts with developers, the Foundation has positioned itself as a role model in
software supply chain security. Beyond 2FA, it is actively helping its projects
to better understand and communicate their dependencies through Software Bill of
Materials (SBOMs), manage vulnerabilities in these dependencies, and secure
their build pipelines against potential threats. These initiatives are set to
continue throughout 2024.
The impact of the 2FA enforcement initiative is clearly demonstrated by the
significant adoption rates within the Eclipse community. On GitHub, 91% of our
committers have now enabled 2FA, with 63% of organizations achieving complete
member compliance. In 2024, we will take the final steps to fully enforce 2FA
for committers on GitHub, ensuring that all organizations will exclusively have
members with 2FA enabled. For projects hosted on gitlab.eclipse.org, 63% of
committers have enabled 2FA. Since December 11th, committers are required to
enable 2FA upon signing in—if they haven’t already—before they can proceed with
any other actions.
The 2FA enforcement initiative of the Eclipse Foundation represents an essential
measure in hardening the security of the open-source software supply chain of
its projects. This initiative underscores the significance of shared
responsibility and vigilance in cybersecurity.
--------------------------------------------------------------------------------
This work was made possible thanks to the funding the Foundation received from
the Alpha-Omega Project.
--------------------------------------------------------------------------------
December 18, 2023 04:00 PM
Mike Milinkovich
CELEBRATING ECLIPSE THEIA’S MILESTONE: FULL COMPATIBILITY WITH VS CODE EXTENSION
API
by Mike Milinkovich at December 18, 2023 12:09 PM
We are thrilled to announce a landmark achievement in the evolution of Theia:
full compatibility with the Visual Studio Code (VS Code) extension API, marking
a significant milestone in the journey of Theia towards becoming a universally
adaptable development environment.
UNLEASHING A WORLD OF FEATURES WITH VS CODE EXTENSIONS
Theia has supported hosting VS Code extensions for many years. The integration
of the VS Code extension API unlocked an unprecedented array of features for
Theia-based applications. This compatibility means that users can leverage the
extensive ecosystem of VS Code extensions, bringing thousands of new
capabilities to Theia. With the completion of a recent initiative, Theia now is
fully compatible with the VS Code API allowing the vast majority of VS Code
extensions to be used in any Theia-based application. Of particular note is the
recent addition of support for notebook editors, a game-changer that opens Theia
to new audiences, such as data scientists, who rely heavily on notebook
interfaces for languages like Python.
A SYMPHONY OF COLLABORATION
This achievement is not just a technical milestone; it is a testament to the
power of collaborative open-source development. The original VS Code API
compatibility implementation was contributed by Red Hat. The journey to full
compatibility, initiated by STMicroelectronics and crafted through the concerted
efforts of EclipseSource, Ericsson, Typefox, and other contributors, has been
one of shared vision and united effort. STMicroelectronics and EclipseSource
played a pivotal role in establishing an open, structured process for regular
API comparison and issue tracking. This approach facilitated a broad-based
contribution, allowing various organizations to contribute effectively to the
project.
EMPOWERING THE DEVELOPER COMMUNITY
The compatibility with the VS Code API multiplies Theia’s effectiveness as a
development platform. For developers, this means access to the latest and most
advanced tools available in the VS Code ecosystem, significantly enhancing both
the adopter and user experience with Theia.
OVERCOMING CHALLENGES THROUGH OPEN SOURCE COLLABORATION
The journey to this point wasn’t without challenges. Initially, contributions
were focused only on specific missing API features needed for particular
extensions used by contributors. However, the structured process initiated by
STMicroelectronics set a new direction – aiming for complete compatibility. This
approach significantly simplified the distribution and parallelization of work.
As a result, this process galvanized the open-source community, leading to a
surge in contributions and exemplifying the true spirit of collaborative
innovation.
MAINTAINING THE PACE: THE FUTURE ROADMAP
For nearly half a year, Theia has maintained full compatibility with the VS Code
extension API. The commitment to this standard is unwavering. With regular scans
of new VS Code API updates, contributors that Theia stays in lockstep with the
latest advancements, continually integrating new features and capabilities.
JOIN US IN THIS CONTINUAL JOURNEY
As we celebrate this milestone, we also look to the future. Theia’s journey is
ongoing, and the path ahead is as exciting as the accomplishments behind us. We
invite the developer community, contributors, and enthusiasts to join us in this
vibrant and continually evolving project. Together, we will keep pushing the
boundaries of what’s possible in open-source development environments.
Let’s continue to shape the future of software development tools with Theia.
Your contributions, feedback, and engagement are not just welcome – they are
essential to our shared success.
Here are a couple of links to get you started in your journey with Eclipse
Theia:
* Theia’s website
* Project overview page
* Github organization
* Project readme
* Getting started with Theia
* Contributing to Theia
--------------------------------------------------------------------------------
by Mike Milinkovich at December 18, 2023 12:09 PM
Donald Raab
MEMORIES OF TWENTY YEARS OF ECLIPSE COLLECTIONS DEVELOPMENT
by Donald Raab at December 18, 2023 12:07 AM
If you want to go far in open source, go together.
My wife and daughter, in our apartment in London in early 2004, the year Eclipse
Collections was created
FAMILY FOR THE WIN
The open source Eclipse Collections Java library had humble beginnings solving
memory problems in a Java application I was working on in 2004. I lived and
worked in London, along with my wife and daughter, for most of 2004. Eclipse
Collections and my son were conceived in London. I credit the weather in London
for both. I got used to carrying an umbrella and having a plastic covering on
our pram when wandering about the city and country (a pram is a baby stroller
for those in the US). I learned to be prepared for potential variations in the
weather a few times a day. Our trip to London remains one of my fondest memories
for many reasons. London will always feel like my second home.
My wife and daughter, ready for all weather exploring, outside Buckingham Palace
in early 2004
I’ve been working on Eclipse Collections for twenty years. I was never alone in
my journey, even when the journey felt lonely. My family was there with me every
single day. They were there through all of the challenging problems I was
solving, in both of the banks I have worked in the past twenty years. My family
may not have understood what I was working on or why, but it didn’t matter to
them. They understand the joy that programming brings me.
Me in my Smalltalk solutions t-shirt playing on my computer with my daughter in
London in 2004
In October 2022, my wife and daughter saw me give a talk in person at JavaOne
2022 in Las Vegas. They saw me deliver the Surviving Open Source talk, which I
first delivered as the keynote for IntelliJ IDEA Conf 2022. This was the first
time they ever saw me speak at a technical conference. I’m glad they were able
to see this particular talk. I think they now have a better understanding for
what it is that I have been working on, and the impact it has had on the Java
and open source communities. They also have a better appreciation for how
important they have been to me along the journey. I hope to eventually take my
son to a conference to see me speak, so he can hear me talk about his open
source sibling, Eclipse Collections.
My daughter and me at JavaOne 2022 wearing Eclipse Collections t-shirts
TEAM AND COLLEAGUES DELIVER
Many developers have collaborated with me over the years on Eclipse Collections.
They have created amazing things that are practical, useful, and solved real
problems they encountered in the spaces they were working in. The library
represents the collective Java collection needs and contributions from some of
most talented developers in the Financial Services industry. I consider myself
fortunate to have been able to work with so many of them.
The library started out as all great libraries should. It started out as code
crafted to solve real problems in an application. Eventually the code was
harvested from that application, moved to a shared code space, and made reusable
across several applications. The code saw more usage and evolution from
contributions from an increasing number of developers. The code was harvested
again, moved, and made more reusable a couple more times until it found its
final internal destination in Goldman Sachs in the form of a library named
Caramel. Caramel would become one of the most reused and contributed to Java
libraries inside of Goldman Sachs.
Caramel was harvested yet again, made more reusable, and moved to GitHub as GS
Collections. GS Collections was the first ever open source project created at
Goldman Sachs. Since then Goldman Sachs has open sourced several large
internally developed projects on their GitHub account and also at the FinOS
Foundation. I am proud to have started the trend of open source project
contributions at Goldman Sachs with GS Collections. I have no doubts that this
trend will continue, and wish the best for all the GS developers as they
continue their collective and individual journeys in contributing to
open source.
Goldman Sachs booth at JavaOne 2014 w/ the GS Collections story on GS
Engineering Portal
Folks often credit me with being the first developer to start Goldman Sachs on
the path of contributing large internally developed projects to open source.
While it is true that I was the driver of this initiative, I was most certainly
not alone. I had an army of supporters I collaborated with for five years inside
of Goldman Sachs that helped make the open sourcing of GS Collections a reality.
There were many developers and senior tech leaders who helped me along the way.
I also spent a lot of quality time with lawyers, compliance officers, risk
officers, media relations, marketing, and branding folks. I built some great
relationships with folks in these areas. Every single one of these folks
contributed to the positive end result. Thank you!
I told some of this story in person in 2019 at the Open Source Strategy Forum in
New York City, in a Fireside Chat with Gab Columbro. The conference was hosted
by the FinOS Foundation. The link to the recording of the talk is here.
MOVING ON TO GLOBAL COLLABORATION
GS Collections would turn out to be just the beginning of the open source
journey for Eclipse Collections. Many features would be added in the four years
the GS Collections library would be in active development on the Goldman Sachs
GitHub account. The code would eventually be forked and moved to the Eclipse
Foundation to become Eclipse Collections at the end of 2015. Eclipse Collections
has existed as an open source library, hosted at the Eclipse Foundation for
eight years now. Congratulations to all involved!
Folks outside of Goldman Sachs got to see the end result of the Eclipse
Collections move. They didn’t get to see the year plus that many folks worked on
getting everything sorted out in order to move GS Collections to the Eclipse
Foundation. This was a project on its own. The goal was simple. Open up the
library so anyone could contribute by leveraging the experience and open source
governance structure at the Eclipse Foundation. The move of GS Collections to
the Eclipse Foundation is what made Eclipse Collections a mature and sustainable
open source project. GS Collections was free as in beer. Anyone could take the
code and library and do what they wanted with it. Eclipse Collections is free as
in speech. Any developer can contribute and participate in its evolution so long
as they sign the Eclipse Contributor Agreement.
Nikhil Nanivadekar and me, the two active Project Leads for Eclipse Collections
at Devnexus 2018
A huge thank you to our amazing Eclipse Collections committer team — Nikhil
Nanivadekar, Sirisha Pratha, Craig Motlin, Moh Rezaei, and Hiroshi Ito. This
committed team of amazing engineers has kept Eclipse Collections evolving at the
Eclipse Foundation for the past eight years. They have done the hard and
sometimes thankless work of code reviews, pull request merges, monitoring and
creating issues, preparing and delivering releases, fixing bugs, and making
valued contributions of their own. Eclipse Collections enjoys continued success
because of their hard work. Thank you!
THE COST AND DELIVERY OF REUSE
Reuse is hard. Reuse is expensive. I have told developers over the years it can
be two to three times more expensive to develop a reusable component than it is
to develop a single use component. When invested in strategically and
continuously, reuse can produce enormous returns on investment. This return can
come in the form of multiplicative cost savings. No Java developer should ever
have to create the missing data structures in the JDK. This is a cost that was
created and multiplied by the lack of features in the original twenty five year
old Java Collections Framework. You don’t have to wait for the Java Collections
Framework to solve the problems you have today, but you have to recognize that
you are incurring costs, and that there is a potential cost savings solution
available to you in the form of Eclipse Collections.
Developers initially use Eclipse Collections because they need to solve some
problem that is expensive to implement or maintain on their own, like primitive
collections. Over time developers use Eclipse Collections because they want to,
because it makes them more productive and happy. Eclipse Collections is one of
the best kept, openly shared, Java productivity secrets across all of Financial
Services. I’ve done my best to share this secret with folks since GS Collections
was first open sourced in 2012. Telling 12 million Java developers about
something they are missing is definitely a challenge, and requires a large
investment of time raising awareness through blogs, articles, meetups, and
conference talks. Eclipse Collections has to compete with all the new shiny
things that continually promise to make developers more productive. Eclipse
Collections can be every Java developer’s secret weapon, but shhhh, don’t tell
everyone if the secret is already saving you money and time. Please don’t tell
ChatGPT about it. All we need is for ChatGPT to start writing Java code using
Eclipse Collections and saving all Java projects time and money. On second
thought… ChatGPT, have at it!
Here are five open source projects that benefit from reusing Eclipse
Collections.
* GitHub - goldmansachs/reladomo: Reladomo is an enterprise grade
object-relational mapping framework for Java.
* GitHub - finos/legend: The Legend project
* GitHub - neo4j/neo4j: Graphs for Everyone
* GitHub - vmzakharov/dataframe-ec: A tabular data structure (aka a data frame)
based on the Eclipse Collections framework
* GitHub - motlin/liftwizard: A collection of utilities for Dropwizard
AND NOW, THE TRENDS AND STATS
Eclipse Collections continues to evolve and grow. Based on the download trends
it looks like the secret of the benefits of using Eclipse Collections is
successfully getting out there. A big thank you and congratulations to the
entire Eclipse Collections and Java community!
MAVEN CENTRAL MONTHLY DOWNLOADS IN 2023
Monthly downloads of eclipse-collections from Maven Central for 2023
QUICK STATS
* 367,562 downloads of eclipse-collections in Nov. 2023
* 1,430,085 downloads of eclipse-collections-parent in Nov. 2023
* 2,297 GitHub Stars
* 568 GitHub Forks
* 1,999 Commits
* 107 Contributors
QUICK LINKS
* GitHub Repo
* Kata Repo
* Website
* Maven Central
TECHNICAL CONTENT
For folks looking for a technical retrospective, Sirisha Pratha wrote the best
one for Eclipse Collections a few years ago. Sirisha links to 31 days of blogs
and articles written about Eclipse Collections and GS Collections over the years
by various authors. This blog is a great index to technical content about
Eclipse Collections.
Eclipse Collections — 2020 retrospective
There has been a lot of technical content written about Eclipse Collections
since the end of 2020. There are Medium search links on the Eclipse Collections
GitHub wiki at the following link which include a lot of the more recent content
that has been produced.
Blogs
THANK YOU!
Thank you to all of the contributors, committers, users, advocates, and friends
of Eclipse Collections. You have helped make this journey worthwhile and
enjoyable. I appreciate your support and many contributions over the past twenty
years. I hope to see many of you and thank you in person at various technical
conferences in the coming years.
To my family, I love you very much. Thank you for supporting me and keeping me
inspired and motivated while I was spending time working on Eclipse Collections
all of these years.
Have a safe, happy and healthy Holiday and New Year!
I am the creator of and a Committer for the Eclipse Collections OSS project
which is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at December 18, 2023 12:07 AM
Jonas, Maximilian and Philip
BUILDING CLOUD-NATIVE (MODELING) TOOLS
by Jonas, Maximilian & Philip at December 18, 2023 12:00 AM
Are you on the journey to develop a domain-specific (modeling) tool based on
modern web technologies? Curious about the latest tech innovations and their
seamless integration for cloud efficiency?...
The post Building cloud-native (modeling) tools appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 18, 2023 12:00 AM
DECEMBER 16, 2023
Donald Raab
MY JOURNEY TO AND AS A JAVA CHAMPION
by Donald Raab at December 16, 2023 10:43 PM
Reflecting on my Java Champion story and its evolution after five years.
Walking the Path to Balos Beach, Crete with JCrete attendees— July 2016
A MARKER ALONG THE JOURNEY, NOT THE DESTINATION
It was truly a great honor for me to be selected as a Java Champion in July
2018. By the time I was selected, there were around 265 Java Champions, out of
an estimated 9–12 million Java developers.
Tweet announcing several Java Champion selections
Today, there are about 380 Java Champions globally. The members of this
prestigious group share a lot of knowledge, experience, inspiration, and time
with the global Java community. I think of a Java Champion as someone who is a
champion for Java, and not just a champion of Java. Giving back to the Java
Community in the form of blogs, articles, books, conference talks, JUG meetups,
open source contributions, expert group, and committee participation are all
important aspects of being a Java Champion.
My recipe for success? Passion, Patience, and Persistence. I did not set out
with a goal of becoming a Java Champion. I have always wanted to help make Java
a better language for developers to develop in. I knew this would be a long
road. I started down this path in 2001 when I first began programming in Java
full time. It wasn’t until the end of 2017 that I though perhaps I might
eventually qualify to be selected into the Java Champions community.
I found this blog by Vlad Mihalcea to be both informative and inspiring on my
own journey.
How to become a Java Champion - Vlad Mihalcea
MY JOURNEY AS A MINDÂ MAP
Every Java Champion’s story is different. There were thousands of little
important moments that edged me closer to being nominated and accepted into the
Java Champions community since I started getting involved publicly in the Java
Community in 2010. The most important moment was when Leonardo de Moura Rocha
Lima nominated me as a Java Champion. I am extremely thankful for the honor Leo
bestowed upon me with this nomination. Thank you!
Anyone who has read many of my blogs will probably know that I love mind maps.
The following is a mind map of all of the things I had been involved with
publicly before I was finally selected as a Java Champion in 2018.
A visual representation of my public impact and influence before selected as
aJava Champion in 2018
TOP FIVE EVENTS ALONG MYÂ JOURNEY
The following are the top five events that I believe set the stage for me to
eventually be nominated as a Java Champion.
1. Joining the JSR 335 Expert Group — 2011
2. Open Sourcing GS Collections at Goldman Sachs — 2012
3. JavaOne 2014 — Strategy Keynote, first JavaOne talk, Face-2-Face
meeting of JCP EC at Twitter Headquarters where I created my
Twitter account
4. Moving GS Collections to the Eclipse Foundation to become Eclipse
Collections — 2015
5. Attending JCrete — 2016
The events were not only important for the impact I was having, they were
formative in me building important long-lasting relationships in the Java
Community.
MY JOURNEY AS A JAVAONE CONFERENCE BADGE
At the time of JavaOne in 2016, I was a speaker, an exhibitor, a JavaOne Alumni,
a Java Community Process (JCP) Member, a JSR 335 Expert Group (EG) Member, had
helped out with the Adopt-a-JSR effort and was also a member of the JCP
Executive Committee (EC).
This was my JavaOne 2016 badge. I think it nicely captures the things I was
actively doing in the Java Community at the time.
THE STUFF THAT DIDN€™T MATTER
I’ve had a successful career in Financial Services working at two different
banks for the past 22 years. I‘ve been a Managing Director and Tech Fellow at
one bank, and am a Managing Director and Distinguished Engineer at another. None
of my impressive enterprise scale proprietary work inside of the banks or the
corporate titles I accumulated along the way mattered even a tiny bit for my
Java Championship nomination and selection. However, the impressive enterprise
scale stuff that I created and contributed to open source while at these
Financial Services firms on the other hand, definitely made a difference.
All of the stuff in the mind map above was public facing. This is something to
think about if you are suddenly inspired and motivated to begin a journey to
Java Champion.
My rule of thumb — If you can’t link to it from a web browser outside of
your current company, it doesn’t matter on your journey to Java Champion.
FIVE YEARSÂ LATER
A lot has happened in the five plus year I have been a member of the Java
Champions. I think a comparison of some of the stats from the mind map comparing
2018 and 2023 will summarize how my impact and influence in the Java Community
has grown.
* Measure — 2018 value �� 2023 value
* Medium Blogs — 29 �� 174
* Medium Followers — 154 �� 1,523
* Twitter Followers — 727 ���� 9,178
* LinkedIn Connections— 1,300 �� 2,632
* StackOverflow Answers— 120 �� 197
* StackOverflow Reputation — 3,881 �� 6,528
* Eclipse Collections (EC) GitHub Stars— 726 �� 2,284
* Maven Central EC Monthly Downloads — 40,000+ �� 300,000+
This year marked a new achievement for me. I presented at four Java Conferences
in six months. I really felt like a Developer 🥑 for the first time. Two of
the conferences I spoke at were in Europe. This was my first time speaking at
European Tech Conferences. I hope to continue this trend in 2024 and beyond.
MY TOP FIVE INÂ FIVE
If I had to name the top five memorable things that happened to me on my journey
the past five years as a Java Champion, they would be as follows.
1. My wife and daughter seeing me speak for the first time at JavaOne 2022
2. Contributing author to “97 Things Every Java Programmer Should
Know� book
3. Eclipse Collections named one of the 25 greatest Java apps ever written in
Java Magazine
4. Co-presenting with Rustam Mehmandarov at four Java conferences in 2023
5. Delivering the virtual keynote for IntelliJ IDEA Conf 2022 with Mala
Gupta hosting
IT€™S A BEGINNING, NOT THE END
I hope you find this blog helpful in understanding my journey to becoming a Java
Champion. I hope it will inspire some of you to start sharing your experiences,
contributions, and knowledge with the developer community as you begin or
continue your own journeys, on whichever path you choose.
I’ll be out there continuing my own journey as a Java Champion. Look out for
new blogs, open source contributions, and talks at JUGs and various global Java
conferences. I hope to meet many new excited Java developers over the next few
years at Java Conferences and JUG Meetups. Good luck, and good journey!
Me enjoying a coffee with my now memorial Twitter coffee cup during
the pandemic
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at December 16, 2023 10:43 PM
DECEMBER 14, 2023
Lorenzo Bettini
ECLIPSE FONTS IN WINDOWS 11
by Lorenzo Bettini at December 14, 2023 09:06 AM
This is a quick post about having nice fonts in Eclipse in Windows 11, based on
my experience (maybe I had bad luck with the default configurations of Eclipse
and/or Windows). When I bought my Acer Aspire Vero, I found Windows 11
installed, and now and then, I’m using Windows 11 (though I’m using Linux […]
--------------------------------------------------------------------------------
by Lorenzo Bettini at December 14, 2023 09:06 AM
Jonas, Maximilian and Philip
THE ECLIPSE THEIA COMMUNITY RELEASE 2023-11
by Jonas, Maximilian & Philip at December 14, 2023 12:00 AM
We are happy to announce the fourth Eclipse Theia community release
“2023-11”, version 1.43.x! Don’t know about Eclipse Theia,
yet? It is the next-generation platform for building...
The post The Eclipse Theia Community Release 2023-11 appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 14, 2023 12:00 AM
DECEMBER 11, 2023
Donald Raab
WHY DO YOU WRITE LIKE YOU’RE RUNNING OUT OF TIME?
by Donald Raab at December 11, 2023 12:39 AM
I learned something important during the pandemic, so I wrote it down.
Photo by Milad Fakurian on Unsplash
I watched Hamilton the Musical on Disney+ back in July 2020. The musical was
simply amazing. I felt like I had been missing this in my life for a very
long time.
The title of this blog is a line from one of the songs in the play. The line
struck me at my core in a way I was not quite prepared for at the time. I write
like I am running out of time. The sad reality is that we all have limited time.
Alexander Hamilton wrote 51 articles in the Federalist Papers before he died
after a duel in his late 40s. His wife Eliza lived until she was 97 years old,
and worked for 50 years to raise awareness of all that Hamilton had done.
Hamilton ran out of time, but his writing and legacy lives on, due in large part
to the efforts of his wife.
Over the years, I have tried my best to inspire and motivate others to share
their stories through writing. Linked below are some of the blogging accounts I
follow on Medium and elsewhere. Some of these folks I have worked with or
co-presented with. I have done my best to set a good example by writing and have
encouraged many of them to blog over the years. I hope to see them all continue
to make writing a regular part of their life.
When they write, I read. I share their writings with others so we all can learn.
Enjoy!
BLOGS
* C. V. Guntur
* Vladimir Zakharov - Medium
* Blog Feed - Graciano.dev
* Nikhil Nanivadekar - Medium
* Craig Motlin - Medium
* Sirisha Pratha - Medium
* Emilie Robichaud - Medium
* Aqsa Malik - Medium
* Alex Goldberg - Medium
* Robin Zheng - Medium
* Blog
* Mala Gupta - Author | The JetBrains Blog
* Bhavana | Substack
* Helen Scott - Medium
* Blog - Trisha Gee
* Neha Sardana - Medium
* BrianVermeer.nl
* Java
* @cowtowncoder - Medium
* Mary Grygleski - DEV Community Profile
* JVM Anatomy Quarks
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at December 11, 2023 12:39 AM
Jonas, Maximilian and Philip
COLLABORATIVE, TESTABLE AND ACCESSIBLE DIAGRAMS WITH ECLIPSE GLSP
by Jonas, Maximilian & Philip at December 11, 2023 12:00 AM
Modern web-based diagram editors are not only about shapes and edges;
they’re about creating an interactive, collaborative environment that
elevates user experience and productivity. With...
The post Collaborative, Testable and Accessible diagrams with Eclipse GLSP
appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 11, 2023 12:00 AM
DECEMBER 06, 2023
Webtools News
WTP 3.32 RELEASED!
December 06, 2023 11:59 PM
The Eclipse Web Tools Platform 3.32 has been released! Installation and updates
can be performed using the Eclipse IDE 2023-12 Update Site or through any of the
related Eclipse Marketplace . Release 3.32 is included in the 2023-12 Eclipse
IDE for Enterprise Java and Web Developers , with selected portions also
included in several other packages . Adopters can download the R3.32 p2
repository directly and combine it with the necessary dependencies, as well as
check the New Help for Old Friends document as a high number of bundles have
updated their BREEs in this release, in part due to a large amount of third
party bundles seeing their own updates.
More news
--------------------------------------------------------------------------------
December 06, 2023 11:59 PM
DECEMBER 05, 2023
Eclipse Announcements
THE ECLIPSE FOUNDATION LAUNCHES THE ECLIPSE DATASPACE WORKING GROUP TO FOSTER
GLOBAL INNOVATION IN TRUSTED DATA SHARING
by Jacob Harris at December 05, 2023 12:00 PM
The Eclipse Foundation Launches the Eclipse Dataspace Working Group to Foster
Global Innovation in Trusted Data Sharing Jacob Harris Tue, 2023-12-05 07:00
BRUSSELS – December 5, 2023 – The Eclipse Foundation, one of the world’s largest
open source software foundations, today announced the formation of the Eclipse
Dataspace Working Group (WG). This new working group is tasked with fostering
new dataspaces based on open source technologies via the seamless exchange of
data between private companies, governments, academia, and other institutions to
create an ecosystem for technology innovation that spans the European Union (EU)
and beyond. Dataspaces are federated networks of trusted connections for sharing
data to foster information sharing for mutual benefit. They are a critical
element in the EU’s strategy for creating a culture of innovation built on
privacy and data sovereignty values.
To achieve this goal, the Eclipse Dataspace Working Group will provide
governance, guidance, and support for open source solutions that enable the
development of and participation in dataspaces. The working group does not
favour a specific industry or type of organisation. It is fully dedicated to
enabling the global adoption of dataspace technologies to foster the creation
and operation of trusted data-sharing ecosystems.
“Dataspaces support the sharing of federated, sovereign, and trusted data. In
doing so, they enable new business models where multiple players can aggregate
their data for their own benefit and create a trusted means of data exchange
that is decentralised, egalitarian, and secure,” said Mike Milinkovich,
executive director of the Eclipse Foundation. “Open source software is the most
logical means of building this new reality, and the Eclipse Foundation provides
the ideal vendor-neutral ‘code first’ governance model to bring this future to
life.”
The mission of the Eclipse Dataspace WG is to provide a forum for individuals
and organisations to build and promote open source software, specifications, and
collaboration models needed to create scalable, industry-ready components based
on open standards for dataspaces. Founding members of the working group include
a diverse set of organisations from both the public and private spheres,
including Amadeus, Fraunhofer, IDSA, iShare, Microsoft, and T-Systems. The
Eclipse Dataspace WG will focus on participating in standards development,
implementation, and onboarding of existing open source projects, and guiding
associated projects in alignment with the overarching goal of supporting a broad
ecosystem of interoperable dataspaces.
To this end, the working group aims to foster a component-driven model that
supports project collections in three distinct groups:
* Dataspace Core & Protocols (DCP): DCP focuses on the core protocol
specifications and their standardisation. It also provides alignment between
the protocol specifications and OSS projects implementing mandatory dataspace
functionality.
* Dataspace Data Planes & Components (DDPC): DDPC focuses on alignment between
projects that implement data plans, which are essential components for
dataspaces, as well as additional optional elements that enable advanced
dataspace scenarios. These include projects that are not essential to create
a viable dataspace but add capabilities that increase the business value of
dataspaces.
* Dataspace Authority & Management (DAM): DAM focuses on the alignment of tools
and workflows to enable the implementation of dataspaces. Its associated
projects will support Dataspace Authorities to manage their dataspaces. This
includes policy management, member management, and starter kits for dataspace
authorities.
Overall, the three endeavours aim to create an ecosystem of projects covering
diverse aspects of dataspace solutions. Implementations are non-exclusive, and
overlapping projects can exist. Protocols will be the unifying aspect between
projects, providing minimum viable interoperability.
“By nurturing implementations and specifications, we aim to elevate dataspaces
as a vital component in future data-driven businesses. Alongside projects like
Eclipse Cross Federation Services Components, Asset Administration Shell
initiatives, and Tractus-X, the Catena-X reference implementation, we've
established a unique ecosystem for Digital Sovereignty under the well-proven
governance model of the Eclipse Foundation,” said Michael Plagge, VP, Ecosystem
Development at the Eclipse Foundation.
The Eclipse Dataspaces WG will also collaborate with existing organisations
involved with dataspaces, including the International Data Spaces Association
(IDSA), iSHARE Foundation (iSHARE) and Catena-X, among others. Together with the
Eclipse Dataspaces WG, these organisations will support one another in a host of
ventures, including the formation of new dataspaces initiatives, the creation of
Technical Compatibility Kits, and driving consensus around product roadmaps and
new capabilities.
For any organisation, including enterprises, technology vendors, cloud
providers, academic departments, or government organisations, the Eclipse
Dataspaces WG is a unique opportunity to help shape the future of technology
development in the EU. Membership in the working group not only supports the
sustainability of the community but also provides avenues for participating in
marketing initiatives and direct engagement with a diverse array of EU
organisations building new technology. Discover the numerous benefits and
advantages of membership here. Your involvement can help drive the future of
dataspaces around the world.
Quotes from Eclipse Dataspaces Working Group Member Organizations
Amadeus
“Dataspaces have the potential to create new dynamics and foster innovation in
many domains and could really be game changers to help connect ecosystems across
the tourism industry,” says Nikolaus Samberger, Senior Vice-President
Engineering at Amadeus. “As a strategic member of the Eclipse Dataspace Working
Group, we at Amadeus, are very excited to be launching this collaborative
initiative that will no doubt play a key role in the global dataspace
ecosystem.”
Fraunhofer
“For the success of dataspaces, it is required to bring together various
stakeholders from different countries, domains, sizes, and interests and provide
a neutral place for dialog and collaboration to formulate the joint vision of
data sharing,” said Prof. Dr.-Ing Boris Otto, Director, Fraunhofer ISST
(Fraunhofer Institute for Software and Systems Engineering). “With the launch of
the Eclipse Dataspace Working Group, we now also provide such a place to jointly
transfer the vision into technical specification and technologies. Within the
EDWG, we can leverage the mutual benefits of open source and the best practices
of the Eclipse Foundation.”
IDSA
“Data spaces have reached a level of maturity and adoption which requires a
strong governance framework to build business-relevant services that allow data
sharing while maintaining data sovereignty,” said Sebastian Steinbuss, CTO at
IDSA. “We are happy to be part of the Eclipse Foundation community in the
Dataspace Working Group, to expand the community of data space enthusiasts in
the field of Open Source Software.”
iSHARE Foundation
“Data Sovereignty for all has been the commitment and focus of iSHARE since its
start in 2015. This is realised through the comprehensive and stable triangle of
legal coverage, participant governance, and technical components. This enables
Data Owners to maintain full (legal and technical) control of their data with
any service provider or connector,” said Gerard van der Hoeven, Executive
Director of the iSHARE Foundation. “Through open-source components for
Participant Governance, a consent and authorization registry controlled by Data
Owners, and Data Service providers, data spaces based on iSHARE Trust Framework
have empowered thousands of businesses to control access to and usage of their
data.”
“This step to bring the existing open-source technical components for data space
governance into the EDSWG is important because it strengthens the collaboration
with the open-source communities, with peers like IDSA and Gaia-X, and
simplifies the creation of new commercial services, opening more data sources to
be governed. But most of all, it enables many more data spaces to take advantage
of the fully distributed and interoperable data sovereignty and trust that the
non-profit iSHARE framework brings.”
Microsoft
“We believe dataspaces are a crucial enabler of trusted data sharing across
every company, large or small, in every industry,” said Ulrich Homann, Corporate
Vice President & Distinguished Architect, Microsoft. “We have the responsibility
to come together to support open source software and the associated open
specifications that enable autonomy and agency of participants in a dataspace.”
T-Systems
“We’re thrilled to be part of Eclipse Dataspace Working Group,” said Christoph
Gerkum, vice president, Data Intelligence for Dataspace & Data Products,
T-Systems International GmbH. “As dataspaces pioneers, Telekom Data Intelligence
Hub has shaped the ecosystem with projects like EuroDaT, GAIA-X Future Mobility,
and Catena-X. Over +5 years, we’ve dedicated ourselves to open source
technologies, community adaptation, and building trust in dataspaces. This
collaboration propels us into the future, simplifying dataspaces participation
and elevating our collaboration to new heights. We won’t stop until everything
is connected and interoperable.”
About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and
organisations with a business-friendly environment for open source software
collaboration and innovation. We host the Eclipse IDE, Adoptium, Software
Defined Vehicle, Jakarta EE, and over 425 open source projects, including
runtimes, tools, specifications, and frameworks for cloud and edge applications,
IoT, AI, automotive, systems engineering, open processor designs, and many
others. Headquartered in Brussels, Belgium, the Eclipse Foundation is an
international non-profit association supported by over 350 members. To learn
more, follow us on social media @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 (Germany)
Gloria Huppert, Franziska Wenzl
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 - 70 / - 58
Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
514 Media Ltd for the Eclipse Foundation, AISBL (France, Italy, Spain)
Benoit Simoneau
benoit@514-media.com
M: +44 (0) 7891 920 370
Image
Tags
dataspaces
Dataspaces Gaia-X
--------------------------------------------------------------------------------
by Jacob Harris at December 05, 2023 12:00 PM
Jonas, Maximilian and Philip
ECLIPSE THEIA 1.44 RELEASE: NEWS AND NOTEWORTHY
by Jonas, Maximilian & Philip at December 05, 2023 12:00 AM
We are happy to announce the Eclipse Theia 1.44 release! The release contains 37
merged pull requests and we welcome three new contributors. In this article we
will highlight some selected...
The post Eclipse Theia 1.44 Release: News and Noteworthy appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 05, 2023 12:00 AM
DECEMBER 04, 2023
Sharon Corbett
STARTING YOUR COLLABORATION JOURNEY AT THE ECLIPSE FOUNDATION
by Sharon Corbett at December 04, 2023 06:38 PM
Starting Your Collaboration Journey at the Eclipse Foundation
Whether you intend on contributing to Eclipse technologies that are important to
your product strategy, or simply want to explore a specific innovation area with
like-minded organisations, the Eclipse Foundation is the open source home for
industry collaboration.
But how do you get started? The first step is to identify your goals and areas
of interest. Which Eclipse technologies does your organisation find valuable?
What kinds of organisations are you looking to collaborate with?
After answering these questions, you can determine the scope of your intended
collaboration. Once you’ve decided which of our two collaboration models is
right for you, it’s time to explore your options. The Eclipse Foundation hosts
19 working groups and 3 interest groups focused on runtimes, tools, and
frameworks for cloud and edge applications, IoT, AI, automotive, and beyond.
Members are encouraged to explore our current showcase and see which existing
collaborations align with their goals.
All Eclipse Foundation members are eligible to participate in industry
collaborations. To contact us about joining a working group, you can complete
the membership form on the website of your working group of interest, or the
general Eclipse Foundation membership form. From there, our membership team will
guide you through the process.
For interest groups, the process is simpler. Members can simply announce their
intention to join on the interest group’s mailing list.
STARTING YOUR OWN COLLABORATION
To begin the process of establishing a working group, you first need to contact
our business development team to determine the feasibility of establishing a
formal working group. Upon determination, the Eclipse Foundation will work with
the lead organisation(s) to define the working group's vision and scope,
formalise agreements, and identify potential members. A key outcome of this
stage is the draft Working Group Charter, a framework outlining the vision,
scope, technical roadmap, and leadership structure of the working group.
All five stages of the working group lifecycle are visualised below:
To learn more about the different stages of creating a new working group, review
the Eclipse Foundation Working Group Process.
To create a new interest group, existing members can submit a proposal on our
website. If your organisation is not already a member, you must first join the
Eclipse Foundation, and then follow the Eclipse Foundation Interest Group
Process. There must be at least three member organisations participating, and
members must designate at least one interest group lead. Unlike formal working
groups, no additional fees are required to participate.
Once your collaboration is underway, you’ll be able to benefit from the
vendor-neutral governance and collaboration management provided by the Eclipse
Foundation. Visit eclipse.org/collaborations to learn more about starting your
collaboration journey.
Sharon Corbett Mon, 2023-12-04 13:38
--------------------------------------------------------------------------------
by Sharon Corbett at December 04, 2023 06:38 PM
Jonas, Maximilian and Philip
DISCOVER THE REAL-WORLD POWER OF OPEN SOURCE AND COLLABORATION
by Jonas, Maximilian & Philip at December 04, 2023 12:00 AM
Open source and collaboration are buzzwords in every industry, but what does it
mean in the real world? Who are the people behind these projects, and how are
they funded? What motivates stakeholders...
The post Discover the Real-World Power of Open Source and Collaboration appeared
first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at December 04, 2023 12:00 AM
DECEMBER 01, 2023
Donald Raab
INFECTIOUS ENTHUSIASM
by Donald Raab at December 01, 2023 03:54 PM
Smiles change the world.
Photo by Spencer Davis on Unsplash
I was once told by a partner at a large financial services institution that I
have “infectious enthusiasm.”
When I first heard this, I was confused. I thought it might have been a
compliment, but also thought maybe it was feedback that I suffered from some
incurable disease.
Years later, I’m pretty sure I know what it means. It is both. The more time you
spend interacting with me (virtually or in person), the more likely the
possibility you will wind up discovering, learning, and doing something that may
have never occurred to you before. Many people are immune to my brand of
enthusiasm, while others develop extreme symptoms.
Here are a list of symptoms that you may exhibit over time, the longer you
interact with me.
✅ You have an Eclipse Collections sticker on your laptop
✅ You have started to learn Java
✅ You have learned how to use lambdas in Java
✅ You have started to learn Eclipse Collections
✅ You have read some Smalltalk code
✅ You know who Alan Kay is
✅ You have read one of my Medium blogs
✅ You have followed me on social media
✅ You have attended a Java User Group Meetup
✅ You have completed an Eclipse Collections Kata
✅ You use Eclipse Collections in one of your projects
✅ You have developed a Method Reference preference
✅ You have written your first blog
✅ You have attended your first technical conference
✅ You have taught your first code kata
✅ You have started contributing to open source
✅ You are blogging and posting on social media regularly
✅ You have presented at a technical conference
✅ You have developed your own brand of “infectious enthusiasm”
✅ You have given an Eclipse Collections sticker back to me
✅ You have sung your first song at a karaoke outing
See how many of these symptoms you exhibit over time. If you’re reading this
blog, you’re already developing at least one.
Over the past two decades, I have accumulated stories of developers I have
inspired and influenced in some way. Some of these folks have gone on to do some
great things and have developed their own brands of infectious enthusiasm. Many
developers have left a lasting impression on me, even if it was only through a
single authentic conversation. Every bit of feedback I receive on my journey
goes a long way to keeping me motivated, energized, and on a path of continuous
improvement.
A decade ago, I learned an important lesson from a developer I barely knew. The
experience was truly humbling and inspiring for me. The developer dropped by my
office one evening and said, “Don, I wanted to let you know you are my hero.”
This was a first for me. I have many heroes. I‘ve never thought of myself as
someone else’s hero. I sat there in my office chair blushing, not really knowing
how to respond. After a few seconds, I gained enough composure to say something
like “Take my printer, please.” This was a response I had learned from a former
manager who would say this to express gratitude anytime someone would compliment
him. We both laughed. The developer thanked me for all that I did to make
contributing to open source a possibility at the large financial services
institution we both worked for at the time. Then he went back to his desk and
continued coding. This interaction helped me understand how important it is to
tell others in the most authentic way possible the positive impact they are
having. This developer inspired me more than he may realize. This memory
continues to be a source of inspiration and positive energy for me a
decade later.
I hope to inspire and motivate developers to continually improve their craft and
do things they would have previously thought were beyond their capabilities.
These are some of the habits I try to pass on to other developers.
* Follow a path of continuous learning
* Socialize their work and share what they learn
* Write high quality code and tests
* Teach others to learn
* Grow communities of excellence
* Contribute to open source
* Build their brand through blogs and talks
* Inspire and motivate others
* Celebrate wins, no matter how small
In closing, I want to extend my deepest gratitude to folks in DevRel roles and
all the people that selflessly share their knowledge for the best of the
community. We need your infectious enthusiasm to help improve our craft. Many of
you have inspired me and motivated me with your seemingly endless energy and
talent. Your infectious enthusiasm has rubbed off on me, and I will continue to
make sure I pay it forward with as many folks as I can.
Thank you!
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at December 01, 2023 03:54 PM
NOVEMBER 30, 2023
Jonas, Maximilian and Philip
CDT CLOUD BLUEPRINT: MEMORY INSPECTOR
by Jonas, Maximilian & Philip at November 30, 2023 12:00 AM
When it comes to C/C++ development, especially in the world of embedded
development, in-depth memory analysis is often key to efficient and effective
programming. CDT Cloud Blueprint, an open and...
The post CDT Cloud Blueprint: Memory Inspector appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at November 30, 2023 12:00 AM
NOVEMBER 29, 2023
Eclipse Announcements
ECLIPSE MOSQUITTO SECURITY AUDIT HAS BEEN COMPLETED
by Jacob Harris at November 29, 2023 02:04 PM
Eclipse Mosquitto Security Audit Has Been Completed Jacob Harris Wed, 2023-11-29
09:04
We’re excited to announce that the Eclipse Foundation has successfully conducted
a security audit for Eclipse Mosquitto, marking our fourth project audit this
year.
URL
https://blogs.eclipse.org/post/mika%C3%ABl-barbero/eclipse-mosquitto-security-a…
--------------------------------------------------------------------------------
by Jacob Harris at November 29, 2023 02:04 PM
NOVEMBER 28, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS CONTRIBUTOR AWARD:TOBIAS ORTMAYR FOR IMPROVING THE
PERFORMANCE OF THEIA
by John Kellerman at November 28, 2023 09:07 PM
Eclipse Cloud DevTools Contributor Award:Tobias Ortmayr for improving the
performance of Theia
The Eclipse Cloud Developer Tools contributor award for December goes to Tobias
Ortmayr at EclipseSource for his outstanding and transformative contributions to
improving the performance of Eclipse Theia.
Tobias Ortmayr continues to exemplify exceptional proficiency and commitment in
his instrumental work on Eclipse Theia. His work on significant performance
enhancements is remarkable for its immediate effects. However, it also enables
observability of the ongoing
progress:. https://eclipse-theia.github.io/theia-e2e-test-suite/performance/
(see also screenshot below). This work and progress resonates and is appreciated
by the Eclipse Theia community.
Furthermore, Tobias, along with Philip Langer, has led community discussions on
performance, bringing four different vendors to address this critical issue:
STMicroelectronics, Ericsson, EclipseSource, and Typefox. See also Matthew
Khouzam’s talk at TheiaCon about “Theia Observability and Lessons Learned for
your App” for more details.
A notable achievement under Tobias's leadership is the optimization of the
frontend-backend communication by a factor of 30 and the reduction of start-up
times for Theia-based IDEs by an impressive 60%. In a cloud-centric design like
Theia, even marginal reductions in docker spin-up times and communication
improvements, when scaled over thousands of instances, translate into
substantial savings in developer time. In the words of Will Rogers, "you never
get a second chance to make a first impression." In this vein, Tobias has not
only enhanced the initial experience of Theia, but continues to refine it
persistently.
For these reasons and more, we congratulate Tobias Ortmayr. His contributions
have significantly improved the performance of Eclipse Theia and, equally as
important, enable transparency and continued progress. Well done Tobias!
This Eclipse Cloud DevTools contributor award is sponsored by the Eclipse Cloud
DevTools Working Group. The working group provides a vendor-neutral ecosystem of
open source projects focused on defining, implementing and promoting
best-in-class web and cloud-based development tools. It is hosted at the Eclipse
Foundation, current members of the group
include AMD, Arm, EclipseSource, Ericsson, Obeo, RedHat, Renesas, STMicroelectronics
and TypeFox.
John Kellerman Tue, 2023-11-28 16:07
--------------------------------------------------------------------------------
by John Kellerman at November 28, 2023 09:07 PM
Mikael Barbero
ECLIPSE MOSQUITTO SECURITY AUDIT HAS BEEN COMPLETED
November 28, 2023 02:00 PM
We’re excited to announce that the Eclipse Foundation has successfully conducted
a security audit for Eclipse Mosquitto, marking our fourth project audit this
year. To enhance security, all Mosquitto users are urged to upgrade to the
latest available version. All issues identified by the audit have been fixed in
the source code.
An Eclipse IoT project, Eclipse Mosquitto provides a lightweight server
implementation of the MQTT protocol that is suitable for all situations, from
powerful servers to embedded and low power machines. Highly portable and
compatible with numerous platforms, Mosquitto is a popular choice for embedded
products.
Threat Model
Since the MQTT network could potentially be accessible to attackers, correct
handling of messages in a broker and correct cryptographic operations are
important to the security of the entire network.
The audit revealed a few issues in the password implementation and Dynamic
Security plugin. This shows that independent review can be useful for all
projects, even mature ones.
Full Report
This open source project security audit was completed by Trail of Bits, an
independent auditor. Like our previous three audits, this initiative was done in
collaboration with the Open Source Technology Improvement Fund (OSTIF) and was
made possible thanks to the funding the Foundation received from the Alpha-Omega
Project.
GET INVOLVED
* Download Eclipse Mosquitto, learn how you can contribute to the project, and
review their security page.
* Learn more about the Eclipse Cyber Risk Initiative, and how your organization
can join the effort to strengthen the open source supply chain. Please
subscribe to the ECRI mailing list to join the initiative, or to follow its
progress.
--------------------------------------------------------------------------------
November 28, 2023 02:00 PM
NOVEMBER 27, 2023
Donald Raab
DON’T MAKE ME SCROLL
by Donald Raab at November 27, 2023 04:17 PM
I want to read your code… not travel through it.
Photo by Taylor Flowe on Unsplash
I want code for a single Java method to fit on one screen. I do not want to
scroll vertically or horizontally when I am looking at a single method. Making
me scroll is an opportunity for me to lose focus and context and have to waste
time scrolling back and forth. I use big fonts on my laptop. I can switch to
smaller fonts but it’s harder on my eyes.
My metric for a good Java method is less than ten Java statements, and less than
thirty lines of text with method signature and curly braces included. Code
should not have to scroll horizontally to achieve this. Horizontal scrolling is
much worse than vertical scrolling. Nested generics in Java can be challenging.
Maybe add missing types to simplify generics. Requiring scrolling in both
directions will slow comprehension down.
Thank you for reading this brief message, and for not making me scroll.
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
--------------------------------------------------------------------------------
by Donald Raab at November 27, 2023 04:17 PM
Donald Raab
ZOMBIELAND IMPLEMENTATION PATTERN: DOUBLE TAP
by Donald Raab at November 27, 2023 02:45 AM
Photo by julien Tromeur on Unsplash
Have you seen the movie Zombieland? There are rules for surviving in Zombieland.
Rule number two is called Double Tap. When a zombie is attacking you, don’t
get stingy with bullets. Shoot twice!
I’ve seen the Double Tap pattern used occasionally with Eclipse Collections
over the years. Here’s one example of a Double Tap.
@Test
public void doubleTapLazy()
{
ImmutableList<String> list =
Lists.immutable.with("One", "Two", "Three");
list.asLazy()
.tap(System.out::println)
.collect(String::toLowerCase)
.tap(System.out::println)
.collect(String::toUpperCase)
.forEach(System.out::println);
}
In this code, I iterate lazily over a an ImmutableList of String and use tap
twice. I use tap to print out each element, and then again to print each element
after it is converted to lowercase. I use the tap method twice to see the before
and after transformation state in the pipeline. Double Tap! Then I use forEach
to print out the element converted to uppercase.
The output for this code is as follows:
One
one
ONE
Two
two
TWO
Three
three
THREE
The lazy tap method is very useful if you want to log or perform some operation
with intermediate results over a series of fluent calls. The method tap on
LazyIterable is equivalent to the method peek on Java Stream.
Now I will change this code to iterate eagerly by removing the call to asLazy.
@Test
public void doubleTapEager()
{
ImmutableList<String> list =
Lists.immutable.with("One", "Two", "Three");
list.tap(System.out::println)
.collect(String::toLowerCase)
.tap(System.out::println)
.collect(String::toUpperCase)
.forEach(System.out::println);
}
The output for this code is as follows:
One
Two
Three
one
two
three
ONE
TWO
THREE
The output still contains the same number of elements, but the order of
execution is different.
The method named tap defined on the RichIterable interface behaves like forEach
when executed eagerly on a collection like ImmutableList. The tap method has
overrides with Covariant Return Types throughout the Eclipse Collections
hierarchy returning the most specific types possible. This is why when I removed
the call to asLazy, the first call to tap prints out all of the original
elements in the list. The second call to tap prints all of the elements
converted to lowercase. Then the call to forEach prints each element converted
to uppercase with a new line after.
I include an example of a Triple Tap in the following blog when comparing Eager
vs. Lazy to help folks understand the differences between the two iteration
styles.
The 4 am Jamestown-Scotland ferry and other optimization strategies
I hope this blog and the Double Tap analogy helps you understand and remember
the tap method in Eclipse Collections. Perhaps it will prove useful the next
time you need to accomplish something in an intermediate series of
fluent calls.
Thanks for reading!
I am the creator of and committer for the Eclipse Collections OSS project, which
is managed at the Eclipse Foundation. Eclipse Collections is open for
contributions.
STACKADEMIC
Thank you for reading until the end. Before you go:
* Please consider clapping and following the writer! �
* Follow us on Twitter(X), LinkedIn, and YouTube.
* Visit Stackademic.com to find out more about how we are democratizing free
programming education around the world.
--------------------------------------------------------------------------------
Zombieland Implementation Pattern: Double Tap was originally published in
Stackademic on Medium, where people are continuing the conversation by
highlighting and responding to this story.
--------------------------------------------------------------------------------
by Donald Raab at November 27, 2023 02:45 AM
Jonas, Maximilian and Philip
WEB-BASED TOOLS AND IDES: ACCOMPLISHMENTS AND OPPORTUNITIES
by Jonas, Maximilian & Philip at November 27, 2023 12:00 AM
The landscape of tool creation projects has been significantly reshaped by the
advent and rise of web-based tools and integrated development environments
(IDEs). This field, though relatively new, has...
The post Web-based Tools and IDEs: Accomplishments and Opportunities appeared
first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at November 27, 2023 12:00 AM
NOVEMBER 22, 2023
Jonas, Maximilian and Philip
HOW TO GET VISIBLE AS A THEIA ADOPTER AND CONTRIBUTOR
by Jonas, Maximilian & Philip at November 22, 2023 12:00 AM
In the rapidly evolving landscape of technology, visibility and collaboration
are key drivers of success. For companies leveraging Eclipse Theia, the
open-source cloud & desktop IDE platform,...
The post How to get visible as a Theia adopter and contributor appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at November 22, 2023 12:00 AM
NOVEMBER 21, 2023
Eclipse Announcements
INTRODUCING ECLIPSE THREADX
by Jacob Harris at November 21, 2023 05:28 PM
Introducing Eclipse ThreadX Jacob Harris Tue, 2023-11-21 12:28
Eclipse Foundation executive director Mike Milinkovich explores why Eclipse
ThreadX is exactly what the embedded real-time software market needs, and shares
what’s next for the project in his new blog.
URL
https://blogs.eclipse.org/post/mike-milinkovich/introducing-eclipse-threadx
Tags
open source
--------------------------------------------------------------------------------
by Jacob Harris at November 21, 2023 05:28 PM
Mike Milinkovich
INTRODUCING ECLIPSE THREADX
by Mike Milinkovich at November 21, 2023 04:00 PM
TL;DR – GET ENGAGED!
* Contact us to learn how to become part of the Eclipse ThreadX Interest Group
* Contribute to the project and join the ThreadX developer mailing list
* Stay connected by joining the general ThreadX mailing list
* Watch for updates at threadx.io
WHAT WE’RE ANNOUNCING
Every once in a while, a new open source initiative comes along which is truly
an industry changing event. Today, Microsoft announced that Azure RTOS,
including all of its components, is going to be made available as the Eclipse
ThreadX open source project. This new project is exactly what the highly
fragmented embedded software market has needed for a very long time. ThreadX is
going to be the world’s first open source real time operating system which is:
1. Mature and scalable technology. ThreadX has been developed for over 20
years, is currently running on over 12 billion devices around the world, and
is highly regarded as a high-performance, highly deterministic, real time
operating system.
2. Made available under a permissive open source license. ThreadX is going to
be licensed under the MIT license, which provides highly permissive license
terms for users and adopters.
3. Governed under a vendor-neutral open source foundation. ThreadX is going to
be governed by the Eclipse Foundation and its development process. This will
guarantee a vendor-neutral governance model to manage the evolution and
sustainability of ThreadX for the benefit of the entire industry.
AND
4. Certified for functional safety and security. ThreadX is IEC 61508, IEC
62304, ISO 26262, and EN 50128 conformance certified by SGS-TÜV Saar.
ThreadX has also achieved EAL4+ Common Criteria security certification.
These certifications are a big differentiator, and are unprecedented in the
industry. They are a game changer, as there are currently no open source
RTOS’s which have them.
While there are other open source RTOS’s out there, none have all of the four
attributes listed above. We are optimistic that, because of these attributes,
ThreadX is going to rapidly expand its adoption in a wide range of use cases
including aerospace, automotive, IoT, medical, transportation, automation, and
consumer wearables.
NEXT STEPS
In addition to the project, we are also announcing the creation of an interest
group focused on developing an industry-supported, sustainable funding model for
ThreadX. We are excited that AMD, Cypherbridge, Microsoft, NXP, PX5, Renesas, ST
Microelectronics, Silicon Labs, and Witekio (an Avnet company) have all
committed to supporting this conversation. We highly encourage every company
with an interest in embedded technology to join to help create the future.
The ThreadX interest group’s sole focus will be on establishing a working group
focused on the following:
1. Consolidate the project: There is going to be a great deal of focus on
getting ThreadX moved under Eclipse Foundation governance as quickly as
possible. This will involve transferring and re-licensing the code and
documentation, and assigning the trademarks over the next few weeks. In
parallel, we are looking for developers who have experience with the ThreadX
code base to get involved as key resources from Cypherbridge, PX5, and
Witekio have already done. The intent is to have the first release of
ThreadX under Eclipse Foundation governance completed by the end of January
2024.
2. Preserve the certifications: As I mentioned above, the safety and security
certifications are a key differentiator for ThreadX. Maintaining those
certifications while under open source governance is going to be a key
factor in the evolution of ThreadX as an open source project. Fortunately,
the Eclipse Foundation has been thinking about and staffing for this
capability for a long time as our IoT and Software Defined Vehicle
communities have similar requirements. Our intent is to develop best
practices for the ThreadX community and, if required, modify and enhance our
Eclipse Foundation Development Process to support the additional process
requirements necessary to support safety and security. The documentation
which will enable downstream adopters of ThreadX to certify their products
will be made available under open licenses. This will significantly shorten
the lifecycle of safety-certified products based on Eclipse ThreadX.
3. Build the community: ThreadX represents an amazing opportunity to build an
open source embedded software developer community. There will be a great
deal of focus on nurturing new contributions, driving adoption via developer
advocacy, and creating cross-pollination with our other communities within
the Eclipse Foundation such as IoT and SDV, all while preserving the
processes required for the certifications which differentiate ThreadX.
4. Promote the brand: Returning to the original ThreadX name is purposefully
intended to assure the many current adopters of this technology that this is
and will remain the RTOS that they trust for their products. The new mission
will be to associate the ThreadX brand with vendor-neutral governance,
communicate clear market positioning, and establish compatibility programs
that will provide value to current and future adopters.
5. Grow the ecosystem: With over 10 billion devices deployed using ThreadX, it
is clear that this is an important and mature technology. To ensure a
sustainable future for ThreadX we need to obtain the support, participation,
and contributions of all ecosystem participants: silicon/SBC manufacturers,
embedded system integrators, and tool vendors. We highly encourage every
company with an interest in embedded technology to join the interest group
to help define and secure the future of ThreadX.
Eclipse ThreadX presents the industry with a game-changing opportunity. Having a
performant, mature, safety and security certified, permissively-licensed, open
source RTOS under vendor-neutral governance will enable new business and product
opportunities around the world. We are very excited to work with the community
to make ThreadX a huge success.
--------------------------------------------------------------------------------
by Mike Milinkovich at November 21, 2023 04:00 PM
NOVEMBER 17, 2023
Jonas, Maximilian and Philip
CDT CLOUD BLUEPRINT: DETACHING VIEWS
by Jonas, Maximilian & Philip at November 17, 2023 12:00 AM
Looking for a modern, web-based IDE for C/C++ development or aiming to develop a
custom C/C++ tool? Dive in! In this article we will demonstrate advanced
workbench layouting capabilities of CDT Cloud...
The post CDT Cloud Blueprint: Detaching Views appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at November 17, 2023 12:00 AM
NOVEMBER 10, 2023
Marc Nuri
ECLIPSE JKUBE 1.15 IS NOW AVAILABLE!
November 10, 2023 04:00 PM
Original post
On behalf of the Eclipse JKube team and everyone who has contributed, I'm happy
to announce that Eclipse JKube 1.15.0 has been released and is now available
from Maven Central �.
Thanks to all of you who have contributed with issue reports, pull requests,
feedback, and spreading the word with blogs, videos, comments, and so on. We
really appreciate your help, keep it up!
WHAT'S NEW?
Without further ado, let's have a look at the most significant updates:
* Support for Spring Boot 3 native image
* Helm values.yaml fragments
* Updated base images
* � Many other bug-fixes and minor improvements
SUPPORT FOR SPRING BOOT 3 NATIVE IMAGE
Starting with this release, JKube automatically detects Spring Boot 3 native
image build artifacts and generates a suitable container image. This feature is
available for both Maven and Gradle builds.
If you're using Gradle, it will be as simple as running the following commands:
gradle nativeCompile
gradle k8sBuild
Or in case of Maven:
mvn -Pnative native:compile
mvn k8s:build
HELM VALUES.YAML FRAGMENTS
You can now provide a values.helm.yaml file in the src/main/jkube directory.
JKube will automatically merge the contents of this file with the generated
values.yaml file during the Helm chart generation. The fields from the fragment
will be merged with those that can be provided as parameters in the build.gradle
or pom.xml plugin configuration section.
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.15.0</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.15.0'
}
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
--------------------------------------------------------------------------------
November 10, 2023 04:00 PM
NOVEMBER 08, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS CONTRIBUTOR AWARD: DOMINIK BORK FOR BRIDGING ACADEMIA,
OPEN SOURCE, AND INDUSTRY
by John Kellerman at November 08, 2023 04:24 PM
Eclipse Cloud DevTools Contributor Award: Dominik Bork for bridging academia,
open source, and industry
The Eclipse Cloud Developer Tools contributor award for this month is proudly
presented to Dr. Dominik Bork, Assistant Professor for Business Systems
Engineering at TU Wien, in recognition of his remarkable dedication and
innovative contributions to the Eclipse Cloud DevTools technologies.
Dominik has been instrumental in the Cloud DevTools community for bridging
academia, open-source software and industry. His commitment ensures that the
innovative work from research projects and student theses doesn't just end with
an excellent publication, but evolves into valuable contributions to open-source
projects, such as those within the Eclipse Cloud DevTools ecosystem. It's his
forward-thinking approach that enables research results to have a lasting impact
and utility beyond the academic sphere, allowing open-source projects and their
industrial adopters to benefit from novel research results.
Examples of Dominik’s efforts:
* His guidance of students in developing innovative extensions to Eclipse Cloud
DevTools technologies, particularly for Eclipse GLSP and EMF.cloud, has led
to important improvements, such as enhanced accessibility for more
inclusive diagram editing with GLSP, real-time collaborative modeling via VS
Code Live Share, and a robust end-to-end testing framework for GLSP diagram
editors.
* With the inception and development of bigUML (see screenshot below) and an ER
modeling tool for VS Code, he is rethinking the concepts of modeling tools
based on Eclipse Cloud DevTools technologies, and feeds the lessons learned
from development back to the open-source community.
* He is playing a pivotal role in incorporating Eclipse Cloud DevTools
technologies into his academic curriculum and research publications,
significantly contributing to their adoption and enhancement.
BigUML based on Eclipse Theia and GLSP
For these reasons and many more, we extend our heartfelt congratulations to Dr.
Dominik Bork. Your contributions significantly enhance the Eclipse Cloud
DevTools landscape, and we are grateful for your passionate involvement.
This Eclipse Cloud DevTools contributor award is sponsored by EclipseSource,
providing consulting and implementation services for web-based tools, Eclipse
GLSP, Eclipse Theia, and VS Code.
John Kellerman Wed, 2023-11-08 11:24
--------------------------------------------------------------------------------
by John Kellerman at November 08, 2023 04:24 PM
NOVEMBER 07, 2023
Sharon Corbett
WHICH ECLIPSE FOUNDATION COLLABORATION MODEL IS BEST FOR YOU? THREE QUESTIONS TO
ASK
by Sharon Corbett at November 07, 2023 05:00 PM
Which Eclipse Foundation Collaboration Model Is Best for You? Three Questions to
Ask
The Eclipse Foundation gives members two options for collaborating with industry
peers: interest groups and working groups. If you are unsure about which
collaboration model is right for you and your organisation, here are three key
questions you should consider to help determine your next steps.
DO YOU NEED A VENDOR-NEUTRAL SPACE TO COLLABORATE?
If you’re an Eclipse Foundation member, we can assume the answer is yes. Both
working groups and interest groups enable organisations to collaborate under a
vendor-neutral governance model.
With interest groups, members can come together to share a common interest in a
topic or domain in a vendor-neutral manner based on the Eclipse Foundation’s
overall governance structure, including its intellectual property and antitrust
policies. Unlike working groups, there are no formal participation agreements,
budgets, or committees. The governance structure is informal, with most actions
being taken collegially by participants in the interest group.
ARE YOU PLANNING ON DEVELOPING SPECIFICATIONS?
Interest groups are free to develop resources like documents, white papers,
architectures, blueprints, diagrams and presentations. However, they must not
develop software, software documentation, nor specifications.
That’s why any organisation looking to collaborate with industry peers by
developing specifications would need to move to a formal working group model,
meet the associated criteria and provide the necessary funding to do so.
Specifications are created and maintained by specification projects, and
specification projects need to be aligned with a working group.
ARE YOU INTERESTED IN GROWING YOUR COMMUNITY AND HAVE MORE DEVELOPERS CONTRIBUTE
TO YOUR PROJECTS?
The Eclipse Foundation's ecosystem development and marketing programs promote
community and membership growth, drive awareness and discoverability of projects
and collaborations, and increase the commercial adoption of Eclipse
technologies.
These services, including content development, news and media assistance,
in-person and online event planning, and creative design support, are
exclusively offered to working groups. Since working groups are most effective
when a diverse group of organisations get involved and collaborate, our
ecosystem development and marketing services are available to help grow
awareness and participation in these collaborations and the projects they are
involved in.
To summarise, Eclipse Foundation members can join interest groups to collaborate
across organisational boundaries in a vendor-neutral structure to solve industry
problems and to drive shared innovation. But if your organisation intends on
developing and promoting a new compatibility and trademark brand with industry
peers, developing open source specifications, or contributing resources to join
business cases, then a formal working group would need to be created.
To learn more about our industry collaborations and our current showcase, please
visit eclipse.org/collaborations, and contact us if you are interested in
joining and/or forming a new industry collaboration.
Sharon Corbett Tue, 2023-11-07 12:00
--------------------------------------------------------------------------------
by Sharon Corbett at November 07, 2023 05:00 PM
Clark Roundy
FROM AI TO URBAN TRANSFORMATION: INSIGHTS FROM THE 2023 IOT & EDGE DEVELOPER
SURVEY REPORT
by Clark Roundy at November 07, 2023 03:34 PM
From AI to Urban Transformation: Insights from the 2023 IoT & Edge Developer
Survey Report
The ninth edition of the Eclipse Foundation’s IoT & Edge Developer Survey Report
is a window into the ever-evolving IoT and edge computing landscape, where open
source technologies are playing a pivotal role in solving real-world challenges
across diverse industries. And guess what? The 2023 findings reveal that there
is even more innovation happening than ever before, with development activities
increasing across all sectors when compared to our 2022 survey.
Industrial automation and agriculture are once again the two leading market
segments, but smart buildings and cities are emerging as dark horses in this
race, indicating a groundswell of interest in building automation,
connected/smart cities, energy management, and transportation. The momentum is
undeniable, with a future that holds boundless possibilities for urban
transformation.
One of the standout findings is that artificial intelligence continues to be the
shining star among edge computing workloads. As AI investment grows, this
finding is not surprising. What’s interesting, however, is that control logic
has nudged ahead of AI to become the most common edge workload for IoT solutions
utilizing edge gateways and/or edge nodes. It's a shift that hints at the
nuanced requirements of diverse IoT applications.
This year’s global survey drew insights from over 1000 developers, committers,
architects, and decision-makers across a spectrum of industries. Thank you to
everyone who took the time to participate and contribute to our comprehensive
understanding of the IoT and edge computing landscape. Your input has proven
invaluable.
These findings aren’t just for show. They also unveil fresh opportunities for
businesses in the IoT and edge computing domain. With MQTT emerging as the
preferred IIoT communication protocol for nearly half of the survey
participants, companies might want to give it a closer look.
Moreover, the void created by the exit of several IoT middleware providers in
2022, like Google Cloud IoT Platform, Bosch IoT Suite, IBM Watson IoT, and SAP
Internet of Things, presents a substantial opportunity. While nearly half of the
participants have relied on one of these middleware offerings, only 12% have
migrated to a new one. This underscores the untapped potential for middleware
innovation in the ever-evolving IoT and edge computing space.
This is just a taste of what you will find in the 2023 survey report. We
encourage you to dive deeper into the insights and recommendations we’ve shared.
For a complete spectrum of our findings and insightful recommendations, we
invite you to download the complete 2023 IoT & Edge Developer Survey Report.
To connect with the vibrant Eclipse IoT community and stay updated on the latest
developments in the world of IoT and edge computing, be sure to
visit iot.eclipse.org.
Thank you for joining us in this journey of discovery and innovation. The future
of IoT and edge computing holds immense promise, and together, we're shaping it.
Download the report and stay connected – the adventure continues.
Clark Roundy Tue, 2023-11-07 10:34
--------------------------------------------------------------------------------
by Clark Roundy at November 07, 2023 03:34 PM
Eclipse Announcements
THE ECLIPSE FOUNDATION RELEASES 2023 IOT & EDGE DEVELOPER SURVEY RESULTS
by Jacob Harris at November 07, 2023 10:50 AM
The Eclipse Foundation Releases 2023 IoT & Edge Developer Survey Results Jacob
Harris Tue, 2023-11-07 05:50
BRUSSELS – November 7, 2023 – The Eclipse Foundation, one of the world’s largest
open source software foundations, today announced results from its 2023 IoT &
Edge Developer Survey. Administered by the Eclipse IoT Working Group and the
Eclipse Sparkplug Working Group, the survey provides essential insights into IoT
and edge computing industry landscapes, challenges developers face, and the
opportunities for enterprise stakeholders in the IoT & edge open source
ecosystem. Now in its ninth year, the survey is the IoT & edge industry’s
leading technical survey.
“This year’s results yielded some very interesting trends, particularly those
related to real-world use cases and technology choices,” said Mike Milinkovich,
executive director of the Eclipse Foundation. “What’s clear is that developers
are actively building production solutions leveraging open source technologies
to tackle today’s IoT challenges across industrial, agricultural, and municipal
settings.”
The online survey was conducted from April 4, 2023, to July 5, 2023, during
which 1,037 global developers, committers, architects, and decision-makers from
a broad set of industries and organisations participated. Key findings include:
* Development is increasing across all IoT sectors. Industrial automation is
once again the top area of focus (33%, up from 22%), followed by agriculture
(29 %, up from 23%), building automation, energy management, and smart
cities (all at 24%).
* Developers indicate that Java is the preferred language for IoT gateways and
edge nodes, while C, C++, and Java are the most widely used languages for
constrained devices.
* MQTT is the top IIoT communication protocol. Nearly half of developers (49%)
indicate a preference for MQTT for IIoT communications, with MQTT + Sparkplug
checking in at 8%.
* The withdrawal of IoT Middleware providers has created an opportunity for
innovators to enter the market. Google Cloud IoT Platform, Bosch IoT Suite,
IBM Watson IoT, and SAP Internet of Things all exited the market in 2022 or
announced their intent to do so. While nearly half of respondents indicated a
relationship with one or more of these providers, only 12% have migrated to a
new provider.
* Control logic (40%) surpassed artificial intelligence (37%) as the most
common edge computing workload. Does this imply a renewed focus on the
practical aspects of delivering real-world solutions? Only time will tell.
* Software Supply Chain Security has become an essential issue for IoT/edge
developers, with 70% saying it is vital to their work.
* 5G is enabling accelerated IIoT adoption. Cellular adoption has doubled since
2022 (44% vs. 22% in 2022) largely due to 5G penetration, while WiFi (38% vs.
36% in 2022), Ethernet (38% vs 29% in 2022) and Bluetooth (23% vs 20% in
2022) continue to be viable options.
The survey data contains further insights on developer choices for edge
computing workloads, platform connectivity, developer concerns, and use case
breakdowns by market. In addition, the report provides breakdowns of use cases
by market and detailed recommendations on the next steps for IoT developers. The
entire report can be downloaded here.
About Eclipse IoT
Eclipse IoT’s knowledge and expertise span 12+ years of experience in edge
computing, IoT and Industrial IoT. Eclipse IoT is home to open source innovation
that has delivered implementations of 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 part of the Eclipse IoT ecosystem. The Eclipse IoT
toolkit also contains an innovative homegrown protocol built from the ground up
for edge computing: Eclipse Zenoh. In addition to other popular Eclipse IoT
production-ready platforms that cover various use cases such as digital twins
(Eclipse Ditto), contactless payments (Eclipse Keyple), industrial applications
(Eclipse Kura), in addition to Eclipse Kapua — a modular IoT cloud platform that
manages data and devices. Eclipse IoT is also the home of innovative edge
orchestration platforms such as Eclipse ioFog and Eclipse Kanto.
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 visit iot.eclipse.org.
About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and
organisations with a business-friendly environment for open source software
collaboration and innovation. We host the Eclipse IDE, Adoptium, Software
Defined Vehicle, Jakarta EE, and over 425 open source projects, including
runtimes, tools, specifications, and frameworks for cloud and edge applications,
IoT, AI, automotive, systems engineering, open processor designs, and many
others. Headquartered in Brussels, Belgium, the Eclipse Foundation is an
international non-profit association supported by over 350 members. To learn
more, follow us on social media @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 (Germany)
Gloria Huppert, Franziska Wenzl
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 - 70 / - 58
Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
514 Media Ltd for the Eclipse Foundation, AISBL (France, Italy, Spain)
Benoit Simoneau
benoit@514-media.com
M: +44 (0) 7891 920 370
Tags
Edge Computing
IoT
iot developers
--------------------------------------------------------------------------------
by Jacob Harris at November 07, 2023 10:50 AM
Eclipse Announcements
THE ECLIPSE FOUNDATION ANNOUNCES SPARKPLUG AS AN INTERNATIONAL STANDARD FOR A
“PLUG AND PLAY” INDUSTRIAL IOT
by Jacob Harris at November 07, 2023 10:45 AM
The Eclipse Foundation Announces Sparkplug as an International Standard for a
“Plug and Play” Industrial IoT Jacob Harris Tue, 2023-11-07 05:45
BRUSSELS – November 7, 2023 – The Eclipse Foundation, one of the world’s largest
open source software foundations, in collaboration with the Eclipse Sparkplug
Working Group, today announced that the Sparkplug® 3.0 specification has been
published as an International Standard. This publication is the outcome of a
transposition of the specification through the Publicly Available Specification
(PAS) transposition process offered by the ISO and IEC Joint Technical Committee
(JTC 1) for information technology, a consensus-based, voluntary international
standards group.
The International Organization for Standardization and International
Electrotechnical Commission (ISO/IEC) are global organisations that facilitate
the development of International Standards that support innovation,
sustainability, and global trade. Sparkplug® is an open software specification
that enables mission-critical operational technology (OT) clients to use
industry standards, including OASIS MQTT, to seamlessly integrate data from
their applications, sensors, devices, and gateways with most Industrial Internet
Of Things (IIoT) infrastructure. As a result, Sparkplug® enables businesses to
easily deploy complex, mission-critical IIoT systems in record time.
“The publication of Sparkplug® 3.0 as an international standard is significant,
not just for the Sparkplug community, but for any organisation that needs to
digitally transform their business by leveraging IIoT technologies,” said Mike
Milinkovich, executive director for the Eclipse Foundation. “Sparkplug has been
experiencing meteoric growth over the past few years, primarily driven by the
ongoing transition to true IIoT infrastructure across multiple industries. It
provides the key to true, easy integration across the many disparate
technologies that make up this complex OT/IT ecosystem. Sparkplug’s new status
as an international standard will accelerate this adoption while simultaneously
serving as recognition of its immense value to the industry.”
The PAS transposition process for reviewing and approving externally developed
specifications at JTC 1 is neutral to all contributors and includes
industry-wide participation. Going forward, the Sparkplug® specification will
also be known as ISO/IEC 20237. The Eclipse Foundation retains stewardship of
the specification and intends to submit future revisions through the PAS
transposition process.
“JTC 1 appreciates the opportunity to work with The Eclipse Foundation on this
project, and we congratulate the Foundation on the approval of ISO/IEC 20237,”
said Phil Wennblom, JTC 1 Chair. “JTC 1 looks forward to our future
collaboration.”
ISO/IEC International Standards are the global benchmarks for businesses,
manufacturers, vendors, and service providers regarding approved and validated
safety features, quality measures, and interoperability. By becoming an ISO/IEC
standard, a technology is effectively established as a globally recognized
technical ecosystem and benefits from global acceptance of products, accelerated
adoption, and expanded reach.
The Sparkplug® Working Group is simultaneously launching a product compatibility
program for Sparkplug implementers. The program will ensure that
Sparkplug-compatible products and implementations demonstrate a high degree of
compatibility and interoperability.
About Sparkplug® & MQTT
Sparkplug® provides an open and freely available specification for how Edge of
Network (EoN) gateways or native MQTT-enabled end devices and MQTT Applications
communicate bi-directionally within an MQTT Infrastructure. It is recognized
that OASIS MQTT is used across a broad spectrum of application solution use
cases and an almost indefinable variation of network topologies.
By design, the MQTT specification does not dictate a Topic Namespace or any
payload encoding. However, as the IIoT and other architectures leveraging the
publisher/subscriber model are adopted by device OEMs in the industrial sector,
having different Topic Namespace and payload encoding can inhibit
interoperability for the end customer. To that end, the Sparkplug specification
addresses the following components within an MQTT infrastructure:
* Sparkplug® defines an OT-centric Topic Namespace
* Sparkplug® defines an OT-centric Payload definition optimised for industrial
process variables.
* Sparkplug® defines MQTT Session State management required by real-time OT
SCADA systems.
About the Eclipse Foundation
The Eclipse Foundation provides our global community of individuals and
organisations with a business-friendly environment for open source software
collaboration and innovation. We host the Eclipse IDE, Adoptium, Software
Defined Vehicle, Jakarta EE, and over 425 open source projects, including
runtimes, tools, specifications, and frameworks for cloud and edge applications,
IoT, AI, automotive, systems engineering, open processor designs, and many
others. Headquartered in Brussels, Belgium, the Eclipse Foundation is an
international non-profit association supported by over 350 members. To learn
more, follow us on social media @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 (Germany)
Gloria Huppert, Franziska Wenzl
EclipseFoundation@schwartzpr.de
+49 (89) 211 871 - 70 / - 58
Nichols Communications for the Eclipse Foundation, AISBL
Jay Nichols
jay@nicholscomm.com
+1 408-772-1551
514 Media Ltd for the Eclipse Foundation, AISBL (France, Italy, Spain)
Benoit Simoneau
benoit@514-media.com
M: +44 (0) 7891 920 370
Image
Tags
sparkplug
iiot
--------------------------------------------------------------------------------
by Jacob Harris at November 07, 2023 10:45 AM
NOVEMBER 06, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS DIGEST - SEPTEMBER AND OCTOBER 2023
by John Kellerman at November 06, 2023 07:18 PM
Eclipse Cloud DevTools Digest - September and October 2023
THEIACON 2023!
TheiaCon 2023, is right around the corner on November 15-16. We have an
excellent program lined up. If you haven't registered yet, please do so, it's
not too late.Â
SIRIUS AND PAPYRUS
Cedris Brun summarizes a talk he gave at EclipseCon 2023 on the collaboration
between the Eclipse Sirius and Papyrus projects. This includes SysON, an
implementation of a Web-based version of the forthcoming systems engineering
standard ğ�—¦ğ�˜†ğ�˜€ğ�— ğ�—Ÿ ğ�˜ƒğ�Ÿ®.
CONTRIBUTOR AWARDS TO STEFAN DIRIX AND THOMAS MäEDER
The Cloud DevTools working group recognized Stefan Dirix for his work on CDT
Cloud Blueprint and Thomas Mäeder for his many contributions to Theia.
CDT CLOUD BLUEPRINT!
Jonas, Maximilian & Philip, in their blog, highlight the debugging features of
CDT Cloud Blueprint, a modern, Â web-based and extensible all-open-source C/C++
IDE designed for both offline and online scenarios. In a second article, they
explore the online and offline deployment possibilities for CDT Cloud Blueprint.
TESTING WITH THEIA CLOUD
Jonas, Maximilian & Philip, in this article, discuss Theia Cloud, a
Kubernetes-based deployment of Theia, and how it can be used for end to end
testing of your Theia-based application.Â
THEIA OR CODE OSS FOR BUILDING A CUSTOM IDE?
You're looking to build a custom IDE offering; should you build on Code OSS (the
open source base of VS Code) or Eclipse Theia? In this article, Jonas,
Maximilian & Philip provide an extensive look at answering this question.
Spoiler alert: Theia is the better answer.
JKUBE SECURITY AUDIT RESULTS PUBLISHED
Mikaël Barbero, in his blog, provides a summary of the recent security audit of
JKube. This is part of a broader effort by the Eclipse Foundation to assure the
integrity of its open source projects.
THEIA COMMUNITY RELEASE 2023-08
The Eclipse Theia Community Release 2023-08, version 1.40.x, is here! It
includes significant enhancements like detachable view support for Electron
applications, support for multiple extension registries, UI and usability
improvements, and backend bundling for improved startup performance.
RECENT RELEASES
THEIA 1.41
THEIA 1.42
SPROTTY 1.0.0
SIRIUS DESKTOP 7.2.1
CLOUD TOOL TIME WEBINARS
We are now scheduling Cloud Tool Time webinars for 2023. Be sure to Sign up now
to get on the calendar and let us help tell your story. You can see past
sessions on our Youtube channel.
ECLIPSE CLOUD DEVTOOLS PROJECTS
Explore the Eclipse Cloud DevTools ecosystem! Check out our projects page to
find out more about open source innovation for cloud IDEs, extension
marketplaces, frameworks and more.
GETTING LISTED ON THE CLOUD DEVTOOLS BLOG
If you are working with, or on, anything in the Cloud DevTools space, learn how
to get your writings posted in our blog section.
John Kellerman Mon, 2023-11-06 14:18
--------------------------------------------------------------------------------
by John Kellerman at November 06, 2023 07:18 PM
JBoss Tools Team
JBOSS TOOLS 4.29.0.FINAL FOR ECLIPSE 2023-09
by sbouchet at November 06, 2023 02:24 PM
Happy to announce 4.29.0.Final build for Eclipse 2023-09.
Downloads available at JBoss Tools 4.29.0 Final.
WHAT IS NEW?
Full info is at this page. Some highlights are below.
GENERAL
COMPONENTS REMOVAL
As outlined and announced in a prior blog post, the subsequent components have
been excluded from the latest JBoss Tools distribution:
* WebServices
* Batch
HIBERNATE TOOLS
HIBERNATE RUNTIME PROVIDER UPDATES
Multiple additions and updates have been performed on the available Hibernate
runtime providers.
NEW RUNTIME PROVIDER
A new Hibernate 6.3 runtime provider incorporates Hibernate Core version
6.3.1.Final, Hibernate Ant version 6.3.1.Final and Hibernate Tools version
6.3.1.Final.
RUNTIME PROVIDER UPDATES
The Hibernate 6.2 runtime provider now incorporates Hibernate Core version
6.2.13.Final, Hibernate Ant version 6.2.13.Final and Hibernate Tools version
6.2.13.Final.
The Hibernate 5.3 runtime provider now incorporates Hibernate Core version
5.3.32.Final and Hibernate Tools version 5.3.32.Final.
SERVER TOOLS
NEW SERVER VIEW BASED ON RSP
In JBoss Tools, a fresh perspective has been introduced, known as the "RSP
Servers View," which utilizes the Remote Server Protocol (RSP).
To begin, you must initiate the server connector responsible for managing the
servers. Simply right-click on any entry for the Server connector, and choose
the "Start RSP" option.
The server connector is now starting and it’s status will change to [STARTED].
You can then choose between download a server or use a local server.
Now, let’s create a new server. Simply right-click on the active Server
connector and select "Download Server." Choose any runtime from the list and
confirm by clicking OK.
Follow the dialog steps for additional parameters and wait for the installation
to finish. You can see a new entry on the server view with the selected server.
Now start the server runtime using "Start Server" context menu action. The
console view opens and display any message from the server.
Now you can add any deployment to the server. This can be either a folder or a
file, present on your local computer. For example, let’s deploy a basic web
application.
Right click on the started server runtime and select "Add deployment". Then
select a web archive to be added to the server.
It will automatically deploy the application and display any message in the
console.
Now you can enjoy the application on your browser !
We are welcoming any suggestion to this new view, either on our JIRA/Github, or
using our gitter chatroom
AND MORE…
You can find more noteworthy updates in on this page.
Enjoy!
Stéphane Bouchet
--------------------------------------------------------------------------------
by sbouchet at November 06, 2023 02:24 PM
JBoss Tools Team
JBOSS TOOLS 4.28.0.FINAL FOR ECLIPSE 2023-06
by sbouchet at November 06, 2023 02:24 PM
Happy to announce 4.28.0.Final build for Eclipse 2023-06.
Downloads available at JBoss Tools 4.28.0 Final.
WHAT IS NEW?
Full info is at this page. Some highlights are below.
GENERAL
COMPONENTS DEPRECIATION
As communicated in a previous blog article, the following components are now
deprecated:
* Openshift CDK Tooling
* Openshift Explorer view (already hidden by default) and wizards, targeting
Openshift v3
The current openshift Application Explorer view, based on odo v3 is now the
default supported tooling.
Related JIRA: JBIDE-29044
HIBERNATE TOOLS
RUNTIME PROVIDER UPDATES
The Hibernate 6.2 runtime provider now incorporates Hibernate Core version
6.2.5.Final, Hibernate Ant version 6.2.5.Final and Hibernate Tools version
6.2.5.Final.
The Hibernate 5.3 runtime provider now incorporates Hibernate Core version
5.3.30.Final and Hibernate Tools version 5.3.30.Final.
NEW BACK-END USAGE
We changed the backend system used in the usage bundle from Google Analytocs to
Segment. This as no impact on how we collected usage inforamtion, neither change
the opt-in choice made in previous version of JBossTools.
As always, neither Eclipse nor JBoss will use any information unless a user has
opted in, nor is there ever any personal information sent unless it is provided
on the Preferences page.
AND MORE…
You can find more noteworthy updates in on this page.
Enjoy!
Stéphane Bouchet
--------------------------------------------------------------------------------
by sbouchet at November 06, 2023 02:24 PM
NOVEMBER 02, 2023
Jonas, Maximilian and Philip
ECLIPSE THEIA 1.43 RELEASE: NEWS AND NOTEWORTHY
by Jonas, Maximilian & Philip at November 02, 2023 12:00 AM
We are happy to announce the Eclipse Theia 1.43 release! The release contains 40
merged pull requests and we welcome three new contributors. In this article, we
will highlight some selected...
The post Eclipse Theia 1.43 Release: News and Noteworthy appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at November 02, 2023 12:00 AM
OCTOBER 31, 2023
N4JS
N4JS CAN GENERATE TYPESCRIPT DEFINITIONS
by n4js dev (noreply@blogger.com) at October 31, 2023 12:29 PM
N4JS source code is transpiled into EcmaScript, making it an integral part of
the JavaScript ecosystem. Within this ecosystem, it is utilized by various
libraries. To facilitate this usage, N4JS now offers TypeScript type definition
generation.
The growing popularity of TypeScript as a programming language is evident in the
increasing number of TypeScript packages and the download rates of pure type
definition packages. The latter are primarily provided by the Definitely Typed
repository, which currently includes type definitions for 8,724 libraries. By
enabling the N4JS transpiler to generate TypeScript definition files, N4JS
projects can be seamlessly imported into TypeScript projects while maintaining
type safety.
To activate the feature for '.d.ts' file generation, you can set the
'n4js->generator->d.ts' property to 'true' in the 'package.json' file. This
setting applies to the entire project. In cases where multiple projects exist
within a yarn workspace, the transpiler will respect projects that do not
generate '.d.ts' files. In case type information gets exposed through a project
that generates 'd.ts' files, those exposed types are cut off and will be treated
as any types. When generating type information, import statements in 'd.ts'
files may be added or removed, as some become obsolete while others are
necessary.
Despite their superficial similarities, N4JS and TypeScript differ in various
aspects. For example, N4JS allows interfaces to provide static properties, and
N4JS enums offer static properties like the getter literals that returns all
literals of an enum. In the corresponding 'd.ts' files, these interfaces and
enums are split up into TypeScript interfaces and enums along with a namespace
bearing the same name (making use of TypeScript declaration merging). The
additional namespace contains all properties that are static in the N4JS source
code.
To enable the use of built-in types, such as accessing N4JS reflection
information, the transpiler also includes the file 'n4jsglobals.d.ts'. This file
contains type information about reflection classes and provides types that mimic
N4JS structural typing strategies (e.g. all readable fields/getters of a type C
written as ~r~C in N4JS) using utility types of TypeScript.
While N4JS and TypeScript may appear similar, they differ in several ways. For
instance, TypeScript generics have the semantics of an implicit upper bound,
written as C<? extends T> in Java, whereas N4JS generics are similar to Java and
support both no explicit bounds, as well as upper or lower bounds (written as
C<T>, C<? extends T>, and C<? super T>). Additionally, TypeScript does not
support certain features, such as optional getters or setters. N4JS, on the
other hand, supports this feature, treating a getter/setter pair as
override-compatible to fields, which of course can be optional. These
differences or unsupported language features in TypeScript may occasionally
result in generated type definitions not aligning perfectly with respect to the
runtime EcmaScript and/or N4JS source code. However, in the vast majority of
cases, TypeScript type information significantly simplifies and accelerates the
reuse of N4JS libraries in terms of coding assistance and type validation.
by Marcus Mews
--------------------------------------------------------------------------------
by n4js dev (noreply@blogger.com) at October 31, 2023 12:29 PM
OCTOBER 24, 2023
Jonas, Maximilian and Philip
CDT CLOUD BLUEPRINT: DEBUGGING
by Jonas, Maximilian & Philip at October 24, 2023 12:00 AM
Looking for a modern, web-based IDE for C/C++ development or aiming to develop a
custom C/C++ tool? Dive in! This blog post highlights the debugging features of
CDT Cloud Blueprint. Before we dive...
The post CDT Cloud Blueprint: Debugging appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at October 24, 2023 12:00 AM
OCTOBER 18, 2023
Eclipse Announcements
ECLIPSE JETTY SECURITY AUDIT HAS BEEN COMPLETED
by Jacob Harris at October 18, 2023 03:55 PM
Eclipse Jetty Security Audit Has Been Completed Jacob Harris Wed, 2023-10-18
11:55
We’re proud to share that the Eclipse Foundation has completed the security
audit for Eclipse Jetty, one of the world’s most widely deployed web server and
servlet containers. All users are encouraged to upgrade to versions containing
changes addressing all conclusions of the audit: Eclipse Jetty 12.0.0, 11.0.16,
10.0.16, and 9.4.53.
URL
https://blogs.eclipse.org/post/mika%C3%ABl-barbero/eclipse-jetty-security-audit…
--------------------------------------------------------------------------------
by Jacob Harris at October 18, 2023 03:55 PM
Mikael Barbero
ECLIPSE JETTY SECURITY AUDIT HAS BEEN COMPLETED
October 18, 2023 03:00 PM
We’re proud to share that the Eclipse Foundation has completed the security
audit for Eclipse Jetty, one of the world’s most widely deployed web server and
servlet containers. All users are encouraged to upgrade to versions containing
changes addressing all conclusions of the audit: Eclipse Jetty 12.0.0, 11.0.16,
10.0.16, and 9.4.53.
Web/application servers and client libraries like ones included in Jetty need to
support multiple protocols, such as HTTP/1, HTTP/2, HTTP/3, and various Jakarta
EE standards. They handle data that could potentially come from malicious
sources. Achieving this in a proper and secure manner can be quite challenging,
and even experienced developers may inadvertently make errors.
Additionally, such Jetty servers and clients are integrated with custom
application code that handles data. The complete solutions are complex, and
improving the security of each building block is crucial. This made Eclipse
Jetty a good candidate for a security audit.
The audit provided a set of general recommendations on the direction of Jetty’s
architecture, and revealed some issues in the code base that were unknown to the
development team. It has also led to two CVEs: CVE-2023-36479 and
CVE-2023-36478, along with a list of bug fixes for the initial release of Jetty
12.0.0.
Full Report
Audits like these improve the security of the whole web services ecosystem for
Java applications, both in the short term through fixes, and in the long term by
showing potential risks and possible development directions.
While Jetty has been hosted at the Eclipse Foundation since 2009, the project’s
origins go back to 1995. Jetty is used extensively by millions of developers and
in production environments around the world. Its small footprint, high
performance, and scalability have made the server an appealing choice among
enterprise application developers using a variety of Java, Scala, Kotlin, and
other JVM-based languages. Jetty can be found in products and projects such as
Apache Hadoop, Apache Maven, Google App Engine, Dropwizard, Spring Boot, the
Javalin project, Zimbra, and the Eclipse IDE.
This was our third open source project security audit, and was completed by
Trail of Bits. Like our previous two audits, this initiative was done in
collaboration with the Open Source Technology Improvement Fund (OSTIF) and was
made possible thanks to the funding the Eclipse Foundation received from the
Alpha-Omega Project.
GET INVOLVED
* Download Eclipse Jetty, and learn how you can contribute to the project.
* Learn more about the Eclipse Cyber Risk Initiative, and how your organization
can join the effort to strengthen the open source supply chain. Please
subscribe to the ECRI mailing list to join the initiative, or to follow its
progress.
--------------------------------------------------------------------------------
October 18, 2023 03:00 PM
OCTOBER 17, 2023
Eclipse Ditto
ANNOUNCING ECLIPSE DITTO RELEASE 3.4.0
October 17, 2023 12:00 AM
The Eclipse Ditto teams is proud to announce the availability of Eclipse Ditto
3.4.0.
Version 3.4.0 mainly concentrates on exchanging the use of the Akka toolkit (due
to a change in licensing) with its fork Apache Pekko which remains Apache 2.0
licensed.
Apart from that, several improvements are also included which can be found in
the changelog.
ADOPTION
Companies are willing to show their adoption of Eclipse Ditto publicly:
https://iot.eclipse.org/adopters/?#iot.ditto
When you use Eclipse Ditto it would be great to support the project by putting
your logo there.
CHANGELOG
The main improvements and additions of Ditto 3.4.0 are:
Eclipse Ditto 3.4.0 focuses on the following areas:
* Supporting HTTP POST for performing searches with a very long query
* Addition of a new placeholder to use in connections to use payload of the
thing JSON e.g. in headers or addresses
* New placeholder functions for joining multiple elements into a single string
and doing URL-encoding and -decoding
* Configure MQTT message expiry interval for published messages via a header
* Reduce patch/merge thing commands to modify only the actually changed values
with a new option
* UI enhancements:
* Adding sending messages to Things
* Made UI (at least navigation bar) responsive for small screen sizes
* Increase size of JSON editors in “edit” mode
The following non-functional work is also included:
* Swapping the Akka toolkit (because of its switch of license to BSL License
after Akka v2.6.x) with its fork Apache Pekko which remains Apache 2.0
licensed.
* Support for using AWS DocumentDB as a replacement for MongoDB
* Improve logging by adding the W3C Trace Context traceparent header as MDC
field to logs
* Adjust handling of special MQTT headers in MQTT 5
* Optimize docker files
* Migration of Ditto UI to TypeScript
* There now is an official Eclipse Ditto Benchmark which shows how Ditto is
able to scale horizontally and provides some tuning tips
* Addition of a benchmark tooling to run own Ditto benchmarks
The following notable fixes are included:
* Fixed that failed retrieval of a policy (e.g. after policy change) leads to
search index being “emptied out”
* Fixed that putting metadata when updating a single scalar value did not work
* UI fix, fixing that patching a thing will null values did not reflect that
change in the UI
Please have a look at the 3.4.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:
* @eclipse-ditto/ditto-javascript-client-dom
* @eclipse-ditto/ditto-javascript-client-node
The Docker images have been pushed to Docker Hub:
* eclipse/ditto-policies
* eclipse/ditto-things
* eclipse/ditto-things-search
* eclipse/ditto-gateway
* eclipse/ditto-connectivity
The Ditto Helm chart has been published to Docker Hub:
* eclipse/ditto
–
The Eclipse Ditto team
--------------------------------------------------------------------------------
October 17, 2023 12:00 AM
Cedric Brun
(SIRIUS + PAPYRUS) × WEB: A NEW ERA FOR COLLABORATIVE ENGINEERING TOOLS
by Cédric Brun (cedric.brun@obeo.fr) at October 17, 2023 12:00 AM
I am excited to announce our collaboration with CEA-List towards a new era of
open-source model-based solutions!
We’ve embarked on three joint and complementary initiatives:
* ������� adopting Sirius,
* developing Web Editors for Papyrus alongside the ������
��� platform,
* beginning the implementation of a Web-based version of the forthcoming
systems engineering standard ğ�—¦ğ�˜†ğ�˜€ğ�— ğ�—Ÿ ğ�˜ƒğ�Ÿ® through a project
within the Eclipse Foundation named �����.
I had the pleasure to present all these initiatives at EclipseCon and at the
Models 2023 - Industry Day, here are the slides:
(Sirius + Papyrus) × Web: a new Era for Collaborative Engineering tools
(Sirius + Papyrus) × Web: a new Era for Collaborative Engineering tools was
originally published by Cédric Brun at CEO @ Obeo on October 17, 2023.
--------------------------------------------------------------------------------
by Cédric Brun (cedric.brun@obeo.fr) at October 17, 2023 12:00 AM
OCTOBER 12, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS CONTRIBUTOR AWARD: STEFAN DIRIX FOR CDT CLOUD BLUEPRINT
(ONLINE)
by John Kellerman at October 12, 2023 05:16 PM
Eclipse Cloud DevTools Contributor Award: Stefan Dirix for CDT Cloud Blueprint
(online)
The Eclipse Cloud Developer Tools contributor award for August goes to Stefan
Dirix at EclipseSource for his contributions to CDT Cloud Blueprint. Due to his
very recent contributions to several participating components, you can now
try CDT Cloud Blueprint online:
CDT Cloud Blueprint is a template tool for integrating and combining a set of
components to create a vanilla C/C++ IDE. You can download it, install it and
use it for C/C++ development. As such, it provides a good overall experience of
the capabilities of CDT Cloud and third party components. Further, as
the sources and build scripts for CDT Cloud Blueprint are open source, you can
use CDT Cloud Blueprint as a starting point to create your own custom C/C++ tool
by integrating your toolchains, customizing the user interface, adding specific
editors and views such as project editors or wizards, and wrapping it in your
branding. Please refer to the documentation on how to build a custom tool based
on CDT Cloud Blueprint for more information.
CDT Cloud Blueprint combines and integrates various open source technologies
provided by a diverse group of contributors. Stefan, as the project lead of CDT
Cloud Blueprint, has done an excellent job, on a technical level, in integrating
these technologies into one consistent tool. Equally as important, on a
communication level, he is the pivotal element across several CDT Cloud
projects, with contributions to participating projects such as Trace Compass
Cloud, to ultimately enable the online version of CDT Cloud Blueprint.
Of course, great technologies such as CDT Cloud depend on many contributors. We
would like to also honor the strategic contributions
from STMicroelectronics, Ericsson, Renesas, Arm and Kichwa Coders to CDT Cloud.
Thank you Stefan, well earned and congratulations!
The Cloud DevTools Working Group provides a vendor-neutral ecosystem of
open-source projects focused on defining, implementing and promoting
best-in-class web and cloud-based development tools. It is hosted at the Eclipse
Foundation, current members of the group include AMD, Arm, EclipseSource,
Ericsson, Obeo, RedHat, Renesas, STMicroelectronics and TypeFox.
This Eclipse Cloud DevTools contributor award is sponsored by EclipseSource,
providing consulting and implementation services for web-based tools, Eclipse
GLSP, Eclipse Theia, and VS Code.
John Kellerman Thu, 2023-10-12 13:16
--------------------------------------------------------------------------------
by John Kellerman at October 12, 2023 05:16 PM
OCTOBER 09, 2023
Eclipse Ditto
ECLIPSE DITTO BENCHMARK
October 09, 2023 12:00 AM
This blog post is presenting a benchmark of Eclipse Ditto. It consists of a few
scenarios to cover most important ditto functionalities, test the performance
and provide a tuning guide. This benchmark is done via the benchmark-tool, based
on k6 load testing tool
SETUP AND USED TOOLS
* EKS cluster using m5.4xlarge nodes.
* Deployed Ditto using ditto’s official helm chart, version 3.0.0, ditto
version 3.3.5.
* Deployed bitnami kafka helm chart, version 23.0.7, kafka version 3.4.0.
* Deployed MMock instance - used as a ‘dummy’ receiver for ditto events and
device commands.
* k6 - load testing tool, used to implement the benchmark scenarios.
* Deployed k6-operator - Kubernetes operator for running distributed k6 tests.
* MongoDB instance of type M50, version 5.0.21
SCENARIOS
The benchmark test consists of 4 test scenarios that can be executed
independently and in parallel:
* READ_THINGS - read things via HTTP ( get things by id )
* SEARCH_THINGS - search things via HTTP ( get things by applying search filter
)
* MODIFY_THINGS - Modify things by sending ditto protocol kafka messages to
specfic topic. Ditto kafka connection is reading from this topic and
processes the messages. Ditto HTTP push connection is configured in ditto,
which sends events from topic
/things/twin/events?filter=eq(topic:action,’modified’) to a monster mock
endpoint, which replies with HTTP status code 204.
* DEVICE_LIVE_MESSAGES - Send live messages to things via HTTP. Ditto HTTP push
connection is configured, which sends events from topic /things/live/messages
to a monster mock endpoint, which replies with predefined ditto protocol
message.
PREPARATION
1 000 000 things are created with the benchmark-tool by sending Ditto protocol
messages to the topic that a Ditto Kafka connection is configured to read from.
This connection has an implicitThingCreation mapper configured.
The thing template, configured in the connection mapper looks like the
following:
{
"thing": {
"thingId": "{{ header:device_id }}",
"_policy": {
"entries": {
"DEVICE": {
"subjects": {
"nginx:ditto": {
"type": "does-not-matter"
}
},
"resources": {
"policy:/": {
"revoke": [],
"grant": [
"READ",
"WRITE"
]
},
"thing:/": {
"revoke": [],
"grant": [
"READ",
"WRITE"
]
},
"message:/": {
"revoke": [],
"grant": [
"READ",
"WRITE"
]
}
}
}
}
},
"definition": "org.eclipse.ditto:coffeebrewer:0.1.0",
"attributes": {
"location": "test location",
"model": "Speaking coffee machine"
},
"features": {
"coffee-brewer": {
"properties": {
"brewed-coffees": 0
}
}
}
}
}
Example created thing looks like the following:
{
"thingId": "org.eclipse.ditto:test-thing-1",
"policyId": "org.eclipse.ditto:test-thing-1",
"definition": "org.eclipse.ditto:coffeebrewer:0.1.0",
"attributes": {
"location": "test location",
"model": "Speaking coffee machine"
},
"features": {
"coffee-brewer": {
"properties": {
"brewed-coffees": 0
}
}
}
}
WARMUP
Before executing the scenarios, a special ‘warmup’ scenario is executed. It is
making ‘GET’ requests so that entities are loaded in memory and caches are
populated in order to provide optimal performance.
Heap memory needed according to number of things:
* 10 000 hot things ~1.8GB for things service and ~1GB for policies service.
* 100 000 hot things - ~3.5GB for things service and ~3GB policies
* 300 000 hot things - ~5GB for things service and ~5GB for policies service
* 1 000 000 hot things - ~16GB for things service and ~15GB for policies
service
The size varies, depending on the size of the things and policies.
The scenarios are run with 100 000 warmed up things.
SCENARIOS RUN
All services use the following java vm options:
-XX:InitialHeapSize=5g
-XX:MaxHeapSize=5g
-XX:MaxRAMPercentage=75
-XX:ActiveProcessorCount=16
The scenarios run for 10 minutes each, screenshots are taken from Grafana, from
exposed ditto metrics.
READ THINGS
This scenario executes HTTP GET requests for reading things by id, like so:
${DITTO_BASE_URI}/things/org.eclipse.ditto:test-thing-1
The tests show that with single instance of each service, it is possible to
perform ~2800 reads/s. Attempting more, results in high garbage collection time
and drop in performance which can be seen in the “GC” and “Gateway Traces”
dashboards.
Scaling gateway to 2 instances results in only ~3500 reads/s, because of high GC
time for things service - ~5s. Scaling things service to 2 instances results in
~5600 reads/s. A maximum of 8400 reads/s was possible with 3 gateways and 2
things instances.
Setup 1 instance of each service 2 gateway, 1 instance each else 2 gateway, 2
things, 1 instance each else 3 gateway, 2 things, 1 instance each else Reads/s
~2800 ~3500 ~5600 ~8400 Command Processing Time(ms) ~80 ~2000 ~50 ~70
SEARCH THINGS
This scenario executes HTTP GET requests for searching things by id like so:
${DITTO_BASE_URI}/search/things?filter=eq(thingId, 'org.eclipse.ditto:test-thing-1')
In this scenario, things-search service is used to perform a search query for
things, based on the provided filter.
The tests show that with single instance of each service, it is possible to
perform ~1700 searches/s. Attempting more results in high garbage collection
time and drop in performance, as can be seen in “GC” and “Gateway Traces”
dashboards.
With single instance of things service and 2 instances of gateway service, a
maximum of ~2400 searches/s can be performed, with high GC time for things
service - ~3s. Scaling things to 2 instances results in ~3400 searches/s.
Scaling to 3 gateways does not show expected performance, because the nodes
things pods run on have high CPU usage - ~90%. To perform more searches, nodes
with more CPUs are needed.
Setup 1 instance of each service 2 gateway, 1 instance each else 2 gateway, 2
things, 1 instance each else 3 gateway, 2 things, 1 instance each else
Searches/s ~1700 ~2400 ~3400 ~4900 Command Processing Time(ms) ~70 ~100 ~50 ~100
MODIFY THINGS
This scenario sends ditto protocol kafka messages, which cause twin modifies.
Example message:
device_id:org.eclipse.ditto:test-thing-1,ditto_message:y!{"topic":"org.eclipse.ditto/test-thing-1/things/twin/commands/modify","path":"features/coffee-brewer/properties/brewed-coffees","value":"10"}
In this scenario, connectivity service is used to create a ditto kafka
connection, which reads messages from the provided topic, maps them to a ditto
modify command and forwards it to things service. The things service then
executes mongodb update query and generates the thing modified event, which is
pushed to the MMock service instance via an HTTP Push connection. Also, the
kafka connection is configured with qos=1, which means if there is no
acknowledgement that the thing is persisted, the operation will be retried.
The HTTP Push connection looks like the following:
{
"id": "a70c0749-261a-474b-9fb2-8fff7bd84fb4",
"name": "http-push-connection",
"connectionType": "http-push",
"connectionStatus": "open",
"uri": "http://mmock-service:80",
"sources": [],
"targets": [
{
"address": "POST:/{{ thing:id }}",
"topics": [
"_/_/things/twin/events?filter=eq(topic:action,'modified')"
],
"authorizationContext": [
"nginx:ditto"
],
"headerMapping": {}
}
],
"clientCount": 1,
"failoverEnabled": true,
"validateCertificates": true,
"processorPoolSize": 1,
"specificConfig": {
"parallelism": "1"
},
"tags": [
"benchmark"
]
}
The kafka connection looks like the following:
{
"id": "4cd191cc-aabb-4965-a1b4-dfe8ae8674bc",
"name": "kafka-source",
"connectionType": "kafka",
"connectionStatus": "open",
"uri": "tcp://bitnami-kafka:9092",
"sources": [
{
"addresses": [
"create-update"
],
"consumerCount": 1,
"qos": 0,
"authorizationContext": [
"nginx:ditto"
],
"enforcement": {
"input": "{{ header:device_id }}",
"filters": [
"{{ entity:id }}"
]
},
"headerMapping": {},
"payloadMapping": [
"ditto"
],
"replyTarget": {
"enabled": false
}
}
],
"targets": [],
"clientCount": 1,
"failoverEnabled": true,
"validateCertificates": true,
"processorPoolSize": 1,
"specificConfig": {
"saslMechanism": "plain",
"bootstrapServers": "bitnami-kafka:9092"
},
"mappingDefinitions": {
"ditto": {
"mappingEngine": "Ditto",
"options": {
"thingId": "{{ header:device_id }}"
},
"incomingConditions": {
"sampleCondition": "fn:filter(header:ditto_message,'exists')"
}
}
},
"tags": [
"benchmark"
]
}
By default, the ditto kafka consumer is throttled with limit of 100 number of
messages/s per consumer. This is configured by the
KAFKA_CONSUMER_THROTTLING_LIMIT env variable. This value is changed to 1000,
since with the current setup, more than 500 messages can be processed. Single
connectivity instance is able to perform ~800 modifies/s. However, “Outbound
Message rates” panel shows failed published messages from our HTTP Push
connection, and the following is observed from our connection logs:
Ran into a failure when publishing signal: Outgoing HTTP request aborted: There are too many in-flight requests. This can have the following reasons:\na) The HTTP endpoint does not consume the messages fast enough.\nb) The client count and/or the parallelism of this connection is not configured high enough.
Increasing the connection parallelism from 1(default) to 2 solves this issue and
all outbound messages are sent without fails.
...
"connectionType": "http-push",
"specificConfig": {
"parallelism": "2"
},
...
Attempting more modifies/s does not result in better performance, the ditto
kafka connection consumes at the same rate of 800 messages/s.
Scaling connectivity instance and changing our connection to have clientCount
equal to number of connectivity instances solves the GC issue. Performing 1600
modifies/s also results in high garbage collection time(~2s) for things and
things-search services. This is the maximum that can be achieved with single
things and things-search services. Scaling things and things-search solves the
GC issue. Further scaling of connectivity results in only ~1800 modifies/s,
because MongoDB’s write tickets get exhausted, as can be seen in the MongoDB
‘Tickets Available’ metric. Scaling MongoDB to higher CPU instance(M50 General,
8 cpu) solves the issue and ~2400 modifies/s are possible.
Setup 1 instance of each service 2 connectivity, 1 instance each else 3
connectivity, 2 things, 2 things-search, 1 instance each else 4 connectivity, 2
things, 2 things-search, 1 instance each else Modifies/s ~800 ~1600 ~2400 ~3200
Signal Processing Times(ms) ~15 ~80 ~10 ~20 ACK Times(ms) ~40 ~250 ~50 ~100
DEVICE LIVE MESSAGES(COMMANDS)
This scenario executes HTTP POST requests to ditto’s live channel. An HTTP Push
connection is subscribed for them and in turn pushes to a MMock instance that
acts as a ‘dummy’ device receiver of live messages/commands and simply responds
with pre-configured ditto response.
The HTTP POST request looks like the following:
URL: ${DITTO_THINGS_URI}/org.eclipse.ditto:test-thing-1/inbox/messages/someSubject
Request Body: "anyMessage"
MMock pre-configured response looks like the following:
{
"topic": "{{request.body.topic}}",
"status": "200",
"value": "ok",
"path": "{{request.body.path}}",
"headers": {
"correlation-id": "{{request.body.headers.correlation-id}}",
"content-type": "application/json"
}
}
The HTTP Push connection looks like the following:
{
"id": "a70c0749-261a-474b-9fb2-8fff7bd84fb4",
"name": "http-push-connection",
"connectionType": "http-push",
"connectionStatus": "open",
"uri": "http://mmock-service:80",
"sources": [],
"targets": [
{
"address": "POST:/live_messages",
"topics": [
"_/_/things/live/messages"
],
"authorizationContext": [
"nginx:ditto"
],
"headerMapping": {}
}
],
"clientCount": 1,
"failoverEnabled": true,
"validateCertificates": true,
"processorPoolSize": 1,
"specificConfig": {
"parallelism": "1"
},
"tags": [
"benchmark"
]
}
The tests show that a single connectivity instance is able to perform ~600 live
messages/s. Attempting more results in high garbage collection time and high
Command Processing Time, as can be seen in “GC” and “Gateway Traces” dashboards.
Scaling the instances and increasing the value of connection clientCount solves
the GC issue and doubles the messages/s. Performing more than 2400 live
messages/s also results in high garbage collection time for things and gateway
services and this is the maximum with single things and gateway services.
Scaling things and gateway solves the issue and results in ~3000 live
messages/s.
Setup 1 instance of each service 2 connectivity, 1 instance each else 3
connectivity, 1 instance each else 4 connectivity, 1 instance each else 5
connectivity, 2 things, 2 gateway, 1 instance each else Live messages/s ~600
~1200 ~1800 ~2400 ~3000 Command Processing Time(ms) ~50 ~50 ~100 ~240 ~50 Signal
Processing Times(ms) ~15 ~15 ~40 ~90 ~20
ADDITIONAL TUNING PROPERTIES, NOT USED IN THE SCENARIOS
Ditto ‘tuning’ environment variables, that were not mentioned, because those
cases were never hit, while executing the scenarios.
THING_PERSISTENCE_ACTOR_MAILBOX_SIZE - Used for special actor mailbox, which
handles ThingModifyCommands, see org.
eclipse.ditto.things.service.persistence.actors.ThingPersistenceActorMailbox. If
number of messages is more than the mailbox capacity, modify command results in
error, like the following:
Too many modifying requests are already outstanding to the Thing with ID 'org.eclipse.ditto:test-thing-1'.
REMOTE_OUTBOUND_MESSAGE_QUEUE_SIZE - See
https://doc.akka.io/docs/akka/current/general/configuration-reference.html
# Size of the send queue for outgoing messages. Messages will be dropped if
# the queue becomes full. This may happen if you send a burst of many messages
# without end-to-end flow control. Note that there is one such queue per
# outbound association. The trade-off of using a larger queue size is that
# it consumes more memory, since the queue is based on preallocated array with
# fixed size.
outbound-message-queue-size = 3072
If this limit is hit, the following error log will appear:
Message [org.eclipse.ditto.things.model.signals.commands.modify.ModifyAttribute] from Actor
[akka://ditto-cluster/temp/thingProxy$AsP9C] to Actor[akka://ditto-cluster@10.0.157.
154:2552/system/sharding/thing#362290016] was dropped. Due to overflow of send queue, size [3072]. [10] dead letters
encountered, no more dead letters will be logged in next [5.000 min]. This logging can be turned off or adjusted
with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
--------------------------------------------------------------------------------
October 09, 2023 12:00 AM
OCTOBER 06, 2023
Jonas, Maximilian and Philip
ECLIPSE THEIA 1.42 RELEASE: NEWS AND NOTEWORTHY
by Jonas, Maximilian & Philip at October 06, 2023 12:00 AM
We are happy to announce the Eclipse Theia 1.42 release! The release contains 21
merged pull requests and we welcome three new contributors. In this article we
will highlight some selected...
The post Eclipse Theia 1.42 Release: News and Noteworthy appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at October 06, 2023 12:00 AM
OCTOBER 04, 2023
Christopher Guindon
DROPPING SUPPORT FOR INTERNET EXPLORER 11 IN 2024
October 04, 2023 02:30 PM
Microsoft announced the retirement of Internet Explorer 11 (IE 11) on June 15,
2022. In alignment with this industry change and our upcoming migration to
Drupal 10 and Bootstrap 5, we are formally announcing that we will cease support
for IE 11 effective January 1, 2024.
Our decision to extend support until 2024 is strategic. Based on our website
analytics, a small but significant 3% of our user base is still utilizing IE 11.
It’s important to remember that IE 11 is a legacy browser that is no longer
supported by Microsoft, posing increased security risks. We believe this
timeline will provide ample opportunity for users to transition to modern, more
secure browsers while allowing us to align our technical roadmap.
WHAT DOES THIS MEAN FOR YOU?
For those still using IE 11, we strongly urge you to transition to a modern
browser before January 1, 2024. Popular alternatives include Microsoft Edge,
Google Chrome, and Mozilla Firefox, all of which offer a more secure and
efficient browsing experience.
We understand that this is a significant change, and we want to hear from you.
If you have any concerns or objections, please participate in our discussion.
While we aim to be as inclusive as possible in terms of browser support,
technological advancements necessitate this inevitable shift. We believe that by
giving our community advance notice, we’re ensuring a smoother transition for
everyone involved.
--------------------------------------------------------------------------------
October 04, 2023 02:30 PM
Jonas, Maximilian and Philip
CDT CLOUD BLUEPRINT: TRY IT ONLINE! (...OR OFFLINE)
by Jonas, Maximilian & Philip at October 04, 2023 12:00 AM
Are you looking for a modern, web-based C/C++ IDE that seamlessly operates
within your browser as well as a conventional desktop application? Whether you
aim to create a tailored, domain-specific...
The post CDT Cloud Blueprint: Try it Online! (...or offline) appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at October 04, 2023 12:00 AM
OCTOBER 03, 2023
Eclipse Announcements
ECLIPSE FOUNDATION ESTABLISHES CATEGORY A LIAISON WITH ISO/IEC JTC 1/SC 38 FOR
CLOUD COMPUTING AND DISTRIBUTED PLATFORMS
by Frédéric Desbiens at October 03, 2023 01:00 PM
Eclipse Foundation Establishes Category A Liaison With ISO/IEC JTC 1/SC 38 for
Cloud Computing and Distributed Platforms Frédéric Desbiens Tue, 2023-10-03
09:00
In preparation for the upcoming launch of the Eclipse Dataspaces Working Group,
we are proud to announce the establishment of a Category A liaison between
Eclipse Foundation AISBL and ISO/IEC JTC 1/SC 38 (Cloud Computing and
Distributed Platforms).
SC 38 pursues standardization in Cloud Computing and Distributed Platforms,
including Foundational concepts and technologies, operational issues, and
interactions among cloud computing systems and other distributed systems.
A dataspace is a multi-organizational agreement and a supporting technical
infrastructure enabling data sharing between two or more participants.
Dataspaces are naturally distributed, hence SC 38's interest in them.
The Eclipse Foundation is home to the Eclipse Dataspace Components project
(EDC). EDC is a comprehensive framework providing a basic set of features that
dataspace implementations can use and customize while preserving
interoperability through a well-defined API. EDC implements the Gaia-X AISBL
Trust Framework and the IDSA Dataspace protocol.
By establishing this liaison, the Eclipse Foundation intends to contribute its
expertise to future standardization efforts revolving around cloud computing,
dataspaces, and edge computing. Existing and upcoming Eclipse specifications
could eventually be transposed into standards as well.
The Eclipse Foundation obtained the status of Publicly Available Specification
(PAS) submitter back in November 2022. Since then, it has successfully submitted
its Sparkplug specification for transposition as an international standard.
Sparkplug will officially be published as ISO/IEC 20237 in the upcoming months.
--------------------------------------------------------------------------------
by Frédéric Desbiens at October 03, 2023 01:00 PM
OCTOBER 02, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS CONTRIBUTOR AWARD: THOMAS MÄEDER FOR EXTRAORDINARY
CONTRIBUTIONS TO THEIA
by John Kellerman at October 02, 2023 03:59 PM
Eclipse Cloud DevTools Contributor Award: Thomas Mäeder for Extraordinary
Contributions to Theia
The Eclipse Cloud Developer Tools contributor award for October goes to Thomas
Mäeder at Castle Ridge Software for his innovative and highly impactful
contributions to Eclipse Theia. This includes, very recently, the last missing
piece for full VS Code extension compatibility to Theia!
Image
Thomas has been an integral part of Eclipse Theia for years, demonstrating not
only a deep technical knowledge that allows him to contribute significant
features, but also a commitment to maintaining the quality of the project. He
has a strong emphasis on fostering good communication within the community,
making him a valued member of the ecosystem. Thomas plays a key role in
discussions and decision-making processes with his thoughtful perspectives and
insights. Thomas consistently looks out for the overall well being of the Theia
ecosystem.
Thomas's contribution list is too long to enumerate. Recently, he initiated a
new implementation of the RPC communication protocol in Theia that is 30 times
faster than before. In September, he had the honor of completing a huge
milestone for Theia. With his contribution of the Test API, Theia achieves full
compatibility with VS Code extensions.
It is worth mentioning that technologies like Eclipse Theia are reliant on the
efforts of many contributors and Theia is fortunate to have an active and
diverse group of developers. As an example, the Test API was originally
initiated by a group of students. It's important to recognize and honor
individual contributors who stand out and make a significant impact. Without a
doubt, Thomas Mäeder is one such developer, making this award thoroughly
well-deserved. Congratulations, Thomas!
The Cloud DevTools Working Group provides a vendor-neutral ecosystem of
open-source projects focused on defining, implementing and promoting
best-in-class web and cloud-based development tools. It is hosted at the Eclipse
Foundation, current members of the group include AMD, Arm, EclipseSource,
Ericsson, Obeo, RedHat, Renesas, STMicroelectronics and TypeFox.
This Eclipse Cloud DevTools contributor award is sponsored by EclipseSource,
providing consulting and implementation services for web-based tools, Eclipse
GLSP, Eclipse Theia, and VS Code.
John Kellerman Mon, 2023-10-02 11:59
--------------------------------------------------------------------------------
by John Kellerman at October 02, 2023 03:59 PM
SEPTEMBER 27, 2023
Christopher Guindon
NAVIGATING THE SHIFT FROM DRUPAL 7 TO DRUPAL 9/10 AT THE ECLIPSE FOUNDATION
September 27, 2023 02:30 PM
We’re currently in the middle of a substantial transition as we are migrating
mission-critical websites from Drupal 7 to Drupal 9, with our sights set on
Drupal 10. This shift has been motivated by several factors, including the
announcement of Drupal 7 end-of-life which is now scheduled for January 5, 2025,
and our goal to reduce technical debt that we accrued over the last decade.
To provide some context, we’re migrating a total of six key websites:
* projects.eclipse.org: The Eclipse Project Management Infrastructure (PMI)
consolidates project management activities into a single consistent location
and experience.
* accounts.eclipse.org: The Eclipse Account website is where our users go to
manage their profiles and sign essential agreements, like the Eclipse
Contributor Agreement (ECA) and the Eclipse Individual Committer Agreement
(ICA).
* blogs.eclipse.org: Our official blogging platform for Foundation staff.
* newsroom.eclipse.org: The Eclipse Newsroom is our content management system
for news, events, newsletters, and valuable resources like case studies,
market reports, and whitepapers.
* marketplace.eclipse.org: The Eclipse Marketplace empowers users to discover
solutions that enhance their Eclipse IDE.
* eclipse.org/downloads/packages: The Eclipse Packaging website is our platform
for managing the publication of download links for the Eclipse Installer and
Eclipse IDE Packages on our websites.
THE PROGRESS SO FAR
We’ve made substantial progress this year with our migration efforts. The team
successfully completed the migration of Eclipse Blogs and Eclipse Newsroom. We
are also in the final stages of development with the Eclipse Marketplace, which
is currently scheduled for a production release on October 25, 2023. Next year,
we’ll focus our attention on completing the migration of our more substantial
sites, such as Eclipse PMI, Eclipse Accounts, and Eclipse Packaging.
MORE THAN A SIMPLE MIGRATION: DECOUPLING DRUPAL APIS WITH QUARKUS
This initiative isn’t just about moving from one version of Drupal to another.
Simultaneously, we’re undertaking the task of decoupling essential APIs from
Drupal in the hope that future migration or upgrade won’t impact as many core
services at the same time. For this purpose, we’ve chosen Quarkus as our
preferred platform. In Q3 2023, the team successfully migrated the GitHub ECA
Validation Service and the Open-VSX Publisher Agreement Service from Drupal to
Quarkus. In Q4 2023, we’re planning to continue down that path and deploy a
Quarkus implementation of several critical APIs such as:
* Account Profile API: This API offers user information, covering ECA status
and profile details like bios.
* User Deletion API: This API monitors user deletion requests ensuring the
right to be forgotten.
* Committer Paperwork API: This API keeps tabs on the status of ongoing
committer paperwork records.
* Eclipse USS: The Eclipse User Storage Service (USS) allows Eclipse projects
to store user-specific project information on our servers.
CONCLUSION: A FORWARD-LOOKING TRANSITION
Our migration journey from Drupal 7 to Drupal 9, with plans for Drupal 10,
represents our commitment to providing a secure, efficient, and user-friendly
online experience for our community. We are excited about the possibilities this
migration will unlock for us, advancing us toward a more modern web stack.
Finally, I’d like to take this moment to highlight that this project is a
monumental team effort, thanks to the exceptional contributions of Eric Poirier
and Théodore Biadala, our Drupal developers; Martin Lowe and Zachary Sabourin,
our Java developers implementing the API decoupling objective; and Frederic
Gurr, whose support has been instrumental in deploying our new apps on the
Eclipse Infrastructure.
--------------------------------------------------------------------------------
September 27, 2023 02:30 PM
SEPTEMBER 21, 2023
Eclipse Announcements
THE CRA SHOULD SUPPORT OPEN PRACTICES OF OPEN SOURCE AND THE DEVELOPMENT OF
EUROPEAN OPEN SOURCE TO THE ADVANTAGE OF SMALL AND MEDIUM SIZE ENTREPRISES
(SMES)
by Shanda Giacomoni at September 21, 2023 05:00 AM
The CRA should support open practices of open source and the development of
European Open source to the advantage of small and medium size entreprises
(SMEs) Shanda Giacomoni Thu, 2023-09-21 01:00
As the European Union is about to initiate negotiations between co-legislators
on the Cyber Resilience Act (CRA), we, the undersigned organisations and
contributors to leading European open source software (OSS), herewith express
our utmost concerns about the consequences of the proposed CRA, and
misconceptions throughout the EU legislative process.
In this time of increasing awareness of the challenges to European open
strategic autonomy, Europe needs a strong open source community supportive of
SMEs, startups and scaleups, but also accountability of large corporations in
increasing cybersecurity.
We deeply share the CRA’s aim to improve cybersecurity in the EU and embrace the
urgent need to protect citizens and economies by improving software security.
We welcome some recent positive changes brought by the co-legislators, such as
the manufacturers’ obligation to report vulnerabilities to the entity
maintaining OSS.
However, should the proposal or the position of the European Parliament be
adopted as it stands, the CRA would: decrease the number of OSS projects
available to European SMEs; increase the control over OSS initiatives by large
corporations; jeopardise the fragile equilibrium that benefits SMEs which
contributes to European innovation; and reduce the security of products
available to consumers.
Thus, in order to not harm European innovation we urge co-legislators to
consider the following:
* Clearly state that if open source software under the governance of a
non-profit falls within the scope of the legislation, legal responsibility
should only be on commercial entities supplying the software in the course of
a commercial activity, and not the governing non-profit which makes the
software available free of charge;
* Recognise for open source software that is under the governance of
non-profits that are acting as neutral spaces, those non-profits may accept
to collaborate with for-profit entities by coordinating the compliance of the
software;
* Allow the CE marking and overall compliance managed by commercial entities,
to be reusable by the OS community.
With these elements the CRA could achieve one of its objectives to regulate and
improve the cybersecurity practices of OSS used in commercial activities without
altering the equilibrium of OSS development, research and collaboration, which
currently plays to the advantage of European SMEs and innovation.
The undersigned organisations collectively represent a large part of the open
source ecosystem in Europe. We offer our collective expertise, and support an
increased dialogue towards the CRA’s successful implementation in this new
regulatory paradigm.
Download the PDF in English.
--------------------------------------------------------------------------------
by Shanda Giacomoni at September 21, 2023 05:00 AM
SEPTEMBER 20, 2023
Jonas, Maximilian and Philip
USING THEIA CLOUD TO END-TO-END TEST THEIA-BASED APPLICATIONS
by Jonas, Maximilian & Philip at September 20, 2023 12:00 AM
Do you develop a Theia-based application and you want an easy way to end-to-end
test new versions of it. Do you want to dynamically deploy new versions of your
Theia application, ideally on every new...
The post Using Theia Cloud to end-to-end test Theia-based applications appeared
first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at September 20, 2023 12:00 AM
SEPTEMBER 19, 2023
Mike Milinkovich
NEW SURVEY: HOW DO DEVELOPERS FEEL ABOUT ENTERPRISE JAVA IN 2023?
by Mike Milinkovich at September 19, 2023 01:00 PM
The results of the 2023 Jakarta EE Developer Survey are now available! For the
sixth year in a row, we’ve reached out to the enterprise Java community to ask
about their preferences and priorities for cloud native Java architectures,
technologies, and tools, their perceptions of the cloud native application
industry, and more.
From these results, it is clear that open source cloud native Java is on the
rise following the release of Jakarta EE 10.The number of respondents who have
migrated to Jakarta EE continues to grow, with 60% saying they have already
migrated, or plan to do so within the next 6-24 months. These results indicate
steady growth in the use of Jakarta EE and a growing interest in cloud native
Java overall.
When comparing the survey results to 2022, usage of Jakarta EE to build cloud
native applications has remained steady at 53%. Spring/Spring Boot, which relies
on some Jakarta EE specifications, continues to be the leading Java framework in
this category, with usage growing from 57% to 66%.
Since the September 2022 release, Jakarta EE 10 usage has grown to 17% among
survey respondents. This community-driven release is attracting a growing number
of application developers to adopt Jakarta EE 10 by offering new features and
updates to Jakarta EE. An equal number of developers are running Jakarta EE 9 or
9.1 in production, while 28% are running Jakarta EE 8. That means the increase
we are seeing in the migration to Jakarta EE is mostly due to the adoption of
Jakarta EE 10, as compared to Jakarta EE 9/9.1 or Jakarta EE 8.
The Jakarta EE Developer Survey also gives us a chance to get valuable feedback
on features from the latest Jakarta EE release, as well as what direction the
project should take in the future.
Respondents are most excited about Jakarta EE Core Profile, which was introduced
in the Jakarta EE 10 release as a subset of Web Profile specifications designed
for microservices and ahead-of-time compilation. When it comes to future
releases, the community is prioritizing better support for Kubernetes and
microservices, as well as adapting Java SE innovations to Jakarta EE — a
priority that has grown in popularity since 2022. This is a good indicator that
the Jakarta EE 11 release plan is on the right direction by adopting new Java SE
21 features.
2,203 developers, architects, and other tech professionals participated in the
survey, a 53% increase from last year. This year’s survey was also available in
Chinese, Japanese, Spanish & Portuguese, making it easier for Java enthusiasts
around the world to share their perspectives. Participation from the Chinese
Jakarta EE community was particularly strong, with over 27% of the responses
coming from China. By hearing from more people in the enterprise Java space,
we’re able to get a clearer picture of what challenges developers are facing,
what they’re looking for, and what technologies they are using. Thank you to
everyone who participated!
LEARN MORE
We encourage you to download the report for a complete look at the enterprise
Java ecosystem.
If you’d like to get more information about Jakarta EE specifications and our
open source community, sign up for one of our mailing lists or join the
conversation on Slack. If you’d like to participate in the Jakarta EE community,
learn how to get started on our website.
--------------------------------------------------------------------------------
by Mike Milinkovich at September 19, 2023 01:00 PM
SEPTEMBER 15, 2023
Mikael Barbero
ECLIPSE FOUNDATION PUBLISHES RESULTS OF ECLIPSE JKUBE SECURITY AUDIT
September 15, 2023 02:00 PM
Today, the Eclipse Foundation released the results of our security audit for
Eclipse JKube, a collection of tools for building Java applications that can be
deployed to a cloud environment. Findings from the audit have been addressed in
the 1.13 release leading to a new feature.
This audit included a documentation review, static code review and manual
review, which uncovered two findings that have been addressed by the JKube team
through container configuration improvements.
Eclipse JKube originated in 2020 as the successor to the Fabric8 Maven plug-in,
which was deprecated the same year. Consisting of plug-ins and components for
building container images using Docker, Java image builder (Jib), or
Source-to-Image (S2I) build strategies, JKube makes it easy to transition Java
applications to the cloud by deploying them in Kubernetes.
By default, JKube’s Kubernetes deployment artifacts did not have many of
Kubernetes’ security features enabled. To address the audit’s findings and
improve the overall security of JKube’s generated Kubernetes resources, the
JKube team introduced a Security Hardening profile in the project’s 1.13
release. The profile disables the auto-mounting of the service account token,
prevents containers from running in privileged mode, and ensures containers do
not allow privilege escalation. Check out the full report for more information.
Full Report
This was our second open source project security audit, and was completed by
Trail of Bits. Like with the Equinox p2 security audit, this initiative was done
in partnership with the Open Source Technology Improvement Fund (OSTIF) and was
made possible due to the funding the Eclipse Foundation received from the
Alpha-Omega Project.
Impartial security audits like this play an important role in securing the open
source software supply chain. Developers looking to containerize Java
applications with JKube can now be confident in the security of their
applications.
Keep an eye on our blog for more security audit announcements in the future.
GET INVOLVED
* Get started with Eclipse JKube, and learn how you can contribute to the
project.
* Learn more about the upcoming Eclipse Cyber Risk Initiative, and how your
organization can join the effort to strengthen the open source supply chain.
Please subscribe to the ECRI mailing list to join the initiative, or to
follow its progress.
--------------------------------------------------------------------------------
September 15, 2023 02:00 PM
Jonas, Maximilian and Philip
THE ECLIPSE THEIA COMMUNITY RELEASE 2023-08
by Jonas, Maximilian & Philip at September 15, 2023 12:00 AM
We are happy to announce the fourth Eclipse Theia community release
“2023-08”, version 1.40.x! Don’t know about Eclipse Theia,
yet? It is the next-generation platform for building...
The post The Eclipse Theia Community Release 2023-08 appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at September 15, 2023 12:00 AM
SEPTEMBER 13, 2023
Webtools News
WTP 3.31 RELEASED!
September 13, 2023 11:59 PM
The Eclipse Web Tools Platform 3.31 has been released! Installation and updates
can be performed using the Eclipse IDE 2023-09 Update Site or through any of the
related Eclipse Marketplace . Release 3.31 is included in the 2023-09 Eclipse
IDE for Enterprise Java and Web Developers , with selected portions also
included in several other packages . Adopters can download the R3.31 p2
repository directly and combine it with the necessary dependencies, as well as
check the New Help for Old Friends document as a high number of bundles have
updated their BREEs in this release.
More news
--------------------------------------------------------------------------------
September 13, 2023 11:59 PM
SEPTEMBER 08, 2023
Jonas, Maximilian and Philip
ECLIPSE THEIA VS. VS CODE OSS
by Jonas, Maximilian & Philip at September 08, 2023 12:00 AM
Do you want to build a custom tool or IDE offering and were wondering which
web-based platform to choose? Are you evaluating Eclipse Theia against Code OSS
(the open source project behind VS Code)? In...
The post Eclipse Theia vs. VS Code OSS appeared first on EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at September 08, 2023 12:00 AM
SEPTEMBER 06, 2023
John Kellerman
ECLIPSE CLOUD DEVTOOLS DIGEST - JULY AND AUGUST 2023
by John Kellerman at September 06, 2023 07:53 PM
Eclipse Cloud DevTools Digest - July and August 2023
2023 ECLIPSE CLOUD DEVELOPER SURVEY PUBLISHED
The Eclipse Foundation and the Cloud DevTools Working Group published the
results from its 2023 Cloud Developer Survey. Spoiler alert: Cloud-based
software developer tools are experiencing significant momentum and organizations
are increasingly looking to solutions governed by an open source software
foundation.
CLOUD DEVTOOLS CONTRIBUTOR AWARDS TO STMICROELECTRONICS AND MARK SUJEW
The Eclipse Cloud Developer Tools contributor award for July goes to Mark Sujew
at TypeFox for his continuous, strategic and valuable contributions to Eclipse
Theia, including recently for example, his contributions to enable remote SSH
support for Eclipse Theia! The August contributor award goes to
STMicroelectronics for initiating the support for TypeScript-based GLSP server
implementations.
EMBEDDED SIG EVOLVES TO CDT CLOUD PROJECT
The Embedded Special Interest Group (SIG) hosted as part of the Eclipse Cloud
DevTools working group has now evolved into the CDT Cloud project. This reflects
the growth and continuously high level of activity in the group, which has
outgrown the original governance structure and matured into the establishment of
several active open source initiatives under the CDT Cloud umbrella.
ECLIPSE JKUBE 1.14 IS NOW AVAILABLE
Image
Marc Nuri, in his blog, updates us on what's on new and noteworthy for JKube
1.14, including Gradle 8 and Helidon support.
ECLIPSE THEIA RELEASES
Image
Jonas, Maximilian & Philip, in their blog, provide updates for Theia releases
1.39 and 1.40, including support for multiple extension registries, Electron
application detachable views, conditions on exception breakpoints, and a number
of usability and performance enhancements.
JBOSS TOOLS 4.28 RELEASE
Image
The JBoss team announced JBoss Tools 4.28.0 for Eclipse 2023-06. This release
includes deprecations for some Openshift support, updates to Hibernate runtime
support, and a move on the backend from Google Analytics to Segment.
THEIACON 2023 AND COMMUNITY DAY AT ECLIPSECON EVENTS
The Eclipse Cloud DevTools and Open VSX Working Groups will be co-hosting a
Community Day event at EclipseCon on October 16th. Last year’s Community Day was
well-attended and a very informative and enjoyable time was had by all. Be sure
to submit your topics for this years event.
The Call for Presentations is also now live for TheiaCon 2023, which will be
held virtually on November 15-16. We look forward to another excellent program
and encourage you to submit your proposals early.
CLOUD TOOL TIME WEBINARS
We are now scheduling Cloud Tool Time webinars for 2023. Be sure to Sign up now
to get on the calendar and let us help tell your story. You can see past
sessions on our Youtube channel.
ECLIPSE CLOUD DEVTOOLS PROJECTS
Explore the Eclipse Cloud DevTools ecosystem! Check out our projects page to
find out more about open source innovation for cloud IDEs, extension
marketplaces, frameworks and more.
GETTING LISTED ON THE CLOUD DEVTOOLS BLOG
If you are working with, or on, anything in the Cloud DevTools space, learn how
to get your writings posted in our blog section.
John Kellerman Wed, 2023-09-06 15:53
--------------------------------------------------------------------------------
by John Kellerman at September 06, 2023 07:53 PM
SEPTEMBER 05, 2023
Jonas, Maximilian and Philip
ECLIPSE THEIA 1.41 RELEASE: NEWS AND NOTEWORTHY
by Jonas, Maximilian & Philip at September 05, 2023 12:00 AM
We are happy to announce the Eclipse Theia 1.41 release! Even though we are
still in vacation season, the release contains 50 merged pull requests and we
welcome three new contributors. In this...
The post Eclipse Theia 1.41 Release: News and Noteworthy appeared first on
EclipseSource.
--------------------------------------------------------------------------------
by Jonas, Maximilian & Philip at September 05, 2023 12:00 AM
AUGUST 31, 2023
Marc Nuri
ECLIPSE JKUBE 1.14 IS NOW AVAILABLE!
August 31, 2023 04:00 PM
Original post
A newer version of Eclipse JKube is available, jump to Eclipse JKube 1.15
announcement.
On behalf of the Eclipse JKube team and everyone who has contributed, I'm happy
to announce that Eclipse JKube 1.14.0 has been released and is now available
from Maven Central �.
Thanks to all of you who have contributed with issue reports, pull requests,
feedback, and spreading the word with blogs, videos, comments, and so on. We
really appreciate your help, keep it up!
WHAT'S NEW?
Without further ado, let's have a look at the most significant updates:
* Gradle 8 support
* Helidon support
* Spring Boot layered jar
* Helm push support for OCI registries
* � Many other bug-fixes and minor improvements
GRADLE 8 SUPPORT
Gradle 8 wasn't fully supported in previous versions of JKube, as some users
have reported. This release fixes the issues and adds full support for Gradle 8.
Gradle 8 brings multiple improvements and new features. You can find more
information in the Gradle 8 release announcement. These are some of the most
relevant changes:
* Performance Boosts:
* Introduction of a configuration cache to speed up project configuration.
* Enhanced parallelism for task execution without requiring the '--parallel'
flag.
* Faster Java compilation with improved incremental compilation.
* Usability Improvements:
* Improved Java toolchain support for specifying the project's JDK and
vendor.
* Introduction of Test Suites for simplifying test organization.
* Version catalogs for managing dependencies with better plugin version
support.
* Ecosystem Support Upgrades:
* Support for Java 17 through 19, Groovy 4.0, and an updated Scala Zinc
version.
Our JKube fix will allow you to take advantage of all these improvements and
won't hold you back from upgrading to Gradle 8 🚀.
HELIDON SUPPORT
Helidon is a collection of Java libraries for writing microservices that run on
a fast web core powered by Netty. Until now, if you wanted to use JKube with
Helidon, you had to provide a complete image configuration.
This JKube release includes a new Helidon Generator and Enricher that will allow
you to build and deploy your Helidon application to Kubernetes and OpenShift
without any additional configuration.
You will find quickstarts for both Helidon SE and Helidon MP in our main
repository.
SPRING BOOT LAYERED JAR
Spring Boot 2.3 introduced a new layered jar format to package your application.
Being able to provide different layers when building your image allows you to
take advantage of the Docker or Jib layer cache and reduce the image build time.
With this release, JKube will automatically detect if your project is using a
layered jar and will configure the image build accordingly to take advantage of
the layers defined in your jar. As usual with many of JKube's features,
everything will work out of the box without any additional configuration from
your side.
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.14.0</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.14.0'
}
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
--------------------------------------------------------------------------------
August 31, 2023 04:00 PM
BLOGS
ACTIVE BLOGS
* Cedric Brun
* Christopher Guindon
* Clark Roundy
* Donald Raab
* Eclipse Announcements
* Eclipse Ditto
* Glyn Normington
* JBoss Tools Team
* John Kellerman
* Jonas Helming
* Lorenzo Bettini
* Marc Nuri
* Mikael Barbero
* Mike Milinkovich
* Mukul Gandhi
* N4JS
* Sharon Corbett
* Wayne Beaton
* Webtools News
INACTIVE BLOGS
* Abel Muino
* Aleksandr Kravets
* Alex Blewitt
* Alex Lagarde
* Alex Radeski
* Alex Ruiz
* Alexander Kurtakov
* Alexander Nyssen
* Andre Oosthuizen
* Andrea Zoppello
* Andreas Graf
* Andreas Muelder
* Andres Alvarez Mattos
* Andrew Eisenberg
* Andrew Niefer
* Andrew Ross
* Andrey Loskutov
* Andy Clement
* Andy Piper
* Angelo Zerr
* Ankur Sharma
* Annamalai Chockalingam
* Anne Haugommard
* Anthony Hunter
* Anthony Juckel
* Antoine Thomas
* Antoine Toulme
* Axel Meinhardt
* Ayushman Jain
* BJ Hargrave
* Ben Vitale
* Benjamin Cabe
* Benno Baumgartner
* Benoit Langlois
* Bernd Kolb
* BioClipse
* Birt World
* Blaise Doughan
* Blinki
* Bob Balfe
* Boris Bokowski
* Borislav Kapukaranov
* Brian Fitzpatrick
* Brian Fitzpatrick
* Brian de Alwis
* Bryan Hunt
* Carlos Sanchez
* Carlos Valcarcel
* Chetan Kumar Kotha
* Chris Aniszczyk
* Chris Daniel
* Chris Gross
* Chris Recoskie
* Christian Damus
* Christian Krause
* Christian Meier
* Christian Pontesegger
* Christoph Kulla
* Code Recommenders
* Craig Setera
* Ctrlflow
* Ctrlflow
* DSL Forge
* Daniel Ford
* Darin Swanson
* Dariusz Luksza
* Dave Carver
* David Black
* David Bosschaert
* David Bosschaert
* David Green
* David Kyle
* Dean Roberts
* Deepak Azad
* Del Myers
* Denis Roy
* Dinis Cruz
* Dirk Fauth
* Donald Smith
* Doug Clarke
* Doug Schaefer
* Eclipse Che
* Eclipse Cloud DevTools
* Eclipse Committer Reps
* Eclipse Dirigible
* Eclipse Enthusiasts Poznań
* Eclipse Gyrex
* Eclipse Jubula
* Eclipse Lyo
* Eclipse Membership
* Eclipse Scout
* EclipseCon Europe 2019
* EclipseLink Team
* EclipseLive
* Ed Burnette
* Ed Merks
* Edmundo López B.
* Egon Willighagen
* Eike Stepper
* Ekkehard Gentz
* Elias Volanakis
* Elliott Baron
* Emil Crumhorn
* Emilien Perico
* Erdal Karaca
* Eric Moffatt
* Eric Rizzo
* Erkki Lindpere
* Etienne Juliot
* Eugene Kuleshov
* Eugene Ostroukhov
* Fabian Steeg
* Fabio Zadrozny
* Felipe Heidrich
* Florian Lautenbacher
* Florian Pirchner
* Florian Thienel
* Florian Waibel
* Florian Weßling
* Francis Upton
* Francisco Gortazar-Bellas
* Frank Appel
* Frank Turovich
* Fred Grott
* Freddy Allilaire
* Frederic Madiot
* GEF3D
* Geniutec
* Gorkem Ercan
* Goulwen Le Fur
* Gunnar Wagenknecht
* Hasan Ceylan
* Heiko Behrens
* Heiko Seeberger
* Hendrik Eeckhaut
* Hendrik Still
* Hendy Irawan
* Henrik Lindberg
* Herman Lintvelt
* Hiroki Kondo (kompiro)
* Holger Staudacher
* Holger Voormann
* Hudson-CI Blog
* Human Centered Web (HCW)
* Ian Bull
* Ian Skerrett
* Ilya Shinkarenko
* Imran Abdul Rahiman
* InfoQ Eclipse feed
* Inside Designerator
* Ismael Juma
* Jacek Pospychala
* Jae Gangemi
* James Ervin
* James Sutherland
* Jan Kohnlein
* Jason van Zyl
* Jazz Team
* Jeeeyul Lee
* Jeff McAffer
* Jens Reimann
* Jens von Pilgrim
* Jeremie Bresson
* Jerome Benois
* Jesper Møller
* Jiang Hu
* Jin Mingjian
* Joachim Hofer
* Jochen Krause
* Joern Weigle
* John Arthorne
* John Bito
* John Dang
* John Graham
* Jonas Helming
* Jonas Hungershausen
* Jonas, Maximilian and Philip
* Jonathan Musset
* Jpicture Data Binding Team
* Julius Shaw
* Kai Kreuzer
* Kai Toedter
* Kai Zimmermann
* Kaloyan Raev
* Kaloyan Raev
* Karl Beecher
* Karsten Thoms
* Ken Gilmer
* Ken Ryall
* Kenn Hussey
* Kent Beck
* Ketan Padegaonkar
* Kevin Vu
* Kichwa Coders
* Kim Horne
* Kim Moir
* Knut Wannheden
* Konstantin Komissarchik
* Lars Vogel
* Laurent Goubet
* Lawrence Mandel
* Leo Ufimtsev
* Les Jones
* Libor Jelinek
* Litrik De Roy
* Lukasz Milewski
* Maarten Meijer
* Madhu Samuel
* Malick Wade
* Manoj N Palat
* Manuel Selva
* Marc Dutoo
* Marc Gille
* Marcel Bruch
* Marcel Gorri
* Marcelo Mayworm
* Marcelo Paternostro
* Mariot Chauvin
* Mark Melvin
* Mark Phippard
* Mark Powell
* Markus Knauer
* Markus Kohler
* Markus Scheidgen
* Markus Voelter
* Martin Fluegge
* Martin Lippert
* Martin Oberhuber
* Martin Taal
* Marty Jones
* Mat Booth
* Mateusz Matela
* Matthias Kempka
* Maximilian Kögel
* Meinte Boersma
* Melanie Bats
* Michael Jastram
* Michael Scharf
* Michael Spector
* Michael Valenta
* Michael Vorburger
* Michaela Greiler
* Mickael Istria
* Mik Kersten
* Mike Wilson
* Miles Parker
* Mitch Sonies
* ModelBus
* Mohsen Vakilian
* Moritz Eysholdt
* Moritz Post
* Morten Christensen
* Naci Dai
* Ned Twigg
* Neil Bartlett
* Nick Boldt
* Nicolas Richeton
* Nikhil Nanivadekar
* Niko Stotz
* Nirav Thaker
* Nirmal Sasidharan
* Nitin Dahyabhai
* Noopur Gupta
* OSGi Alliance
* Oisín Hurley
* Olivier Thomann
* Open Healthcare Framework
* OpenNTF
* Orion
* Paolo Patierno
* PapyrusUML
* Pascal Rapicault
* Patrick Paulin
* Patrik Suzzi
* Paul Bilnoski
* Paul Buck
* Paul Webster
* Peter Friese
* Peter Liu
* Philip Wenig
* Philipp Kursawe
* Philippe Ombredanne
* Platform Debug Team
* Polarsys
* Polishin' Eclipse
* Prakash G.R.
* R4E Development Team
* RCP Testing Tool
* RSE World
* Radoslaw Urbas
* Raja Kannappan
* Ralf Sternberg
* Ralf Zahn
* Red Hat Developers
* Remy Suen
* Ricco Deutscher
* Richard Gronback
* Robert Gruendler
* Robert Konigsberg
* Rohan Kumar
* Roland Grunberg
* Ron Bermejo
* Roxanne Joncas
* Roy Ganor
* Ruediger Herrmann
* Samy Abou-Shama
* Sandip Chitale
* Sandro Boehme
* Scott Kellicker
* Scott Lewis
* Scott Schram
* Sebastian Benz
* Sebastian Zarnekow
* Serge Beauchamp
* Seva Lapsha
* Shaun Smith
* Simon Chemouil
* Simon Kaegi
* Simon Maple
* Simon Scholz
* Simon Zambrovski
* SoC Blog
* Sopot Cela
* Stefan Dimov
* Stefan Leopold
* Stefan Winkler
* Stephan Herrmann
* Stephane Begaudeau
* Stephane Bouchet
* Steve Northover
* Suneth Vijayindu
* Suresh Krishna
* Susan McCourt
* Sven Efftinge
* Sébastien Gandon
* Tanja Obradovic
* Terry Chen
* Thea Aldrich
* Thibault Landre
* Thomas Derflinger
* Thomas ten Cate
* Tillmann Seidel
* Tim Buschtöns
* Tom Schindl
* Tom Schindl
* Tom Seidel
* Tomasz Wesolowski
* Tonny Madsen
* Torkild Ulvøy Resheim
* Triquetrum project
* Ugo Sangiorgi
* Vasanth Dharmaraj
* Vassiliy Tchoumatchenko
* Vincent Hemery
* Vincent Zurczak
* Vineet Sinha
* Virgil Dodson
* Vladimir Piskarev
* Vladimir Prus
* Vojimir Golem
* Wayne Beaton
* William Piers
* Wim Jongman
* Wim Jongman
* Zend Studio Team
* Zoltan Ujhelyi
* itemis
* typefox.io
* vert.x project
×Close
ABOUT PLANET ECLIPSE
Planet Eclipse is a window into the world, work and lives of Eclipse hackers and
contributors.
Looking for an RSS Newsreader? Try RSSOwl, it is built on Eclipse!
Last updated: April 26, 2012 06:53 PM (UTC)
Maintained by the Planet Eclipse admins.
Powered by:
Close
×Close
ADD YOUR BLOG
Want to become a Planet Eclipse author? To add your blog to the feed, please
have a look at our guidelines and then open an issue or create a pull request
with your feed-specific information.
Close
Back to the top
SIGN UP TO OUR NEWSLETTER
A fresh new issue delivered monthly
ECLIPSE FOUNDATION
* About Us
* Contact Us
* Donate
* Governance
* Logo and Artwork
* Board of Directors
LEGAL
* Privacy Policy
* Terms of Use
* Copyright Agent
* Eclipse Public License
* Legal Resources
USEFUL LINKS
* Report a Bug
* Documentation
* How to Contribute
* Mailing Lists
* Forums
* Marketplace
OTHER
* IDE and Tools
* Community of Projects
* Working Groups
* Research@Eclipse
* Service Status
Copyright © Eclipse Foundation, Inc. All Rights Reserved.
*
*
*
*
Back to the top