At the InfoQ Dev Summit Munich, Markus Kett presented a database alternative for Java: The in-memory EclipseStore promises faster data processing with lower cloud costs. It stores Java objects as binary files in local or cloud file systems and uses Java Streams for queries. But applications must manage concurrent writes and use the commercial MicroStream Cluster for multiple JVM instances.

We are happy to announce the Eclipse Theia 1.54 release! The release contains 82 merged pull requests. In this article, we will highlight some selected improvements and provide an overview of the …

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

The Theia IDE, built on modern web technologies, is at the forefront of open innovation for developers, providing cutting-edge capabilities, including experimental AI support powered by Theia AI. …

The post Introducing Custom Chat Agents in Theia IDE: Automate Your Workflows with Ease appeared first on EclipseSource.

Consistent categorization of methods can lead to comprehension benefits.

Seven Plus Two For The Win

I’ve written a couple of blogs about grouping the methods in the Eclipse Collections RichIterable interface by Method Category. I have updated the RichIterable interface source using Custom Code Folding Regions in IntelliJ.

There are nine categories of methods in RichIterable. If we look at the RichIterable type in the IntelliJ hierarchy view, we will see there are many interfaces that are subtypes of RichIterable.

The nine categories that have been organized for RichIterable, could be used to group the methods in all of these types as well. Each of these interfaces inherit all of the methods of RichIterable, and may selectively override methods with covariant return types.

Categorizing all of these types would be a lot of work. So I started thinking about how I could do this using Java. I wrote a little code to determine the method categories for most Collection types in Java. I categorized methods in Collection related classes in the JDK and Eclipse Collections.

The following is the method named countMethodsInClassesByCategory I wrote that does much of the work. It creates and then flips a BagMultimap. Everyone should do this at least once in their life.

public static void countMethodsInClassesByCategory(String title, MutableList<Class<?>> types)
{
    ClassComparer classComparer = new ClassComparer(true, false, false);

    BagMultimap<String, Class<?>> classCountsByCategory =
            types.groupByEach(
                    clazz -> classComparer.getMethodNames(clazz)
                            .collect(ClassComparerAsciiDoc::categoryForMethodNamed),
                    Multimaps.mutable.bag.empty());

    outputMethodCountsPerTypePerCategory(title, classCountsByCategory);

    System.out.println();

    BagMultimap<Class<?>, String> categoryCountsByClass =
            classCountsByCategory.flip();

    outputMethodCategoryCountsByType(title, categoryCountsByClass);
}

private static String categoryForMethodNamed(String method)
{
    return PREFIXES.detectIfNone(
            pair -> pair.getTwo().anySatisfy(method::startsWith),
            () -> Tuples.pair("Uncategorized", Sets.mutable.empty())).getOne();
}

private static void outputMethodCategoryCountsByType(String title, BagMultimap<Class<?>, String> categoryCountsByClass)
{
    System.out.println("." + title + " Method Category Counts by Type");
    System.out.println("[%autowidth.stretch]");
    System.out.println("|===");
    System.out.println("|*Class* |*Method Counts by Category*");

    MutableList<String> result2 = Lists.mutable.empty();
    categoryCountsByClass.forEachKeyMultiValues((k, v) ->
            result2.add("|*" + k.getSimpleName() + "* |"
                    + v.toSortedBag().toStringOfItemToCount()));
    result2.sortThis();
    result2.forEach(System.out::println);

    System.out.println("|===");
}

private static void outputMethodCountsPerTypePerCategory(String title, BagMultimap<String, Class<?>> classCountsByCategory)
{
    System.out.println("." + title + " Method Counts per Type by Category");
    System.out.println("[%autowidth.stretch]");
    System.out.println("|===");
    System.out.println("|*Category* | *Method Counts per Type*");

    MutableList<String> result1 = Lists.mutable.empty();
    classCountsByCategory.forEachKeyMultiValues((k, v) ->
            result1.add("|*" + k + "* | "
                    + v.collect(Class::getSimpleName).toSortedBag().toStringOfItemToCount()));
    result1.sortThis();
    result1.forEach(System.out::println);
    System.out.println("|===");
}

This method takes a title and a List of Class to categorize. It creates two BagMultimap instances. The first instance counts the methods for each type by method category. By flipping this BagMultimap using the flip method, we get the counts for each Method Category, by Class.

The type ClassComparer is a class in the Eclipse Collections test-utils jar. I use it to get the method names for a class. In this particular case, the first of the three magic booleans I pass in (true, false, false), keeps the parameter types as part of the method name, but ignores the return type and packages. I described this class a while ago in the following blog.

How to introspect and find conceptual symmetry between classes in Java

The trick is associating method prefixes with some category. This is much faster than categorizing every method manually, which would be a lot of work. The following is the method I use to place methods in categories using their prefixes. The same code is used for JDK and Eclipse Collections types. Sometimes the prefixes match up (e.g., any, all, none, flat, group) and sometimes they don’t (e.g. select, reject, filter, collect, map). The collect method on Stream will get categorized into the transforming category. I would probably have put it in the aggregating category if I was categorizing individual methods. I still wish it would have been named something other than collect, but naming is hard, and this is what we have. :)

private static final MutableList<Pair<String, MutableSet<String>>> PREFIXES =
        prefixesByCategory();

public static MutableList<Pair<String, MutableSet<String>>> prefixesByCategory()
{
    MutableList<Pair<String, MutableSet<String>>> list = Lists.mutable.empty();
    list.add(Tuples.pair(
            "Iterating",
            Sets.mutable.with(
                    "each", "forEach", "tap", "asLazy", "iterator", "spliterator", "tee", "drop",
                    "take", "generate", "iterate", "peek", "reverse", "listIterator", "parallel",
                    "sequential", "asParallel", "asReversed", "asUnmodifiable", "asSynchronized",
                    "stream", "parallelStream", "primitiveParallelStream", "primitiveStream",
                    "intIterator")));
    list.add(Tuples.pair("Counting", Sets.mutable.with("count", "size")));
    list.add(Tuples.pair(
            "Testing",
            Sets.mutable.with("any",
                    "all", "none", "contains", "is", "not", "corresponds", "equals", "if",
                    "comparator", "compareTo")));
    list.add(Tuples.pair(
            "Finding",
            Sets.mutable.with("detect",
                    "get", "min", "max", "find", "indexOf", "lastIndexOf", "top", "bottom",
                    "binarySearch", "occurrences")));
    list.add(Tuples.pair("Grouping", Sets.mutable.with("chunk", "group", "zip", "partitioning")));
    list.add(Tuples.pair(
            "Filtering",
            Sets.mutable.with("select", "reject", "partition", "filter", "distinct", "limit", 
                    "skip", "subList")));
    list.add(Tuples.pair("Transforming", Sets.mutable.with("collect", "flat", "zip", "map")));
    list.add(Tuples.pair(
            "Aggregating",
            Sets.mutable.with("aggregate",
                    "inject", "reduce", "reducing", "sum", "averaging", "average", "median",
                    "dotProduct", "hashCode")));
    list.add(Tuples.pair(
            "Converting",
            Sets.mutable.with("into",
                    "to", "append", "make", "joining", "flip", "key", "values", "entry",
                    "clone", "freeze")));
    list.add(Tuples.pair("Sorting", Sets.mutable.with("sort")));
    list.add(Tuples.pair("Casting", Sets.mutable.with("cast")));
    list.add(Tuples.pair(
            "Mutating",
            Sets.mutable.with("add",
                    "remove", "retain", "replace", "clear", "put", "shuffle", "set", "merge",
                    "compute", "with", "update", "swap")));
    list.add(Tuples.pair(
            "Creating",
            Sets.mutable.with("of", "concat", "empty", "unordered", "builder", "newWith", "newEmpty")));
    list.add(Tuples.pair("Closing", Sets.mutable.with("close", "onClose")));
    list.add(Tuples.pair(
            "Set Math",
            Sets.mutable.with("union", "difference", "intersect", "symmetric", "cartesian", "powerSet")));
    return list;
}

The following code shows how to pass a MutableList of Class instances to this method to create both BagMultimap instances and output them in a simple Asciidoc table.

public static void viewECReadableMethodsInClassesByCategory()
{
    countMethodsInClassesByCategory("Eclipse Collections Readable", 
        Lists.mutable.with(
            RichIterable.class,
            LazyIterable.class,
            Bag.class,
            ListIterable.class,
            SetIterable.class,
            StackIterable.class,
            MapIterable.class,
            SortedSetIterable.class,
            SortedBag.class,
            SortedMapIterable.class));
}

The following is the output of this method.

This data can be easily turned into charts, like a pie chart for each type. Here’s the Bag result as a pie chart.

Once we step past readable interfaces into mutable and immutable interfaces, the number of categories has to necessarily increase. I add a method named Mutating to capture methods like add and remove.

Here are some of the mutable collection types for Eclipse Collections.

If we look at the MutableBag type as a pie chart, it will appear as follows.

Notice how most of the operations on MutableBag are read operations, and there are only 18 write (mutating) operations. Collections can be much more useful than just data collectors and containers. I’m writing a book somewhat related to this very topic right now. Stay tuned!

Categorizing Methods in the JDK Collection Types

We could use the same categories to group methods in JDK types as well.

Let’s see what counting methods by method category for Stream would look like.

Now let’s see what will happen if we do the same for the Collectors class.

The following is the output I used for creating the pie charts for Stream and Collectors above. I used the same category naming I used for RichIterable, and added some new categories like Creating, Closing, and Sorting. Here’s a bunch of the JDK Collection related interfaces classes with methods counted by Method Category.

Let’s add a pie chart for the List interface so we can compare it to Stream.

Stream has all read-only methods, and List has mostly creating and mutating operations. This is an odd separation of data and behavior. It’s not what you would expect in an object-oriented library.

Additional Perspectives

Each of the collection types in Eclipse Collections and the JDK has a number of eager, lazy and lambda enabled methods.

• An eager method is a method that evaluates immediately and returns a result.
• A lazy method returns a result which may cause evaluation to occur at a later time, once a terminal (aka eager) method is called.
• A lambda enabled method is a method which takes at least one Functional Interface as a parameter type. A Functional Interface is an interface with a single abstract method that can be represented with a lambda (e.g., Function, Predicate, Consumer). Lambda-enabled methods can be either eager or lazy.

The following table shows a selection of types in Eclipse Collections with the counts of eager, lazy, and lambda enabled methods.

It’s possible that eager and lazy could be method categories, and so could lambda-enabled. We might want to intersect these method categories with other method categories, so we could see for instance where there are lambda-enabled filtering methods, or eager filtering methods, or lazy transforming methods, etc.

I won’t be drawing any more pie charts for these. :)

Final Thoughts

There are a lot of opportunities for increasing the comprehension of our rich class libraries, if we can find useful ways of categorizing the methods in our classes. When we are consistent in our categorization, it can make it easier to find and compare things between classes. This can also lead to us evaluating and evolving our class designs in more useful and intentional manners.

Feel free to use the code in this blog, and categorize things in ways that they make sense to you. Just because I found the categories I used here helpful for understanding Eclipse Collections types, doesn’t mean everyone will find them useful. After all, naming is hard, and method categories are very much a difficult naming exercise.

I hope you found this useful. 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. I am writing a book this year about Eclipse Collections. Stay tuned!

Sometimes you need to flip.

How do you flip a Map?

In a Map type in the Java programming language, keys are mapped to values. We specify a Map<K, V>, meaning keys of some type K are mapped to values of some type V. Lookups in Java Maps happen by key. If you want to lookup by value, you have to create a Map in the other direction. This is how you can flip a Map with unique keys and values simply by hand.

@Test
public void flipUniqueJDKMap()
{
    Map<String, Color> fruitToColor = new HashMap<>();
    fruitToColor.put("�", Color.RED);
    fruitToColor.put("�", Color.YELLOW);
    fruitToColor.put("�", Color.GREEN);
    fruitToColor.put("�", Color.ORANGE);

    Map<Color, String> colorToFruit = new HashMap<>();
    fruitToColor.forEach((k, v) -> colorToFruit.put(v, k));

    Map<Color, String> expected = Map.of(
            Color.RED, "�",
            Color.YELLOW, "�",
            Color.GREEN, "�",
            Color.ORANGE, "�");

    assertEquals(expected, colorToFruit);
}

If you use an Eclipse Collections MutableMap, there is a method named flipUniqueValues that does this.

@Test
public void flipUniqueECMap()
{
    MutableMap<String, Color> fruitToColor = Maps.mutable.with(
            "�", Color.RED,
            "�", Color.YELLOW,
            "�", Color.GREEN,
            "�", Color.ORANGE);

    Map<Color, String> colorToFruit = fruitToColor.flipUniqueValues();

    Map<Color, String> expected = Map.of(
            Color.RED, "�",
            Color.YELLOW, "�",
            Color.GREEN, "�",
            Color.ORANGE, "�");

    assertEquals(expected, colorToFruit);
}

The benefit here is not that it saved a tremendous amount of code. The benefit is that we followed the “Tell, Don’t Ask� principle of good object-oriented programming and told the MutableMap to flipUniqueValues for us. In the JDK version, we had to ask the Map for its data so that we could do the flipping ourselves. Yuck.

BiMap is a flipper

There is a type in Eclipse Collections called BiMap, which allows developers to look up either by key or value. We can consider it actively flipping every time as it maps a key to a value. With a BiMap, we can ask for the inverse which changes the directions of the keys and values.

@Test
public void biMap()
{
    BiMap<String, Color> fruitToColor = BiMaps.mutable.with(
            "�", Color.RED,
            "�", Color.YELLOW,
            "�", Color.GREEN,
            "�", Color.ORANGE);

    BiMap<Color, String> colorToFruit = fruitToColor.inverse();

    Map<Color, String> expected = Map.of(
            Color.RED, "�",
            Color.YELLOW, "�",
            Color.GREEN, "�",
            Color.ORANGE, "�");

    assertEquals(expected, colorToFruit);
}

The inverse of the BiMap is maintained and updated with each call to put. We can also see that a BiMap is a Map, as confirmed by the assertEquals method which returns true comaring a Map to a BiMap.

We can also call flipUniqueValues, which will create a copy of the BiMap using the inverse.

@Test
public void biMapFlipUniqueValues()
{
    BiMap<String, Color> fruitToColor = BiMaps.mutable.with(
            "�", Color.RED,
            "�", Color.YELLOW,
            "�", Color.GREEN,
            "�", Color.ORANGE);

    BiMap<Color, String> colorToFruit = fruitToColor.flipUniqueValues();

    Map<Color, String> expected = Map.of(
            Color.RED, "�",
            Color.YELLOW, "�",
            Color.GREEN, "�",
            Color.ORANGE, "�");

    assertEquals(expected, colorToFruit);
}

What if you need to flip non-unique values?

Oh shit. Stand back. We‘re going to need to do a double, triple, or n-flip.

Here’s how we can flip a non-unique value Map using plain old Java Map.

@Test
public void flipNonUniqueJDKMap()
{
    Map<String, Color> fruitToColor = Map.of(
            "�", Color.RED,
            "�", Color.RED,
            "�", Color.YELLOW,
            "�", Color.YELLOW,
            "�", Color.GREEN,
            "�", Color.GREEN,
            "�", Color.ORANGE,
            "�", Color.ORANGE);

    Map<Color, Set<String>> colorToFruit = new HashMap<>();
    fruitToColor.forEach((k, v) ->
            colorToFruit.computeIfAbsent(v, (c) -> new HashSet<>())
                    .add(k));

    Map<Color, Set<String>> expected = Map.of(
            Color.RED, Set.of("�", "�"),
            Color.YELLOW, Set.of("�", "�"),
            Color.GREEN, Set.of("�", "�"),
            Color.ORANGE, Set.of("�", "�"));

    assertEquals(expected, colorToFruit);
}

We’re safe making the values in the flipped Map a Set, because the keys in the first map are a Set, so will have no duplicates. I did not use a List, because there is no guarantee of order. I’d have to sort the resulting List values in order to not have a potentially “flickering� unit test.

Surely, Eclipse Collections will not be able to perform this double flip so easily.

@Test
public void flipNonUniqueECMap()
{
    MutableMap<String, Color> fruitToColor =
            Maps.mutable.with("�", Color.RED)
                    .withKeyValue("�", Color.RED)
                    .withKeyValue("�", Color.YELLOW)
                    .withKeyValue("�", Color.YELLOW)
                    .withKeyValue("�", Color.GREEN)
                    .withKeyValue("�", Color.GREEN)
                    .withKeyValue("�", Color.ORANGE)
                    .withKeyValue("�", Color.ORANGE);

    SetMultimap<Color, String> colorToFruit = fruitToColor.flip();

    SetMultimap<Color, String> expected =
            Multimaps.mutable.set.<Color, String>empty()
                    .withKeyMultiValues(Color.RED, "�", "�")
                    .withKeyMultiValues(Color.YELLOW, "�", "�")
                    .withKeyMultiValues(Color.GREEN, "�", "�")
                    .withKeyMultiValues(Color.ORANGE, "�", "�");

    assertEquals(expected, colorToFruit);
}

As we can see, the flip method on an Eclipse Collections MutableMap returns a different type, that is named SetMultimap. A SetMultimap is kind of like a Map<K, Set<V>>. But it can also do flips. Any Multimap type in Eclipse Collections can do flips.

Eclipse Collections is built to perform Parkour with Maps in Java

Let’s see what it’s like to flip a Multimap<K, V>, or a Map<K, Collection<V>>.

Here’s how we can flip a Map<K, Set<V>> in a JDK Map.

@Test
public void flipMultiValueJDKMap()
{
    Map<Color, Set<String>> colorToFruit = Map.of(
            Color.RED, Set.of("�", "�"),
            Color.YELLOW, Set.of("�", "�"),
            Color.GREEN, Set.of("�", "�"),
            Color.ORANGE, Set.of("�", "�"));

    Map<String, Set<Color>> fruitToColor = colorToFruit.entrySet()
            .stream()
            .flatMap(e -> e.getValue().stream()
                    .map(v -> Map.entry(e.getKey(), v)))
            .collect(Collectors.groupingBy(
                    Map.Entry::getValue,
                    Collectors.mapping(
                            Map.Entry::getKey, 
                            Collectors.toSet())));

    Map<String, Set<Color>> expected =
            Map.of(
                    "�", Set.of(Color.RED),
                    "�", Set.of(Color.RED),
                    "�", Set.of(Color.YELLOW),
                    "�", Set.of(Color.YELLOW),
                    "�", Set.of(Color.GREEN),
                    "�", Set.of(Color.GREEN),
                    "�", Set.of(Color.ORANGE),
                    "�", Set.of(Color.ORANGE));

    assertEquals(expected, fruitToColor);
}

Here’s how we can flip a SetMultimap in Eclipse Collections.

@Test
public void flipMultiValueECMap()
{
    SetMultimap<Color, String> colorToFruit =
            Multimaps.mutable.set.<Color, String>empty()
                    .withKeyMultiValues(Color.RED, "�", "�")
                    .withKeyMultiValues(Color.YELLOW, "�", "�")
                    .withKeyMultiValues(Color.GREEN, "�", "�")
                    .withKeyMultiValues(Color.ORANGE, "�", "�");

    SetMultimap<String, Color> fruitToColor = colorToFruit.flip();

    SetMultimap<String, Color> expected =
            Multimaps.mutable.set.<String, Color>empty()
                    .withKeyMultiValues("�", Color.RED)
                    .withKeyMultiValues("�", Color.RED)
                    .withKeyMultiValues("�", Color.YELLOW)
                    .withKeyMultiValues("�", Color.YELLOW)
                    .withKeyMultiValues("�", Color.GREEN)
                    .withKeyMultiValues("�", Color.GREEN)
                    .withKeyMultiValues("�", Color.ORANGE)
                    .withKeyMultiValues("�", Color.ORANGE);


    assertEquals(expected, fruitToColor);
}

What if you need to flip a Map of Map of counts?

It was one thing when we dealt simply with a Map, or a Map with non-unique values. When we need to deal with a Map<K, Map<V, Integer>>, the challenge of flipping is a bit more complicated. This is a good opportunity to leave a JLDD (Jet Lag Driven Development) challenge for my good friends José Paumard and Vladimir Zakharov.

Here’s a unit test that fails. Your job, if you want, is to make it pass by replacing the null with code that flips the colorToFruitCount Map.

@Test
public void flipMapOfMapOfCountsJDKMap()
{
    Map<Color, Map<String, Integer>> colorToFruitCount = Map.of(
            Color.RED, Map.of("�", 10, "�", 5),
            Color.YELLOW, Map.of("�", 5, "�", 10),
            Color.GREEN, Map.of("�", 10, "�", 5),
            Color.ORANGE, Map.of("�", 5, "�", 10));

    // JLDD Challenge - Good Luck!!!
    Map<String, Map<Color, Integer>> fruitToColorCount = null;

    Map<String, Map<Color, Integer>> expected =
            Map.of(
                    "�", Map.of(Color.RED, 10),
                    "�", Map.of(Color.RED, 5),
                    "�", Map.of(Color.YELLOW, 5),
                    "�", Map.of(Color.YELLOW, 10),
                    "�", Map.of(Color.GREEN, 10),
                    "�", Map.of(Color.GREEN, 5),
                    "�", Map.of(Color.ORANGE, 5),
                    "�", Map.of(Color.ORANGE, 10));

    assertEquals(expected, fruitToColorCount);
}

This is my JLDD submission using a BagMultimap from Eclipse Collections. Bag is “The Counter�, as my good friend Nikhil Nanivadekar would say. A BagMultimap groups and counts, and yes, it can flip.

@Test
public void flipBagMultimapECMap()
{
    MutableBagMultimap<Color, String> colorToFruitCount =
            Multimaps.mutable.bag.empty();
    colorToFruitCount.putOccurrences(Color.RED, "�", 10);
    colorToFruitCount.putOccurrences(Color.RED, "�", 5);
    colorToFruitCount.putOccurrences(Color.YELLOW, "�", 5);
    colorToFruitCount.putOccurrences(Color.YELLOW, "�", 10);
    colorToFruitCount.putOccurrences(Color.GREEN, "�", 10);
    colorToFruitCount.putOccurrences(Color.GREEN, "�", 5);
    colorToFruitCount.putOccurrences(Color.ORANGE, "�", 5);
    colorToFruitCount.putOccurrences(Color.ORANGE, "�", 10);

    BagMultimap<String, Color> fruitToColorCount = colorToFruitCount.flip();

    MutableBagMultimap<String, Color> expected =
            Multimaps.mutable.bag.empty();
    expected.putOccurrences("�", Color.RED, 10);
    expected.putOccurrences("�", Color.RED, 5);
    expected.putOccurrences("�", Color.YELLOW, 5);
    expected.putOccurrences("�", Color.YELLOW, 10);
    expected.putOccurrences("�", Color.GREEN, 10);
    expected.putOccurrences("�", Color.GREEN, 5);
    expected.putOccurrences("�", Color.ORANGE, 5);
    expected.putOccurrences("�", Color.ORANGE, 10);

    assertEquals(expected, fruitToColorCount);
}

What did you think of the flip on BagMultimap? I found a real use for it this week in some code I was writing.

A use case for a BagMultimap and flip

I didn’t just write this blog because I suddenly thought flipping fruits and colors in Maps and Multimaps would be a fun thing to do. I wrote a blog this week about taking a List of classes in Java and categorizing their methods, in code. I wrote some code to count methods in classes and group them by category. This gave me a BagMultimap<String, Class<?>>. This was interesting, but I really wanted to see a BagMultimap<Class<?>, String>. So I called flip, and voila, it was done.

Here’s the blog with the actual use case where I leveraged BagMultimap and the flip method. Enjoy!

Categorizing Methods in Java Types using Eclipse Collections

Final Thoughts

If you’re programming in Java with a collections library without productivity enhancing types like BiMap, SetMultimap, Bag, BagMultimap and parkour-esque methods like inverse, flipUniqueValues, flip, then you might be working too hard. If you’re working too hard, then you probably won’t be having fun. When we’re having fun, we’re at our most creative and can solve amazingly difficult problems. Maybe use a collections library that lets you work less hard at solving basic problems, and you’ll be able to focus your energy on solving more challenging problems. Programming is fun, and can even feel a bit like parkour if you know how to use a library like Eclipse Collections.

I’ll be publishing my first book about Eclipse Collections in the next month or two. I hope you will check out the book once it is published. The book might make programming seem more fun, because it really is. Spoiler alert: the blog I linked to above gives you a preview of some things included in the book. If you haven’t heard of method categories before, then you should definitely check out the blog. It may change the way you think about organizing your own library APIs. I’ve started conversations with various folks about enhancing Javadoc to support method categories.

I hope you found this useful. Thanks for reading, and stay tuned!

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. I am writing a book this year about Eclipse Collections. Stay tuned!

Parkour with Maps in Java was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.

Are you ready to integrate Artificial Intelligence (AI) into your custom tools or IDEs? In our latest video, we explore practical steps for building advanced, AI-powered functionality for IDEs and …

The post Building AI-Powered Tools and IDEs: Practical Techniques appeared first on EclipseSource.

Je rentre tout juste de la toute première édition de OCX, “Open Community Experience 2024”, qui s’est tenue à Mainz en Allemagne. Laissez-moi vous raconter cette expérience!

Dès mon arrivée, j’ai été frappé par l’atmosphère vibrante qui régnait. Après près de 15 ans d’EclipseCon à Ludwigsburg, ce changement de décor était le bienvenu. Mainz, avec son charme et son énergie, a insufflé un vent de fraîcheur à l’événement. Comme le disait Mélanie, nous n’étions plus coincés dans le “jour de la marmotte” du film Un jour sans fin. Cette nouvelle ville nous a offert un cadre idéal pour l’échange et la collaboration, avec des espaces confortables, des tables, des canapés et de quoi grignoter à tout moment. L’équipe technique a fait un travail remarquable, offrant une régie et une captation dignes des plus grands événements.

L’esprit accueillant et positif des communautés Eclipse était palpable. Partout où je regardais, je voyais des visages souriants, des discussions animées et une passion commune pour l’innovation open source. Nous n’étions pas de simples participants, mais de véritables acteurs et moteurs de cet écosystème dynamique.

L’une des expériences les plus mémorables pour moi a été le format “silent disco”. Imaginez une salle où se déroulent quatre présentations simultanément, chaque personne équipée d’un casque et libre de choisir ce qu’elle écoute. Au début, j’étais sceptique. Comment allions-nous nous concentrer avec autant de stimuli autour de nous ? Mais dès que la session a commencé, j’ai été conquis. Le fait de pouvoir se plonger entièrement dans une présentation, tout en étant entouré d’autres passionnés, a créé une ambiance unique. C’était à la fois ludique et incroyablement efficace pour favoriser l’attention et l’engagement.

La team Obeo était sur tous les fronts, avec pas moins de cinq présentations au programme :

• “Integrating React Flow in Sirius Web: Insights and Practical Lessons” par Stéphane Bégaudeau. Stéphane a plongé l’audience au cœur de l’intégration de React Flow dans Sirius Web, démystifiant les complexités techniques et partageant des leçons pratiques.

• “From Monolith to Modulith: The Evolution of Sirius Web’s Architecture” par Stéphane Bégaudeau et Mélanie Bats. Ensemble, ils ont exploré la transformation d’une architecture monolithique vers un “modulith”, abordant à la fois les défis technologiques et organisationnels. Leur approche holistique a offert une perspective fraîche et pertinente sur la façon de gérer l’évolution des architectures logicielles.

• “Open Innovation Unleashed: Obeo’s Journey in the Open-Source Ecosystem”, une présentation qui m’a tenu particulièrement à cœur. J’ai eu l’occasion de revisiter les 19 années de parcours d’Obeo dans l’écosystème open source. J’ai partagé nos réussites, nos défis, et comment nous avons cultivé des partenariats solides basés sur l’innovation ouverte. C’était motivant de voir combien nous avons accompli et de réfléchir aux externalités positives générées par notre modèle économique.

• “Building Graphical Web Applications: A Case Study on SysON” par Axel Richard. Axel a brillamment démontré la puissance de Sirius Web en présentant des outils graphiques web que nous pouvons créer dès aujourd’hui. Son cas d’étude sur SysON a suscité beaucoup d’enthousiasme et de questions de la part de l’audience.

• Table ronde : “OCX Open Source facing European Regulation: what’s the plan?” à laquelle j’ai participé aux côtés d’autres experts. Le sujet du Cyber Resilience Act était au centre des discussions. Nous avons exploré son impact potentiel sur les PME du secteur informatique et les communautés open source. C’était stimulant de voir autant de personnes engagées à trouver des solutions collaboratives pour naviguer dans ce nouveau paysage réglementaire.

Le Cyber Resilience Act est un enjeu majeur qui ne peut être ignoré. En tant que future réglementation européenne, il impose de nouvelles obligations en matière de sécurité, de gestion des vulnérabilités et de transparence pour toutes les entreprises fournissant des logiciels. Pour les PME comme Obeo, cela représente un défi considérable. Les premières versions du règlement menaçaient d’avoir un impact négatif sur les communautés open source. Heureusement, grâce aux efforts collectifs des différentes fondations, des ajustements ont été faits pour reconnaître le statut de “steward open-source”, allégeant ainsi certaines contraintes. Cependant, le travail ne fait que commencer. Chez Obeo, nous sommes déterminés à collaborer avec la communauté pour développer des modes de fonctionnement qui répondent à ces exigences tout en préservant l’esprit d’innovation.

C’est dans cet esprit que nous participons activement au Open Regulatory Compliance Working Group. Cette initiative est une formidable opportunité de façonner collectivement l’avenir du logiciel libre en matière de conformité, en commençant par le Cyber Resilience Act. Ensemble, nous pouvons assurer que les normes de conformité restent accessibles et adaptées aux réalités des PME et des projets open source.

En parcourant les couloirs de l’OCX, j’ai également été frappé par l’importance croissante du logiciel libre dans des secteurs d’ingénierie complexes comme l’automobile. La dynamique autour de la communauté Eclipse Software Defined Vehicle en est une preuve éclatante. Voir comment des industries traditionnelles embrassent l’open source pour innover et relever les défis technologiques m’a rempli d’optimisme. Cela renforce notre conviction chez Obeo que l’open source est un catalyseur puissant pour le progrès.

En quittant Mainz, je me sens revigoré et inspiré. Cette première édition de l’OCX a été plus qu’une simple conférence. C’était une célébration de la collaboration, de l’innovation et de la passion qui animent notre communauté. Je suis impatient de voir comment les idées et les connexions forgées ici façonneront les prochaines étapes d’Obeo et de l’écosystème open source.

Un immense merci à tous ceux qui ont rendu cet événement possible. Votre dévouement et votre enthousiasme sont le moteur qui nous pousse à aller toujours plus loin. Rendez-vous à la prochaine édition, à Bruxelles, pour écrire ensemble le prochain chapitre de cette aventure passionnante !

Voici les slides que j’ai présenté :

Open Community Experience 2024: Obeo était là! was originally published by Cédric Brun at CEO @ Obeo on October 25, 2024.

I have just returned from the very first edition of OCX, “Open Community Experience 2024”, which was held in Mainz, Germany. Let me share this experience with you!

From the moment I arrived, I was struck by the vibrant atmosphere. After nearly 15 years of EclipseCon Europe in Ludwigsburg, this change of scenery was most welcome. Mainz, with its charm and energy, breathed new life into the event. As Mélanie put it, we were no longer stuck in the “Groundhog Day” from the movie. This new city offered us an ideal setting for exchange and collaboration, with comfortable spaces, tables, sofas, and snacks available at any time. The technical team did a remarkable job, providing production and recording worthy of the biggest events.

The welcoming and positive spirit of the Eclipse communities was palpable. Everywhere I looked, I saw smiling faces, lively discussions, and a shared passion for open-source innovation. We were not just participants but true actors and drivers of this dynamic ecosystem.

One of the most memorable experiences for me was the “silent disco” format. Imagine a room where four presentations are happening simultaneously, each person equipped with headphones and free to choose what they listen to. Initially, I was skeptical. How were we going to concentrate with so many stimuli around us? But as soon as the session began, I was won over. Being able to fully immerse oneself in a presentation while surrounded by other enthusiasts created a unique atmosphere. It was both fun and incredibly effective in promoting attention and engagement.

The Obeo team was on all fronts, with no less than five presentations on the program:

• “Integrating React Flow in Sirius Web: Insights and Practical Lessons” by Stéphane Bégaudeau. Stéphane plunged the audience into the heart of integrating React Flow into Sirius Web, demystifying technical complexities and sharing practical lessons.

• “From Monolith to Modulith: The Evolution of Sirius Web’s Architecture” by Stéphane Bégaudeau and Mélanie Bats. Together, they explored the transformation from a monolithic architecture to a “modulith,” addressing both technological and organizational challenges. Their holistic approach offered a fresh and relevant perspective on managing the evolution of software architectures.

• “Open Innovation Unleashed: Obeo’s Journey in the Open-Source Ecosystem”, a presentation particularly close to my heart. I had the opportunity to revisit Obeo’s 19-year journey in the open-source ecosystem. I shared our successes, our challenges, and how we’ve cultivated strong partnerships based on open innovation. It was motivating to see how much we’ve accomplished and to reflect on the positive externalities generated by our economic model.

• “Building Graphical Web Applications: A Case Study on SysON” by Axel Richard. Axel brilliantly demonstrated the power of Sirius Web by presenting web graphical tools that we can create today. His case study on SysON generated a lot of enthusiasm and questions from the audience.

• Panel Discussion: “OCX Open Source Facing European Regulation: What’s the Plan?” in which I participated alongside other experts. The topic of the Cyber Resilience Act was central to the discussions. We explored its potential impact on IT SMEs and open-source communities. It was stimulating to see so many people committed to finding collaborative solutions to navigate this new regulatory landscape.

The Cyber Resilience Act is a major issue that cannot be ignored. As a forthcoming European regulation, it imposes new obligations regarding security, vulnerability management, and transparency for all companies providing software. For SMEs like Obeo, this represents a considerable challenge. The initial versions of the regulation threatened to have a negative impact on open-source communities. Fortunately, thanks to the collective efforts of various foundations, adjustments have been made to recognize the status of “open-source steward,” thereby easing some constraints. However, the work is just beginning. At Obeo, we are determined to collaborate with the community to develop operating methods that meet these requirements while preserving the spirit of innovation.

In this spirit, we are actively participating in the Open Regulatory Compliance Working Group. This initiative is a tremendous opportunity to collectively shape the future of open-source software in terms of compliance, starting with the Cyber Resilience Act. Together, we can ensure that compliance standards remain accessible and adapted to the realities of SMEs and open-source projects.

Walking through the halls of OCX, I was also struck by the growing importance of open-source software in complex engineering sectors like automotive. The dynamism around the Eclipse Software Defined Vehicle community is a shining example. Seeing how traditional industries embrace open source to innovate and tackle technological challenges filled me with optimism. This reinforces our conviction at Obeo that open source is a powerful catalyst for progress.

Leaving Mainz, I feel invigorated and inspired. This first edition of OCX was more than just a conference. It was a celebration of collaboration, innovation, and the passion that drives our community. I am eager to see how the ideas and connections forged here will shape the next steps for Obeo and the open-source ecosystem.

A huge thank you to everyone who made this event possible. Your dedication and enthusiasm are the driving force that pushes us to go ever further. See you at the next edition in Brussels, to write together the next chapter of this exciting adventure!

Here are the slides I presented:

Open Community Experience 2024: Obeo was there! was originally published by Cédric Brun at CEO @ Obeo on October 25, 2024.

How an experiment with 64-bit Pharo Smalltalk surprised me.

The 32-bit party that doesn’t want to end

I haven’t programmed professionally in Smalltalk since Y2K. I only worked professionally in 32-bit versions of Smalltalk. Every once in a while I try some things out in the Pharo dialect of Smalltalk, which has had a 64-bit version for a few years now. I waited a long time for an open source version of Smalltalk to support 64-bit addressing. I have been using 64-bit versions of Java for the past 18 years.

I’ve been wondering when Java will finally provide built-in support for large arrays, meaning arrays with a length of more than 2³¹-1. The Java Collections Framework and all frameworks that implement the built in collection interfaces like Collection, List, Set, Map all max out at an int size. There can be at most 2³¹-1 things stored in an array in Java. (Update: I learned from a post on Hacker News from Stuart Marks the max array size in the Java Hotspot JVM is actually 2³¹-2. I confirmed this in a test.) For all intents and purposes, this imposes a limit of storing slightly more than 2 billion objects or primitives in an array in Java. There are third party libraries that provide BigArrays like fastutil, and we can simulate large arrays ourselves by using multi-dimensional arrays in Java, but this becomes trickier to manage. Better to use a well-tested third party library than recreate hard to test and find bugs.

I was curious if 64-bit Pharo Smalltalk would be able to store more than 2³¹-1 elements in an array. I knew one way I could find out. I would need a lot of RAM for this experiment. Thankfully, I bought a new Mac Book Pro M2 Max last year with 96GB of RAM so I could experiment and test with larger memory footprints.

The newest MacBook Pro M3 Max supports up to 128GB of RAM today. This is an impressive leap from just over a year ago when I bought my MacBook Pro M2 Max series with 96GB RAM. 128GB is double what I have in my 10 year old Mac Pro trash can on my desktop, and 8x more than I had in my 10 year old MacBook Pro laptop. The 2019 version of the Mac Pro supports up to a whopping 1.5TB of RAM. The current Apple Silicon Mac Pro (2023) offers a max configuration of 192GB of RAM which is 3x what my 10 year old Mac Pro has. I suspect in another 10 years we will see 256GB+ RAM on high end commercial laptops, and easily TB+ RAM on high end commercial desktops.

Note: Server class machines can be configured with terabytes of RAM today.

Who needs more than 2 billion elements in an array?

I haven’t needed more than hundred million elements stored in a List in the past 20 years. That is still quite a large number of things, and I needed that around 2006 for the domain I was working in. I’m sure there are some folks who deal with domains that require enormous amounts of data in memory.

Estimates say there are ~8.2 billion people on the planet today. It would currently take four Java arrays to store references to all people in memory. It would be very expensive to hold 8.2 billion simple Person objects in memory. By simple Person object I am thinking of a Person class with first, middle, and last names as String instances. The cost of the array storage alone would be over 65GB (~8.2 billion x 8 bytes per reference). The cost of the Person instances would far exceed my current available memory on my MacBook Pro laptop which is pretty large at 96GB. Let’s estimate maybe 8.2 billion * 32 bytes for the Person instances which would measure at ~262GB. In total, we ‘d need 327GB of RAM to fit everyone with their first, middle, and last names in memory. We could pool the String names, which probably would probably unique down to a few hundred million instances so maybe we’d need 32 GB or more for the String instances. We’re not quite there yet in terms of commercially available desktop hardware. This would be possible with high end servers with terabytes of RAM.

This got me wondering. What if we started smaller than a Person, and went with an object like SmallInteger in Pharo Smalltalk. I started experimenting with creating arrays larger than 2³¹-1 in Pharo. I would learn during the experiment that Pharo Smalltalk provides a great optimization for SmallInteger. Instead of storing references to SmallInteger objects, the actual values of the SmallInteger are stored inline. This felt like the promise of value types we have been hearing about from Project Valhalla in the Java space. I figured this out by doing a bit of digging and experimenting with using the simple sizeInMemory method. I was confused at first when the size reported for a SmallInteger instances was zero. This suggested to me that SmallInteger was getting some special handling in the language. I was also surprised that SmallInteger went beyond the max value for an int in Java.

Transcript show: SmallInteger maxVal.

// Prints - 1152921504606846975
// SmallInteger  -> 1,152,921,504,606,846,975
// Max Java long -> 9,223,372,036,854,775,807

This value seemed more like a long in Java. The value in Java of Long.MAX_VALUE = 9,223,372,036,854,775,807.

The article linked here explains the maximum value of SmallInteger in Smalltalk as well as how it is stored as values instead of as references. SmallInteger uses 61 bits instead of 64.

The biggest difference between Smalltalk’s SmallInteger and Java’s long is what you get when you add one to the maximum value.

In Smalltalk, we get a LargePositiveInteger. Dynamic typing to the rescue.

Transcript cr; show: SmallInteger maxVal.
Transcript cr; show: SmallInteger maxVal class.
Transcript cr; show: SmallInteger maxVal + 1. 
Transcript cr; show: (SmallInteger maxVal + 1) class.

// Prints
// 1152921504606846975
// SmallInteger
// 1152921504606846976
// LargePositiveInteger

When we add 1 to the maximum value of a SmallInteger, Smalltalk dynamically creates an instances of a LargePositiveInteger. This is a benefit of a dynamic language where everything is an object.

In Java, we get a silent but potentially deadly overflow.

System.out.println(BigInteger.valueOf(Long.MAX_VALUE));
System.out.println(BigInteger.valueOf(Long.MAX_VALUE + 1));

// Prints
// 9223372036854775807
// -9223372036854775808

Adding 1 to the maximum value of a long results in an overflow, and the result becomes negative. We cannot dynamically change the type from a long to anything else in Java. What’s long is long, and what’s short is short. This is one place where static typing and primitive types fall short. We have learned to deal with it in Java.

So let’s move on and see the experiments I tried.

The Experiments

I couldn’t settle with having a solution in Smalltalk without trying a solution in Java. Pharo Smalltalk gave me all the tools I needed. In Java, I used a combination of fastutil and Eclipse Collections libraries to repeat the experiment in Java. The great thing about Java is that the ecosystem is rich and vibrant, and folks have built solutions to most problems you may face.

Pharo Smalltalk Version

I started off with storing 5 billion SmallInteger instances in an Array in Pharo. Once I saw this worked, I bumped the total number up to 8.2 billion. Things still worked. Then I tried 10 billion. It still worked. I was very surprised. I didn’t think I would have enough RAM for 10 billion. This is because I didn’t understand at the time how Smalltalk treats SmallInteger “instances”.

This is the source for the 10 billion element experiment. You’ll need 96GB with around 85GB free to run this code. You can downgrade to 5 billion if you have 64GB of RAM.

|array sum|

array := (1 to: 10000000000) collect: [ :each | each * 2 ].
sum := array sum.

Transcript cr; show: array size class.
Transcript cr; show: array size.
Transcript cr; show: sum.
Transcript cr; show: sum class.

(1 to: 10000000000 by: 1000000000) do: [ :index | Transcript cr; 
 show: 'index: '; 
 show: index; 
 show: ' value: '; 
 show: (array at: index);
 show: ' ';
 show: (array at: index) class ].

Transcript cr; show: 'Array memory (bytes) '; 
  show: array sizeInMemory. 
Transcript cr; show: 'Elements memory (bytes) '; 
  show: (array sumNumbers: #sizeInMemory). 

The results for this code is as follows:

SmallInteger
10000000000
100000000010000000000
LargePositiveInteger
index: 1 value: 2 SmallInteger
index: 1000000001 value: 2000000002 SmallInteger
index: 2000000001 value: 4000000002 SmallInteger
index: 3000000001 value: 6000000002 SmallInteger
index: 4000000001 value: 8000000002 SmallInteger
index: 5000000001 value: 10000000002 SmallInteger
index: 6000000001 value: 12000000002 SmallInteger
index: 7000000001 value: 14000000002 SmallInteger
index: 8000000001 value: 16000000002 SmallInteger
index: 9000000001 value: 18000000002 SmallInteger
Array memory (bytes) 80000000016
Elements memory (bytes) 0

What these results show is that there is no extra cost for the SmallInteger instances. The SmallInteger values are inlined into the Array. So the Array storage is all we need, which is ~80GB.

Java w/ fastutil version

This is the source for the 10 billion element experiment in Java. You’ll need 96GB and 85GB free to run this code. I added a commmand line setting of -Xmx85g. You can downgrade to 5 billion if you have 64GB of RAM. I used fastutil for a big long list. I used Eclipse Collections to sum BigInteger. You’ll see why I needed to use BigInteger in the results below.

First, I added a Maven dependency on the fastutil library.

<dependency>
    <groupId>it.unimi.dsi</groupId>
    <artifactId>fastutil</artifactId>
    <version>8.5.14</version>
</dependency>

Then I wrote a test that uses a LongBigArrayBigList to store 10 billion longs. This is roughly the equivalent of the 10 billion element array in Smalltalk storing SmallInteger.

@Test
public void fastutilTenBillion()
{
    LongBigArrayBigList longs = new LongBigArrayBigList(10_000_000_000L);
    LongStream.rangeClosed(1, 10_000_000_000L)
            .forEach(l -> longs.add(l * 2));

    long sum = longs.longStream().sum();
    BigInteger bigSum = longs.longStream()
            .boxed()
            .collect(Collectors2.summingBigInteger(BigInteger::valueOf));

    System.out.println("size: " + longs.size64());
    System.out.println("long sum: " + sum);
    System.out.println("BigInteger sum: " + bigSum);

    for (long l = 0; l < 10_000_000_000L; l += 1_000_000_000L)
    {
        System.out.println("index: " + l + " value: " + longs.getLong(l));
    }
}

The results are as follows:

size: 10000000000
long sum: 7766279641452241920
BigInteger sum: 100000000010000000000
index: 0 value: 2
index: 1000000000 value: 2000000002
index: 2000000000 value: 4000000002
index: 3000000000 value: 6000000002
index: 4000000000 value: 8000000002
index: 5000000000 value: 10000000002
index: 6000000000 value: 12000000002
index: 7000000000 value: 14000000002
index: 8000000000 value: 16000000002
index: 9000000000 value: 18000000002

Now, the first thing that might jump out at you if you weren’t expecting it is that Java uses zero-based indexing, and Smalltalk uses one-based indexing. The values are at the correct indexes. We just have to adjust the indexes by one when comparing the results

The next thing you will notice is that the long sum and the BigInteger sum are different. Why is that?

The following test will show us why.

@Test
public void longMaxValue()
{
    BigInteger maxLong = BigInteger.valueOf(Long.MAX_VALUE);
    BigInteger sum = new BigInteger("100000000010000000000");
    System.out.println(maxLong);
    System.out.println(sum);
}

The results are as follows:

9223372036854775807    // Max Long Value in Java
100000000010000000000  // Sum of 10 billion long values

The maximum long is two digits shorter than the sum. Summing ten billion numbers that are doubled, results in a number larger than the maximum long value. This is why I had to construct the BigInteger for the sum using a String. The value is too big for a long literal. I honestly wasn’t expecting to see this test overflowing a long value. This is more typical when using int values. The max long value is HUGE. Not huge enough as it turns out for this example/

When I saw the sum was incorrect, I decided to try the Collectors2.summingBigInteger() Collector from Eclipse Collections. This worked fine with the downside that I had to box the long values in the LongStream to Long objects and then again to BigInteger objects. It’s possible I could have stared at the code for a few more minutes and figured out a way to just use the “Three-musketeer” collect method on LongStream, but it requires a mutating result, so I didn’t bother.

Reflections on software imposed limits

Most developers will not need arrays that support more than 2³¹-1 elements this year. The same will probably be true next year. In 5, 10, or 20 years this number will begin creeping up on more folks as big data problems become more commonplace. 2³¹-1 sized collection limits may become more problematic. We have solutions built in Java if we need a sum bigger than an int or long. It’s challenging sometimes writing fast and correct software when you’re face with limits of primitives and arrays.

In the late 1980s and early 1990s no one needed more than 640K of RAM. Now we can get 128GB of RAM on a commercial grade laptop. Our great-grandchildren may laugh when they hear about how we suffered using only 64-bit computing. The trend in computing hardware is always that we get more.

When we encounter hardware or software imposed limits, we have to find solutions. I’ve dealt with memory constrained environments since I began programming professionally in the late 1980s. The hardware and software almost always has found a way to catch up just in time. When it doesn’t, we need to be creative.

Sweating the small stuff in Java

Java has many important problems to solve. I don’t know when the max array size issue will become a priority for Java. I suspect it will be in the next decade. In the mean time, libraries like fastutil can help fill the void.

One thing I continue to admire about the dynamic nature of Smalltalk is its ability to adapt. Just add one more thing that will threaten to push you over the edge, and Smalltalk will pleasantly surprise you and return a different type that can handle it. I miss this aspect of Smalltalk.

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. I am writing a book this year about Eclipse Collections. Stay tuned!

We are happy to announce the Eclipse Theia 1.54 release! The release contains 59 merged pull requests. In this article, we will highlight some selected improvements and provide an overview of the …

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

Jet Lag Driven Development resumes at the inaugural dev2next conference

My friend José Paumard arrived at the dev2next conference in Denver (DEN), Colorado with a gift. He offered an opportunity to participate in a “new” Jet Lag Driven Development (JLDD) challenge. The challenge was apparently one that we had discussed previously, but hadn’t implemented at a conference years ago. Better late than never. Let’s go!

The Challenge

The problem as described was to split letters in a String into lists. Every change in letters should result in a new list. Duplicates will be added to the same list, but only when they are in order together. Here’s an example of several String instances being converted to a List of List of char values.

"" -> []
"aaa" -> [['a', 'a', 'a']]
"abc" -> [['a'], ['b'], ['c']]
"aabbaa" -> [['a', 'a'], ['b', 'b'], ['a', 'a']]
"abbccdc" -> [['a'], ['b','b'], ['c', 'c'], ['d'], ['c']]

Solution 1: Java Stream w/ a custom Collector

Here’s a solution I came up with using Java Streams.

Here is the test code for various examples.

@Test
public void letterSplitterStreamTests()
{
    Assertions.assertEquals(
            List.of(),
            this.letterSplitterStream(""));
    Assertions.assertEquals(
            this.expectedListStream("a", "b", "cc", "d", "ee", "f"),
            this.letterSplitterStream("abccdeef"));
    Assertions.assertEquals(
            this.expectedListStream("aaaa"),
            this.letterSplitterStream("aaaa"));
    Assertions.assertEquals(
            this.expectedListStream("aa", "bb", "aa"),
            this.letterSplitterStream("aabbaa"));
    Assertions.assertEquals(
            this.expectedListStream("a", "b", "c"),
            this.letterSplitterStream("abc"));
}

private List<List<Character>> expectedListStream(String... strings)
{
    return Stream.of(strings)
            .map(s -> s.chars()
                    .mapToObj(i -> (char) i)
                    .toList())
            .toList();
}

Here’s the solution code in the letterSplitterStream method.

public List<List<Character>> letterSplitterStream(String value)
{
    var collector = Collector.of(
            ArrayList::new,
            (List<List<Character>> list, Character c) -> {
                List<Character> charList =
                        list.isEmpty() ? null : list.getLast();
                if (charList == null || !charList.contains(c))
                {
                    list.add(charList = new ArrayList<>());
                }
                charList.add(c);
            },
            (l, r) -> {throw new UnsupportedOperationException();},
            Collector.Characteristics.IDENTITY_FINISH);

    return value.chars()
            .mapToObj(i -> (char) i)
            .collect(collector);
}

I used var in this solution to simplify the code. If this code looks confusing using var, here’s the type for the collector variable.

Collector<Character, List<List<Character>>, List<List<Character>>>

The Collector.of() call takes four parameters — A Supplier, a BiConsumer, a BinaryOperator, and a Characteristics array. I made a conscious decision to not support parallelism using the Stream solution, so the BinaryOperator that would normally be implemented merging results throws an UnsupportedOperationException.

Each int value in the IntStream returned by calling chars is cast to a char and converted to a Character in the call to mapToObj. The call to collect passes in the Collector that was created above.

The Supplier simply creates a new ArrayList. The BiConsumer lambda does all the work here. I will leave it as an exercise to the reader to understand how the code in the BiConsumer works.

Solution 2: Eclipse Collections CharAdapter

The first solution I wrote was actually the Eclipse Collections solution, but I thought it would be useful to show the Stream solution first, as most Java developers should be familiar with Java Stream code by now.

Here is the test code for various examples using Eclipse Collections.

@Test
public void letterSplitterTests()
{
    Assertions.assertEquals(
            Lists.mutable.empty(),
            this.letterSplitter(""));
    Assertions.assertEquals(
            this.expectedList("a", "b", "cc", "d", "ee", "f"),
            this.letterSplitter("abccdeef"));
    Assertions.assertEquals(
            this.expectedList("aaaa"),
            this.letterSplitter("aaaa"));
    Assertions.assertEquals(
            this.expectedList("aa", "bb", "aa"),
            this.letterSplitter("aabbaa"));
    Assertions.assertEquals(
            this.expectedList("a", "b", "c"),
            this.letterSplitter("abc"));
}

private MutableList<CharList> expectedList(String... strings)
{
    return Lists.mutable.with(strings).collect(Strings::asChars);
}

Here’s the solution code in the letterSplitter method.

public MutableList<MutableCharList> letterSplitter(String value)
{
    return Strings.asChars(value).injectInto(
            Lists.mutable.empty(),
            (list, c) -> {
                MutableCharList charList = list.getLast();
                if (charList == null || !charList.contains(c))
                {
                    return list.with(CharLists.mutable.with(c));
                }
                charList.add(c);
                return list;
            });
}

The method injectInto is available on both Object and primitive collections in Eclipse Collections. The call to Strings.asChars(value) creates a CharAdapter object. The method injectInto takes an initial parameter that will be used as a mutable accumulator and will be the return result of the Function2 lambda that is the second parameter. The implementation of the Function2 should look similar to the BiConsumer in the Collector example. The major difference is that the char values do not need to be boxed as Character objects when using Eclipse Collections because we can use a MutableCharList. There are some other minor differences which are the result of some convenient methods available in Eclipse Collections.

Update: Solution 3: String.chars().forEach()

I wasn’t quite satisfied with the complexity of using a custom Collector, so thought I would just write a version using String.chars().forEach(). The code is similar to the code in the BiConsumer, without all the excess boilerplate code required.

public List<List<Character>> letterSplitterForEach(String value)
{
    List<List<Character>> list = new ArrayList<>();
    value.chars().forEach(i -> {
        Character c = (char) i;
        List<Character> charList =
                list.isEmpty() ? null : list.getLast();
        if (charList == null || !charList.contains(c))
        {
            list.add(charList = new ArrayList<>());
        }
        charList.add(c);
    });
    return list;
}

@Test
public void letterSplitterForEachTests()
{
    Assertions.assertEquals(
            List.of(),
            this.letterSplitterForEach(""));
    Assertions.assertEquals(
            this.expectedListStream("a", "b", "cc", "d", "ee", "f"),
            this.letterSplitterForEach("abccdeef"));
    Assertions.assertEquals(
            this.expectedListStream("aaaa"),
            this.letterSplitterForEach("aaaa"));
    Assertions.assertEquals(
            this.expectedListStream("aa", "bb", "aa"),
            this.letterSplitterForEach("aabbaa"));
    Assertions.assertEquals(
            this.expectedListStream("a", "b", "c"),
            this.letterSplitterForEach("abc"));
}

Update: Solution 4: CharAdapter.forEach()

Since I wrote a Java Stream version using IntStream.forEach(), I figured I might as well write a CharAdapter.forEach(). Enjoy!

public MutableList<MutableCharList> letterSplitterForEachEC(String value)
{
    MutableList<MutableCharList> list = Lists.mutable.empty();
    Strings.asChars(value).forEach(c -> {
        MutableCharList charList = list.getLast();
        if (list.isEmpty() || !charList.contains(c))
        {
            list.add(charList = CharLists.mutable.empty());
        }
        charList.add(c);
    });
    return list;
}

@Test
public void letterSplitterForEachECTests()
{
    Assertions.assertEquals(
            Lists.mutable.empty(),
            this.letterSplitterForEachEC(""));
    Assertions.assertEquals(
            this.expectedList("a", "b", "cc", "d", "ee", "f"),
            this.letterSplitterForEachEC("abccdeef"));
    Assertions.assertEquals(
            this.expectedList("aaaa"),
            this.letterSplitterForEachEC("aaaa"));
    Assertions.assertEquals(
            this.expectedList("aa", "bb", "aa"),
            this.letterSplitterForEachEC("aabbaa"));
    Assertions.assertEquals(
            this.expectedList("a", "b", "c"),
            this.letterSplitterForEachEC("abc"));
}

Summary

This was a fun and relatively straightforward challenge. The tricky part was trying to write it in as little code as possible. I’m excited to see the solution(s) that José Paumard comes up with. I’d also love to see other alternative solutions folks can come up with. The challenge is open!

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. I am writing a book this year about Eclipse Collections. Stay tuned!

In recent years, the rise of AI-powered code development tools has introduced new possibilities for significantly improving developer productivity and streamlining workflows. However, most of these …

The post Introducing AI Support in Theia IDE: The First Open, Transparent AI-Enhanced Development Environment appeared first on EclipseSource.

There is a growing demand for powerful tools and IDEs that seamlessly integrate AI capabilities across all industries. However, creating such AI-powered tools from scratch involves significant effort. …

The post Introducing Theia AI: Build AI-Enhanced Tools with Ease! appeared first on EclipseSource.

After a longer time of “bugfix releases” only, the Eclipse Ditto team is once again happy to announce the availability of a new minor release, including new features: Ditto 3.6.0.

The most work in this release went into the enforcement/validation of a linked WoT (Web of Thing) “Thing Model” to make sure that a Ditto managed digital twin can only be modified in ways which are valid based on the defined WoT model.

But also other features like SSO in the Ditto-UI were added, so inform yourself in this blogpost about the changes in the new release.

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.6.0 are:

• WoT (Web of Things) Thing Model based validation of modifications to things and action/event payloads
• AWS IAM based authentication against MongoDB
• Configure defined aggregation queries to be exposed as Prometheus metrics by Ditto periodically
• SSO (Single-Sign-On) support in the Ditto UI via OpenID connect provider configuration

The following non-functional work is also included:

• Update Java runtime to run Eclipse Ditto with to Java 21
• Run Ditto system tests in GitHub actions

The following notable fixes are included:

• Fix JWT placeholder not resolving correctly in JSON arrays nested in JSON objects
• Fix retrieving a Thing at a given historical timestamp
• Generating UNIX “Epoch” as neutral element when creating new things based on WoT TM models for types declared as “date-time” format

Please have a look at the 3.6.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

A wonderful new tech conference organized by Dr. Venkat Subramaniam

A Conference and Travel Blog

Attending a tech conference with the backdrop of the Colorado Rockies was too much for me to pass by this year. I’ve been writing a book about Eclipse Collections for the past nine months. I had planned on not speaking at any tech conferences this year, so I wouldn’t have to divert time from writing to prepare slide decks and travelling. Best-laid plans.

Plan is nothing. Planning is everything.

My long time friend Vladimir Zakharov asked me early in 2024 if I wanted to submit a talk with him to dev2next. The dev2next conference was the brain child and hard work of Dr. Venkat Subramaniam and several other folks, and was being held near Denver, Colorado at the end of September 2024. I thought about it for a little bit and said yes. At the time I said yes, I had also planned on attending JCrete 2024. JCrete didn’t require any slide preparation in advance. I did wind up hosting a session at this amazing Unconference about walking the long road of open source. You can read about my JCrete adventures in my blog linked below.

My First and Second JCrete Unconference Experiences

Thankfully, our talk proposal was accepted, and we began preparing for the talk. Duke and Duchess on Nails made a splash appearance at dev2next as well. I wrote about the latest nail art my wife brought to a tech conference a few days before dev2next started.

Nailed it, again

This blog has a mixture of travel experiences and conference experiences. I hope you will enjoy both!

Day 1

The first day of the conference was workshops. I decided not to attend any of the workshops and instead take the morning to explore some of the recommended places to visit on the conference web site that were reasonably close by. We went to the Red Rocks Park and Amphitheater and the Garden of the Gods, which is in Colorado Springs.

Red Rocks Park and Amphitheater

The Red Rocks Park took a little over a half hour to get to. We didn’t spend too much time here but got some great pictures. We wanted to go to the Garden of the Gods as well and make it back in time for the Conference Dinner and Kickoff.

Garden of the Gods

The Garden of the Gods is a free park in Colorado Springs. This was about an hour south of where the conference was held, but was totally worth the drive. Next year, the conference will be held in Colorado Springs, so this site becomes a very convenient place for folks to visit and spend time. It is an extraordinarily beautiful natural rock garden. I’m sharing a small number of pictures that I took so as to give a feel for some of what you can see in the garden, without spoiling the surprise of some of the amazing things I haven’t shared.

Conference Dinner and Kickoff (Monday)

The start of the conference kicked off with a dinner at 6pm on Monday evening. I got to meet up with some of my friends before the dinner.

We got to hear that the dev2next conference would be held again next year, only this time at Colorado Springs. This will be convenient for anyone wanting to hike through the Garden of the Gods, which I can now highly recommend.

Day 2 (Tuesday)

I ran into Mark Heckler right before our talk, and got a nice selfie with him. This reminded me of a selfie we took a year earlier in an airport lounge in Newark airport when we were both headed to Devoxx Belgium in 2023. I am wearing an Eclipse Collections t-shirt with the top ten reasons to use Eclipse Collections listed on the back. My wife made this t-shirt for me right before the pandemic. The top ten list will show up just a little further on in this blog.

Data Frames in Java Talk with Vladimir Zakharov

I had the distinct pleasure of giving a talk with my great friend Vladimir Zakharov. I told the story during our talk that this was the second time I was giving a public talk with Vlad. The first time we gave a talk together was in 2010 at GIDS in Bengaluru. It was an honor to give a talk with Vlad about an open source library he created and is the maintainer for. It was even more special as I got to explain how Vlad’s library used the open source library I created and am a maintainer for.

Vlad and I delivered our talk on Data Frames in Java in the 10:45am spot. It was nice going early in the week, so we could just relax and attend other sessions we wanted to see. Our talk had a decent attendance and a bunch of great questions throughout the 75 minute talk. We filled up all 75 minutes with some high quality content.

If you missed the conference and our talk, or just want to recall what we covered, you can find the slides and code in GitHub here. If you want to read a great blog comparing the performance and footprint of Data Frame libraries in different languages when competing in the One Billion Row Challenge (1BRC), then check out this amazing blog from Vlad.

Here’s a teaser slide with the 8 of 10 top features that dataframe-ec uses from Eclipse Collections. Note: the “ec� in dataframe-ec stands for Eclipse Collections.

The dataframe-ec library uses features from all the lines with green check marks.

void main()

I attended the talk from my former colleagues and fellow Java Champions, Rodrigo Graciano and Chandra Guntur. This talk covered Java features from Java 9 through to Java 23. Rodrigo and Chandra live coded refactoring a Java 8 application to leverage the new Java features. The talk was standing room only. Chocolates were given out to anyone who asked a good question. Lots of chocolates were given out. This was a very engaging and enjoyable talk.

After the “void main()� talk, I got a selfie with Chandra. Every day is a great day when I get to catch up with Chandra.

Speaker Dinner

The speaker dinner was held at Top Golf. I am not a golfer, but have been to driving ranges like Top Golf before. I never played the golf video games before but we had fun doing this as a group. Somehow I managed to hit the balls well enough to wind up on top of the scoreboard at the end of the night. My structure and form was terrible, but like software development, what matters is delivery.

We had a mini celebration with some ice cream at Top Golf for Venkat and his fellow organizers to thank them for putting together their first tech conference. Congrats, Venkat!

Day 3 (Wednesday)

My wife had never been to Colorado before. It had been about 27 years since I was last in Boulder Colorado for C++ training, when I worked for IBM Global Services. I decided to take some time in Wednesday morning to go to see some foliage and mountains not too far from Denver.

I asked Matt Raible for some recommendations close by and one of them was Golden Gate Canyon State Park. It took us about an hour to drive there, and we got to get up to an elevation of 9,300 feet. By Wednesday, the effects of the elevation change had started to settle for both myself and my wife, so we felt comfortable enough to go a little higher up. The views were beautiful.

When we first drove up the mountain, we completely missed the visitor center. We saw the visitor center after driving up and back down.

We bought the $10 park pass at the visitor center, and drove back up to Panorama Point which we didn’t know about when we first drove up.

We made it back in time for me to take in a couple sessions in the afternoon.

Data Oriented Programming talk with José Paumard

I always enjoy seeing José speak. I also enjoy taking time at conferences to issue and respond to Jet Lag Driven Development (JLDD) challenges with José. We have a challenge from dev2next that we will share the results of soon hopefully.

The most important takeaway from José’s talk for me was what I am calling “Visitor Inversion Programming.� Using Pattern Matching for Switch, we can remove the cyclic dependency that the Visitor Pattern introduces in a static language like Java. The dependency moves to the Visitor, and knowledge of the Visitor can be removed from the classes that are Visited.

Application Integration Patterns: When to use what?

My former colleague, fellow Java Champion, and fellow Eclipse Collections Project Lead, gave a talk on Integration Patterns. Can you guess his name? That’s right, Nikhil Nanivadekar.

I always enjoy seeing Nikhil speak, and this talk had a lot of useful and fun information, including some tips on baking bread.

Day 4 (Thursday)

On the last day of the conference I attended several great talks.

Spring Cloud Gateway MVC and Virtual Threads w/ Spencer Gibb

I was very excited to meet Spencer Gibb in person, so I attended his talk in the early morning. It was neat to see how easy it is to switch Spring to use Virtual Threads with a simple change in a YAML file.

I got to have a nice long chat with Spencer later in the evening sitting outside of the hotel by a raging fire pit. It’s always nice when you get to meet a person you have been connected to for a while on social media. This was a wonderful way to end the conference days before heading home on Friday.

“Code Review, you said?� with Dr. Venkat Subramaniam

Attending a conference organized by the one and only Dr. Venkat Subramaniam would not have been complete if I did not attend a session with Venkat. This session on code reviews was simply awesome. I’m including a couple of pictures which meant a lot to me.

I write terrible code too. I love getting code review feedback so I can learn and improve.

If you contribute to an open source project, I recommend submitting small pull requests. I frequently tell folks the chance of getting any feedback and a successful merge of a large (e.g. 50+ file) code review is really small. Volunteers don’t have the time to review large PRs on even an infrequent basis. Occasionally, there is no other option but to do a large code review. I recently reviewed a 400+ file PR from another committer that was generated by Open Rewrite. The rewrite of the code took 15 minutes using the Open Rewrite tool. The code review took me 2.5 hours to review, non-stop. I was not reviewing for quality. I was scanning for matching import statements. Simple scanning to make sure nothing else snuck in to the pull request. There is no easy way to make a change like this, which was one of a many part change to upgrade from JUnit 4 to JUnit 5. I should probably write a blog about the experience. Even better, I should ask the developer and committer who worked on it to write a blog.

Butcher Java’s Virtual Threads like a pro! with Piotr Przybyl

After meeting Piotr just a couple months ago at JCrete, I decided it would be great to see him give a talk. The talk was informative and very entertaining. I would highly recommend seeing Piotr give a talk if you have the chance.

Project Amber: A Deep Dive With The Features with Neha Sardana

Project Amber got great coverage in this conference, and I attended all three talks that covered Project Amber at the conference. Neha gave a great summary of the features included with supporting code examples.

Reading code with Marit van Dijk

This was the last conference timeslot of the conference. Somehow I managed not to take any pictures at this talk by Marit. Meeting Marit in person finally at the conference was already amazing. Marit introduced the concept of information chunking and the practicality of 7+-2 being more like 2–6 items a person can recall in short term memory.

Marit only had 60 minutes for this talk, and really could have used 75. Marit was not rushing the finish her content, but I feel like she had much more to say on the topic that everyone would have benefitted from. This was my favorite session at the conference. The best thing I can do is share this link to a blog and video from Marit titled “Reading Code like a Pro�

Reading Code like a pro - Marit van Dijk

After Marit finished her talk, I brought up the newest (and rather old) feature that I learned in IntelliJ recently that can help developers read YOUR code. I mentioned that I had two recent blogs that explained one way to use the feature. The feature is Custom Code Folding Regions which I had learned a few weeks earlier from a social media conversation with Tagir Valeev. I didn’t know it at the time but literally a day later when I was leaving Denver to return home, I would see my two blogs mentioned in the Java Annotated Monthly from JetBrains.

Java Annotated Monthly - October 2024 | The IntelliJ IDEA Blog

My summary of dev2next

This conference had the feel of an unconference, with the organization of a full blown conference. The speaker and topic lineup was great, and the venue checked all the boxes of being convenient, beautiful, and amazing weather. The whole week was sunny and warm. The food options locally were amazing, even at the hotel. I would love to return next year and visit the Rocky Mountain National Park, which we did not have time to visit this trip. End of September is a great time to have a conference in Colorado.

The best part of conferences for me is the networking and “hallway track�. I got to see a lot of folks I know from the Java Community, I got to meet some folks I’ve known for a while for the first time, and I got to meet some brand new folks

The one downside of the conference is that you need to get used to the elevation and dryness of the air. Stay hydrated is the frequent recommendation. I found that carrying around chapstick was helpful once my lips started getting dry. If you like drinking coffee like me, make sure you make up for any water lost by drinking more water.

My wife and I planned on both going to dev2next this year, and the plan worked out. My wife spent five hours at a nail salon getting four duke/duchess characters painted on her fingers on each hand, along with an Eclipse Collections iteration logo on each thumb. I wrote more about them in the “Nailed it, again� blog. Here’s a picture of us with my wife’s nails as we were leaving Denver airport.

A huge thank you to dev2next, Dr. Venkat Subramaniam, all the organizers, speakers, and attendees for making this a truly amazing conference experience! �

If you can take the time and can afford to go next year, I would definitely recommend attending dev2next 2025.

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. I am writing a book this year about Eclipse Collections. Stay tuned!

Do you want to integrate AI assistance into a custom tool? Are you looking for a platform that is flexible enough to support building a custom AI-augmented tool or IDE without restrictions, tailored …

The post Theia AI Sneak Preview: Powerful AI integration paired with the most flexible tool platform appeared first on EclipseSource.

Collaboration between multiple, specialized AI agents is often handled as the next step in the evolution of AI assistance in tools and IDEs. Yet, in many tools and IDEs, users have to explicitly …

The post Theia AI Sneak Preview: Let your agents talk to each other! appeared first on EclipseSource.

How creativity, family, and fun help energize technical communities

Invest in your making your community fun

This is for folks who work in tech and participate in technical community conferences and meetups. If you spend a lot of time prepping for, networking, and engaging with your community there are two things I can recommend that have helped me.

• Have fun
• Include your family whenever possible

Fun is infectious. Folks are more likely to engage in conversations when there is something fun happening around them.

Spending time away from family is tough. In the past two years, I have started bringing my family to conferences. This solved a few problems for me. I didn’t miss them. I could also introduce them to folks, whose names they may have heard, but had never met in person.

What I didn’t expect was that my wife would wind up creating her own brand and style in the Java community. My wife loves getting her hair and nails done with colorful designs. She came up with the idea to add the Java Duke mascot to her nails, and has been adding another Java Duke with each Java conference she attends. Technically, she has been to five conferences now, but is only up to four Java Dukes/Duchesses on each hand. This is for a very simple reason. Java uses zero based indexing. This is my story, and I’m nailing it, I mean, sticking to it.

The picture above is of her current nails for the conference we are attending next week called dev2next. My wife got her toe nails done as well. It took a total of five hours for the nail technician to finish both the hands and toes with all of the hand drawn artistry. The craftwork is simply amazing. This is also a serious commitment to preparing to have fun at a technical conference.

I’m giving a talk at dev2next with my good friend Vladimir Zakharov on Data Frames in Java.

dev2next Conference

I highly recommend checking out his recent blog comparing how Data Frame performance compare with the One Billion Row Challenge if you haven’t already.

Java, Kotlin, and Pandas Data Frames Walk into the One Billion Row Challenge

This is the first time my wife has added the Eclipse Collections orange iteration loop to her nails. I am thankful to have gotten two thumbs up after 20 years of working on Eclipse Collections. I’m currently working on finishing my first technical book, on Eclipse Collections, so folks can feel free to ask me about it. I may bring it up in conversation anyway.

If you’re attending dev2next and see us at the conference, don’t be shy, and say hello. Take a selfie with Duke and Duchess on nails. Feel free to ask me for an Eclipse Collections sticker as well.

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. I am writing a book this year about Eclipse Collections. Stay tuned!

Do you want to augment your tool or IDE with AI assistance and go beyond just a simple chat interface? Do you want to assist users with actual workflows and boost their efficiency by making AI support …

The post Theia AI Sneak Preview: Custom Part Renderer and actionable responses appeared first on EclipseSource.

Cette semaine, j’ai présenté à la conférence Models 2024 à Linz (Autriche) dans le cadre de la Journée de l’Industrie, où j’ai introduit deux de nos initiatives open source : Sirius Web, qui fait partie du projet Eclipse Sirius, et Eclipse SysON, un outil de modélisation SysMLv2 construit sur Sirius.

Au cours de la session, j’ai mis en évidence plusieurs aspects importants de nos développements récents :

• Eclipse Sirius : « Tout compris » – Sirius Web offre toutes les fonctionnalités standard que vous attendez d’un outil de modélisation complet, désormais disponible sur le web pour une collaboration fluide et une intégration facile des utilisateurs.
• Allier puissance et flexibilité – Notre approche consiste à exploiter la force de la modélisation tout en maintenant la flexibilité pour assurer une adoption aisée et une expérience utilisateur positive.
• Extensibilité et personnalisation – La pile d’outils est entièrement extensible et personnalisable, ce qui la rend idéale pour construire des prototypes expérimentaux pouvant évoluer vers des solutions de qualité industrielle.

Les retours de la communauté de recherche ont été encourageants, notamment sur la manière dont ces outils peuvent être appliqués dans des domaines comme le transport, l’énergie, l’espace ou même la construction.

Je publie également les diapositives de ma présentation, ainsi que des démonstrations vidéo, pour offrir plus d’informations sur les capacités de Sirius Web et SysON. Ces outils offrent aux organisations dans divers domaines stratégiques une solution open source flexible pour aborder des systèmes complexes.

N’hésitez pas à explorer les diapositives ci-dessous, et j’attends avec impatience vos commentaires.

Faire progresser les outils de modélisation basés sur le web avec Sirius Web : Une illustration avec SysON was originally published by Cédric Brun at CEO @ Obeo on September 26, 2024.

Introducing Our Latest Innovations in Modeling: Eclipse Sirius & SysON

This week, I presented at the Models 2024 conference in Linz (Austria) as part of the Industry Day, where I introduced two of our Open-Source initiatives: Sirius Web, part of the Eclipse Sirius project, and Eclipse SysON, a SysMLv2 modeling tool built on Sirius.

During the session, I outlined several important aspects of our recent developments:

• Eclipse Sirius: “Batteries Included” – Sirius Web provides all the standard features you would expect from a comprehensive modeling tool, now available on the web for seamless collaboration and easy onboarding of users.

• Combining Power and Flexibility – Our approach is to leverage the strength of modeling while maintaining flexibility to ensure ease of adoption and a positive user experience.

• Extensibility and Customization – The tool stack is fully extensible and customizable, making it ideal for building experimental prototypes that can scale up to industrial-grade solutions.

The feedback from the research community was encouraging, particularly regarding how these tools can be applied in fields like transportation, energy, space or even construction.

I’m also publishing the slides from my talk, along with video demonstrations, to provide more insight into the capabilities of Sirius Web and SysON. These tools offer organizations in various strategic domains a flexible, open-source solution to tackle complex systems.

Feel free to explore the slides below, and I look forward to your thoughts.

Advancing Web-Based Modeling Tools with Sirius Web: An Illustration with SysON was originally published by Cédric Brun at CEO @ Obeo on September 26, 2024.

As we approach the Open Community Experience (OCX), scheduled to take place from 22-24 October in Mainz, Germany, my anticipation and excitement continues to build. This event marks a new chapter for our community, with a fresh conference format that I believe will bring even more value to all of us. The focus on collocated events is something I’m particularly enthusiastic about, as it allows us to explore a broader range of topics including automotive and Java, while EclipseCon remains at the heart of this experience. 

Whether you’re a regular EclipseCon attendee or joining us from one of the many communities that make up our “community of communities,” I look forward to connecting with you. For me, our flagship conference is more than just an event—it’s a yearly highlight where I get to reconnect with old friends, make new ones, and engage in the meaningful conversations that drive our collective work forward. 

I’m honoured to be delivering the keynote on “The State of the Eclipse Foundation” this year. I’ll be sharing key updates, our vision for the future, and how we plan to continue driving innovation in the open source space. As we celebrate the Eclipse Foundation’s 20th anniversary, it’s a pivotal moment for us, and I’m excited to take you along on this journey.

But it’s not just me you’ll hear from. We’ve lined up a stellar group of keynote speakers, each bringing their unique expertise and deep expertise in their respective fields. Prepare to be inspired by some of the brightest minds in the industry:

• Haibo Chen from Huawei will deliver an exciting session titled “Empowering a Connected Intelligent World With OpenHarmony and Oniro.” This talk will explore how OpenHarmony and Oniro, both open source initiatives, are driving the connected intelligent future.
• Cédric Dumont, an extreme sports athlete and base-jumping pioneer, will provide the inspirational keynote “Scaling New Heights: Emerging trends in performance and leadership for thriving as a team in disruption.”
• Ruth Ikegah, an Open Source Program Manager, acclaimed speaker, and GitHub Star, will deliver her keynote “From Local Roots to Global Impact: Building an Inclusive Open Source Community in Africa.” Ruth will highlight how inclusivity fuels innovation and growth within the global open source community.
• Yann Lechelle from Probabl will take the stage with “Eyes Wide Open, AIs Wide Open – Or How to Remain in Control in the Age of AI,” exploring the big picture implications of compute, data, and machine learning, and how we can stay competitive while safeguarding the values that make us human.
• Sarah Novotny, a leading voice in open source, who has guided projects like Kubernetes, OpenTelemetry, NGINX, and MySQL, will present “We Build Software in the Open to Build Trust.” She’ll discuss the need for transparent and collaborative open source software development and its profound economic and societal impact.
• Leandro von Werra, from Hugging Face, will offer insights into the future of LLMs for code and how the BigCode project is paving the way for open and responsible AI-driven development at the session “BigCode: Building Open LLMs for Code”. 

And that’s just the beginning. OCX 2024 is packed with sessions, workshops, and networking opportunities designed to spark innovation, collaboration, and growth. Whether you’re deeply involved in open source software or just beginning your journey, there’s something here for everyone.

I’m genuinely excited about what we’ll experience together at OCX 2024. This is our chance to come together, share our knowledge, and set the stage for the future of open source development. Don’t miss the opportunity to save by taking advantage of early bird pricing—register before 7 October 2024. 

See you there!

Do you want to augment your tool or IDE with AI assistance? In this article, we show an example of how easy it is to create custom AI agents with Theia AI, a fully open AI framework for building …

The post Theia AI Sneak Preview: Create your own AI assistance! appeared first on EclipseSource.

Today marks an important milestone for the open source community. As open source software continues to drive innovation across industries, ensuring its relevance and compliance with emerging regulations has never been more critical. 

To address these challenges, the Eclipse Foundation is proud to announce the formal launch of the Open Regulatory Compliance (ORC) Working Group. This initiative is designed to ensure that open source remains a powerful force for innovation while meeting the increasingly complex regulatory requirements that commercial organisations face globally. 

As previously announced, this initiative has garnered the support of the world’s open source foundations, including Apache Software Foundation, Blender Foundation, FreeBSD Foundation, Matrix.org Foundation, NLnet Labs, OpenInfra Foundation, OWASP, PHP Foundation, Python Software Foundation, Ruby Central, and Rust Foundation. We also have the support of numerous civil society organisations, industry organisations, and SMEs including CodeDay, iJUG, Obeo, Open Elements, OpenForum Europe, Open Source Initiative, Payara Services, Scanoss, and Software Heritage. Today we are also announcing that we have the support of European industry heavyweights Bosch, Mercedes-Benz, Nokia, and Siemens.

This diverse collaboration highlights the industry’s shared commitment to navigating regulatory changes together and ensuring that open source continues to thrive as a pillar of modern technology.

Securing the Future of Open Source Innovation

In an era where businesses rely on open source for mission-critical applications, the ORC Working Group is essential to maintaining the competitive advantage that comes from using and contributing to open source software. As regulations evolve, commercial organisations need a clear path to stay compliant while continuing to innovate. The ORC Working Group addresses this need by helping to formalise industry-aligned best practices, helping companies leverage the full potential of open source without the risk of falling behind on new regulations.

Immediate Focus: The European Cyber Resilience Act

Open source is a cornerstone of global digital innovation, and Europe’s regulatory landscape is playing a pivotal role in shaping its future. The ORC Working Group is committed to ensuring that open source remains a vital part of the world economy, and complying with the EU’s Cyber Resilience Act (CRA) is a critical part of this. Through collaboration with European institutions, the working group is working to facilitate compliance with the CRA and similar regulations, helping businesses and developers alike stay ahead of the curve.

Keeping Innovation Compliant and Secure

With the Cyber Resilience Act as a primary focus, the ORC Working Group is looking to make progress in developing cybersecurity process specifications and best practices to support compliance. Liaison status with the European Committee for Standardization (CEN) and the European Committee for Electrotechnical Standardization (CENELEC) further strengthens the working group.

Get Involved: Shaping the Future of Open Source Compliance

As the open source ecosystem faces unprecedented regulatory challenges, now is the time for all stakeholders — developers, companies, foundations, and regulatory bodies — to come together and ensure that open source innovation remains sustainable and compliant. The Open Regulatory Compliance (ORC) Working Group offers a unique opportunity to actively shape the future of open source by helping define the standards and best practices that will keep it relevant and competitive in the face of evolving global regulations.

We invite anyone involved in the open source community — whether you’re a developer, legal expert, corporate leader, or part of a standards organisation — to join this critical effort. Your participation will not only help safeguard the future of open source, but also ensure that your organisation stays ahead of the regulatory curve.Join the ORC Working Group and the ORC mailing list today to help define the future of open source compliance.

For AI-assisted tools and IDEs, variables and tool functions play an essential role in enhancing the context and enabling dynamic interactions with the tools at hand. Variables allow AI agents to …

The post Theia AI Sneak Preview: Transparent variables and tool functions appeared first on EclipseSource.

Improving Java API documentation in source code and Javadoc.

Sometimes you don’t know what is possible until you try something. I find walls of text in code and Javadoc challenging to navigate. Interfaces with Javadoc can be especially challenging because the Javadoc can easily hide the methods behind a scrolling wall of text.

I decided to try an experiment in the parent interface of Eclipse Collections named RichIterable. I decided to reimagine the interface by organizing the methods into method categories in the source code and Javadoc, and then associating method categories with a visual approximation using an emoji. I blogged about simulating method categories in Java previously, but the use of emojis to provide visual augmentation is a new twist.

Grouping Java methods using custom code folding regions with IntelliJ

I share the results of my latest experiment below.

Custom code folding regions in IntelliJ

With IntelliJ you can use emojis along with text descriptions in custom code folding regions. This was a neat surprise for me. These regions will display the text and emojis in the source editor, Structure View and in the pop up window when you press Ctrl-F12. I find that the emojis are a more visually appealing alternative to the “Great Wall of Dashes� style comments. These look like the following.

Contrast this with emojis uses with region and endregion comments.

The difference is subtle but important. I would like to know how screen readers will interpret both the “Great Wall of Dashes� and the emojis appearing after the method category descriptions. The text of the method categories is the important part, and the emojis do not add any additional context about the regions. They are simply a visual cue.

Javadoc

I tried an experiment to see if emojis would work in Javadoc as well. Again, I was pleasantly surprised that they do. I had previously changed the Javadoc header in RichIterable by organizing all of the methods into method categories with links. This is how the method categories with emojis and links to methods look in the source editor in IntelliJ with my addition of experimental emojis.

The emojis kind of get lost a bit in the raw Javadoc text view in the editor as there are a lot of links. In the Rendered Reader View in IntelliJ however, they stand out nicely.

Getting back to the wall of dashes separator. These separators disappear in Javadoc, so are only useful in source.

I had to replicate the emojis in the Javadoc by hand, which is just an unfortunate reality today. This is where method category support in Java via a new annotation or Javadoc tag would help reduce work for developers wanting to further organize the methods in their classes and interfaces.

Still, the work done by hand for RichIterable in Eclipse Collections is worth it if you ask me. This kind of treatment in your code and documenation shows developers how much you care about the library.

This is what the emojis look like when added to method categories in Javadoc in the browser.

If you’re wondering what the current Javadoc for RichIterable looks like with Eclipse Collections 11.1, the following is the wall of scrolling text, with all of the methods shown above, in alphabetical order organized in thick rows that goes on for days. The next release of Eclipse Collections will change this with the addition of method categories, and if you appreciate this idea and clap for this blog, hopefully emojis as well. 🤗

Final Thoughts

After 20 years of working on Eclipse Collections, I set out this year to write a book about the library. The book is nearing completion and should be published in Q4. Stay tuned! When I had finished organizing the content of the chapters in the book, I went back to the Eclipse Collections source in IntelliJ to find a way to rethink the organization of the code and Javadoc in the library. I wanted to leave something there so that developers who want to learn the library over the next 20 years will have better tools to help them understand how the library is organized. This can actually help developers in any programming language understand how to think about behavior in their collections. Spoiler alert: here’s a visualization of RichIterable showing how the method categories from my upcoming book are organized. You could have easily figured this out on your own from the screenshots above.

The reason I am writing this blog, and my previous blog about using custom code folding regions to group methods by method categories, is so that any Java library maintainer with feature-rich interfaces can learn about tools that are available today to help them make their documentation better. When libraries are around for 5, 10, 20 years or more, the focus on adding features may continue, and the focus on finding better ways to improve documentation should also continue. I’ve found for Eclipse Collections that my focus has changed to wanting more and better documentation to help current and future users of the library with comprehension and retention of the patterns of problems the library solves. This year, Eclipse Collections will get its first technical book. It will also be getting renewed focus on the code organization and Javadoc with the current IDE tooling.

My hope is that the approaches I am sharing for leveraging the Information Chunking principles using Method Categories start finding their way back into the Java language/libraries or Javadoc tooling for developers to leverage outside of specific IDEs. Once method categories are built into Java, all IDEs can use method categories consistently, and not with tool specific comments that only work potentially in certain IDEs.

If you find the approach I have taken with method categories and emojis here with Eclipse Collections useful, then please feel free to use it to improve your own library documentation and tooling support! When documentation improves in Java libraries, we all benefit! And don’t be shy… click applaud as many times on this blog as you feel is appropriate to show your appreciation!

Thanks for reading, and best of luck organizing and documenting your code!

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. I am writing a book this year about Eclipse Collections. Stay tuned!

Most commercial AI-driven tools and IDEs provide you with a preset LLM that you cannot influence as a user or adopter. Usually, this is even combined with a mandatory subscription model and sometimes, …

The post Theia AI Sneak Preview: Choose your own LLM appeared first on EclipseSource.

Do you use AI code completion and are you interested in what data is actually sent and received to the underlying LLM. And do you feel that sometimes you would like to add your own 2 cents to the …

The post Theia AI Sneak Preview: Open and Transparent AI-driven Code Completion appeared first on EclipseSource.

In recent years, the trend toward open-source platforms for developer tools is more and more undermined by the rise of proprietary AI integrations. Tools like GitHub Copilot, Cursor IDE, or Codeium, …

The post The Vision of Theia AI: Empowering Tool Builders with full control over AI Solutions appeared first on EclipseSource.

We are happy to announce the seventh Eclipse Theia community release “2024-08”, version 1.52.x! New to Eclipse Theia? It is the next-generation platform for building IDEs and tools for the web or …

The post The Eclipse Theia Community Release 2024-08 appeared first on EclipseSource.

More news

We are happy to announce the Eclipse Theia 1.53 release! The release contains 48 merged pull requests. In this article, we will highlight some selected improvements and provide an overview of the …

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

Simulating the lost Smalltalk feature of method categories in Java IDEs.

Information Chunking for the win

Providing mechanisms to group things that are related is a powerful organizational feature. Java packages are great for information chunking in projects with more than seven plus or minus two classes. Imagine if Java didn’t have packages. We would have tens, hundreds, or thousands of classes in a single directory, where we would have to leverage prefixes in our class names to avoid name collisions.

I wrote about how we used information chunking to scale the package design in Eclipse Collections in the following blog.

Leverage Information Chunking to scale your Java library package design

How can we organize methods?

In Java, the first most basic thing we can do is organize methods on classes and interfaces, based on the responsibilities of the class or interface. Once the number of methods in a class exceeds the seven plus or minus two target for short term memory, we have a few options. We can sort and group the methods in the file in some manner we find suitable. We can add visual separators to make it easier to recognize groups of things. The only tool we have to find things this way is the scroll bar or text search, or tools like Structure View in IDEs like IntelliJ.

The Smalltalk programming language has the feature of method categories to group methods. It had this feature when I first learned the Smalltalk programming language thirty years ago. Java, and no other file based programming language I am aware of, has this feature. Method categories are a hidden gem for information chunking in Smalltalk. They help you better handle scale, and make source code easier to navigate. Imagine all of your getters and setters in a class hidden away in a category called “accessing” that you can ignore.

The following is a class browser in Pharo Smalltalk for the Collection class in the Smalltalk class library. Notice the third pane. This contains an alphabetically sorted list of method categories that can filter the methods displayed in the last pane. In the image below, I am looking at the methods in the “enumerating” category of the Collection class, with the implementation of the reduce method in the source pane at the bottom.

The benefits of grouping methods

The Eclipse Collections library is a great example where grouping methods into method categories can help make the library easier to learn and understand. The RichIterable parent type in Eclipse Collections has 134 unique methods (not counting overloads). This number of methods is scary sounding. If we break this large number of methods into nine categories, the distribution becomes easier to comprehend and learn. The type is suddenly a lot less scary. There are a lot of features, but there is a much smaller group of capability categories.

Here’s what the distribution of the 134 methods for RichIterable would look like if we balance the methods across nine method categories.

How can we group the methods like this so that our IDEs and JavaDoc can help us visually group and filter based on categories?

IntelliJ to the rescue

I learned recently from Tagir Valeev on Mastodon that IntelliJ has long supported a source feature of custom code-folding regions.

IntelliJ supports two styles of custom region folding. One is compatible with NetBeans (editor-fold), and one is compatible with VS Code (region / endregion). You can only choose one alternative. I have chosen the VS Code compatible alternative.

The custom code folding feature in IntelliJ IDEA is described section 13.4 Hide Distracting Code of “Getting 2 Know IntelliJ IDEA” by Trisha Gee and Helen Scott. There are screenshots and tips for using this feature on page 112 in the edition I have on my bookshelf. I bought this book because I know that IntelliJ has so many amazing features. Even though I have used IntelliJ for 22 years, I don’t know them all. I need to spend more time going through this excellent book to find new productivity tools I am missing from my coding workflow.

Organizing RichIterable into Method Categories

I have organized the RichIterable type in Eclipse Collections into custom regions with descriptions and submitted a PR for review with the change. The comments in code look as follows

Region comment

Endregion comment

While it is not necessary to put the description in the endregion comment, I have found it useful when scrolling through the source editor to spot the end of a region without having to guess at which region it is.

I am happy with the results. This is how RichIterable looks with all regions collapsed in IntelliJ.

The RichIterable class is more than 2,500 lines of code and text (E.g. javadoc comments). With all of the regions fully collapsed it is about 20.

The real awesomeness happens in the Structure View. IntelliJ sorts the regions alphabetically, and then sorts the methods in the regions alphabetically. Browsing RichIterable in the Structure view with IntelliJ looks as follows with the regions defined. I included the source view on the right after selecting the select method on the left. Notice that the select method is the first method in the region in the source code, but is sorted alphabetically in the structure view for the Filtering Methods region.

IntelliJ also adds the region folding to the Ctrl-F12 shortcut which brings up a method pop up view similar to the pane on the left. This is a rudimentary but decent approximation of method categories in a Smalltalk browser.

I think this will be very beneficial for contributors and committers who work on Eclipse Collections. Users of the library can also view the source of RichIterable in a more organized manner, so long as they are using IntelliJ or VS Code. The custom region folding will not appear in Javadoc or be able to be shown as more than text in the GitHub browser.

Et tu, Javadoc?

While using region comments to build method categories works in the source editor in IntelliJ, I want to have the same view available in Javadoc for RichIterable. No bueno, today.

I decided to take the low tech route of defining the method categories by hand in Javadoc with all of the methods in each category that link directly to the methods. It would be ideal if there was metadata attached to each method (e.g. a Method Category annotation) that the Javadoc tool could use to automatically build the Javadoc Index of methods by category. RichIterable as a type doesn’t evolve too much, and when it does, we only add new default methods, so I am not worried about class churn causing this index to become stale or inaccurate.

As we can see, all 134 methods can fit on a single page when organized into method categories in Javadoc. It was a bit more work to do this, but I had already done the work of organizing methods into categories for RichIterable for a book I am currently writing on Eclipse Collections. I hope the book will be published in the next couple months. Stay tuned!

Method Categories in Java

Java will benefit from adding method categories as an annotation that documentation tooling can leverage. There are many classes in Java today like Stream, Collectors, LocalDate, Scanner, String, StringBuffer, List, Map, Collections, etc. that could all benefit from grouping methods into categories to make it easier for Java developers to navigate and learn classes in the library. I noticed that some classes in Kotlin like DataFrame have begun to use the IDE specific custom region folding approach. I wonder if there are other examples of libraries using a similar approach.

For Eclipse Collections, I plan to work with the other committers and contributors on discovering ways for us to better organize our extensive API using method categories reflected through custom region folding. Hopefully, if a Method Category feature becomes available in a later version of standard Java, we will actively convert over to using that.

Thank you for reading, and I hope you found this useful.

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.

Every beginning has an ending. Every ending has a beginning.

I took this picture at Yorktown Battlefield in Yorktown, Virginia this week. My wife and I were driving around the Colonial Parkway which had quite a few detours due to construction, and I decided to make a right turn instead of a left, initially passing by the center of Yorktown that we had been to several times before. I could see the sun was setting behind me, and followed some cars to a parking area with a parking loop near the battlefield. When I saw the sun already disappearing on the horizon, I parked our car, jumped out quickly and took three quick pictures, hoping I would catch some of the magic of the bright red sun I saw as I was pulling up to the parking area. I had no idea how the pictures came out until I looked the next day.

This picture is unlike most of the sunset pictures I take, which usually involve some body of water (ocean, lake or river). There is something about the trees here that I find mesmerizing. The two trees look like they form a single tree. One bends to allow the other some space. They form a beautiful union of branches and leaves.

I hope you enjoy this photo as much as I do. This photo has the memory of 243 years since a battle that was fought in September — October, 1781 that would help determine the future of 334 million plus Americans today. 88 Americans voted in this battle in 1781 with their lives, so that we may have a future as a nation. An estimated one percent of Americans would lose their lives during the Revolutionary War. Many others have voted with their hearts, souls, lives, and families since then to protect and provide for our future. We remember and honor the lives of all Americans who have come before us, helping build and protect this great nation, by using the right they defended for us, to vote in free and fair elections.

Vote. The trees are standing and watching us grow, just as they do, together. When we bend, we see new, beautiful perspectives, and make space for others to enjoy the view of freedom along with us. Freedom is a sunset on the horizon. It can be there every day for us, but we have to take the time to enjoy it, together.

How to visualize multiple lazy operations in a Java Stream.

Eager is easy, Lazy is Labyrinthine

A few years ago, I wrote a blog that explained the differences between eager and lazy iteration patterns in terms of Stream operation names (filter, map, reduce). I used the peek method of Java Stream with System.out.println to explain the most challenging part of understanding lazy iteration patterns — the order and flow of execution.

Eager is Easy, Lazy is Labyrinthine

While using peek with System.out.println is fine for a blog, there is a better way if we want to encode some of the “how” something works in a test for future maintainers to learn and understand from, without requiring them to execute the code and look at the output.

Don’t print, assert!

The following is code that is similar to the code I wrote in the blog above, where I use peek to understand the inputs that are used for each step in the Stream.

@Test
public void lazyFilterMapReducePrint()
{
    List<Integer> list =
            List.of(1, 2, 3, 4, 5);

    Optional<String> lazy = list.stream()
            .peek(i -> System.out.println("filter: " + i))
            .filter(each -> each % 2 == 0)
            .peek(i -> System.out.println("map: " + i))
            .map(String::valueOf)
            .peek(i -> System.out.println("reduce: " + i))
            .reduce(String::concat);

    Assertions.assertEquals("24", lazy.orElse(""));
}

This code by itself does not tell us anything about the order of execution of the Stream pipeline. We need to run the code to see the output. The following is the output when I run this code.

filter: 1
filter: 2
map: 2
reduce: 2
filter: 3
filter: 4
map: 4
reduce: 4
filter: 5

We can convert the peek code from printing output to adding elements to a List and then asserting equality to an expected ordered List.

@Test
public void lazyFilterMapReduceAssert()
{
    List<Integer> list =
            List.of(1, 2, 3, 4, 5);

    MutableList<String> order =
            Lists.mutable.empty();

    Optional<String> lazy = list.stream()
            .peek(i -> order.add("filter: " + i))
            .filter(each -> each % 2 == 0)
            .peek(i -> order.add("map: " + i))
            .map(String::valueOf)
            .peek(i -> order.add("reduce: " + i))
            .reduce(String::concat);

    List<String> expectedOrder = List.of(
            "filter: 1",
            "filter: 2",
            "map: 2",
            "reduce: 2",
            "filter: 3",
            "filter: 4",
            "map: 4",
            "reduce: 4",
            "filter: 5");

    Assertions.assertEquals(expectedOrder, order);
    Assertions.assertEquals("24", lazy.orElse(""));
}

In this code we take the List of integer values and see them first get evaluated against the Predicate which tests and filters if they are even. When the numbers 2 and 4 are tested, we see they flow on to the next step immediately to be mapped to a String, and then finally reduced together into a concatenated String, which gets returned as an Optional value.

Here’s an eager equivalent of the code above with the output as assertions. The code uses Eclipse Collections types and eager methods, because there is no equivalent eager behavior in the standard Java Collection Framework. The equivalent to the Stream peek method in Eclipse Collections is called tap.

@Test
public void eagerSelectCollectReduceAssert()
{
    ImmutableList<Integer> list =
            Lists.immutable.of(1, 2, 3, 4, 5);

    MutableList<String> order =
            Lists.mutable.empty();

    Optional<String> eager = list
            .tap(i -> order.add("select: " + i))
            .select(each -> each % 2 == 0)
            .tap(i -> order.add("collect: " + i))
            .collect(String::valueOf)
            .tap(i -> order.add("reduce: " + i))
            .reduce(String::concat);

    List<String> expectedOrder = List.of(
            "select: 1",
            "select: 2",
            "select: 3",
            "select: 4",
            "select: 5",
            "collect: 2",
            "collect: 4",
            "reduce: 2",
            "reduce: 4");

    Assertions.assertEquals(expectedOrder, order);
    Assertions.assertEquals("24", eager.orElse(""));
}

The eager version of similar functioning code selects (aka filter) all evens first, then collects (aka map) as Strings the elements that were selected, and finally reduces those elements to the final output. The order of the output matches the order of the method calls in the eager case. This makes it easy to understand and reason about.

The lazy equivalent in Eclipse Collections will have the same order of execution as the Java Stream code. The following is the equivalent code using the LazyIterable type in Eclipse Collections.

@Test
public void lazySelectCollectReduceAssert()
{
    ImmutableList<Integer> list =
            Lists.immutable.of(1, 2, 3, 4, 5);

    MutableList<String> order =
            Lists.mutable.empty();

    Optional<String> lazy = list.asLazy()
            .tap(i -> order.add("select: " + i))
            .select(each -> each % 2 == 0)
            .tap(i -> order.add("collect: " + i))
            .collect(String::valueOf)
            .tap(i -> order.add("reduce: " + i))
            .reduce(String::concat);

    List<String> expectedOrder = List.of(
            "select: 1",
            "select: 2",
            "collect: 2",
            "reduce: 2",
            "select: 3",
            "select: 4",
            "collect: 4",
            "reduce: 4",
            "select: 5");

    Assertions.assertEquals(expectedOrder, order);
    Assertions.assertEquals("24", lazy.orElse(""));
}

IntelliJ to the rescue

The problem of understanding Java Stream flow is common enough that the wonderful developers at JetBrains developed a special debugging feature for Java Stream to help us.

Analyze Java Stream operations | IntelliJ IDEA

The great thing about this tool is that we don’t need to litter calls to peek at various points in the Stream in order to use it. Our code can stay as simple as follows.

@Test
public void lazyFilterMapReduce()
{
    ImmutableList<Integer> list =
            Lists.immutable.of(1, 2, 3, 4, 5);

    Optional<String> lazy = list.stream()
            .filter(each -> each % 2 == 0)
            .map(String::valueOf)
            .reduce(String::concat);

    Assertions.assertEquals("24", lazy.orElse(""));
}

Using the debugging tool

Put a breakpoint in your code and run the code in debug mode. Look for this button with the bubble help text of “Trace Current Stream Chain” in the debugging tab.

There are two modes of viewing a Stream. In split mode, we can look at individual steps in the Stream.

Let’s look at filter first.

Let’s look at map next.

Finally, let’s look at reduce.

Using the split mode is kind of tedious with multiple steps, so we will switch to flat mode which will show all of the steps in the Stream at once.

This view shows us what happens to the inputs after each stage of the Stream pipeline, but it doesn’t really show us the order in which the execution happens. We are only able to see this using the peek approach with some form of either printable or assertable output.

Final Thoughts

I hope you found this blog helpful. We can use peek in Java Stream, or tap in Eclipse Collections to help us understand the flow of lazy code. With Java Stream, we also have the benefit of being able to use the Stream specific debugging tool in IntelliJ to analyze the inputs and outputs at each stage in the pipeline. It would be nice if someone developed a similar debugging tool for Eclipse Collections LazyIterable type.

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.

In the fast-paced world of software development, open source has emerged as a catalyst for innovation. But with this rapid growth comes an equally crucial responsibility: security. As open source continues to reshape the digital landscape, ensuring robust security measures is no longer optional; it’s essential. That’s why Open Community Experience (OCX) is placing a strong emphasis on the latest advancements in open source security.

What Is OCX 2024?

OCX 2024 is a conference taking place on 22-24 October in Mainz, Germany, where the future of open source is actively shaped. Held at Halle 45, a cultural and event venue with a rich history, the event brings together thought leaders, developers, and tech enthusiasts from around the globe. With a focus on innovation, collaboration, and community, OCX 2024 offers an environment where you can learn, network, and contribute to the ongoing evolution of open source technologies.

OCX 2024 will feature multiple tracks of sessions, including embedded IoT and edge, open source security, open technologies, and open source best practices.

A Deep Dive into Open Source Security

The security track at OCX 2024 is packed with sessions that address the most pressing challenges and opportunities in open source security. Here’s a sneak peek at what the security track has in store:

• Enhancing Software Supply Chain Security: Approaches to Software Composition Analysis: Laura Bottner from Mercedes-Benz Tech Innovation will discuss strategies for improving software composition analysis, offering practical insights into using open source tools to detect vulnerabilities and secure the software supply chain.
• The Future of Cybersecurity, Today: Free and Open Source Tools for CRA Compliance for SMEs: Join Philippe Ombredanne and myself to learn how small and medium enterprises (SMEs) can leverage free and open source tools to meet Cyber Resilience Act (CRA) compliance, without extensive resources.
• Navigating a Security Audit, the Insights, Challenges, Experiences and Lessons Learnt: Scott Fryer from Red Hat will offer a comprehensive guide on navigating security audits, from preparation to execution, and follow-up actions. This session is designed to demystify the audit process and arm you with the knowledge to succeed.
• Actions in the Wild: Usability and Ease-of-Use of Open Source Security Tools: Rohan Krishnamurthy from ZF Group will explore the usability and effectiveness of open source security tools in real-world scenarios, highlighting the importance of choosing the right tools for continuous monitoring and vulnerability management.

Beyond Security: What Else Can You Expect at OCX?

This year, OCX expands its horizons with collocated events that cater to the diverse and dynamic open source community:

• Open Community for Java (OCJ): Java developers will find a wealth of knowledge and insights at OCJ, which covers everything from Jakarta EE and Adoptium to the latest in open source Java technologies.
• Open Community for Automotive (OCA): Dive into the future of automotive tech and discover how open source software is fueling innovation in this fast-evolving field at OCA.

Register now!

Make sure to register so you don’t miss a full program of technical talks, community activities, and networking opportunities. Get your tickets before 23 September to benefit from a discounted rate.

Want to learn more about the event? Visit ocxconf.org and follow @EclipseCon and @ocxconference on social media.

I’m looking forward to seeing you in Mainz this year!

Integrating AI into tools and IDEs has become a critical component in many of our customer projects. In these integrations, we frequently depend on LLMs to generate machine-processible outputs, which …

The post Structured Outputs in OpenAI API: A Game-Changer for AI Integration in Tools and IDEs appeared first on EclipseSource.

On behalf of the Eclipse JKube team and everyone who has contributed, I'm happy to announce that Eclipse JKube 1.17.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:

• Multi-platform container image builds in Jib strategy
• New Helm Maven goals and Gradle tasks
  • k8s:helm-dependency-update / k8sHelmDependencyUpdate
  • k8s:helm-install / k8sHelmInstall
  • k8s:helm-uninstall / k8sHelmUninstall
• Support for Micronaut Framework Native images
• ğŸ�› Many other bug-fixes and minor improvements

Multi-platform container image builds in Jib strategy

You can now build multi-platform container images using the Jib strategy. To enable multi-platform builds you can set the jkube.container-image.platforms property in your Maven or Gradle configuration.

Check the following video with a demo of this functionality:

New Helm Maven goals and Gradle tasks

This release includes new Helm features much awaited by the community. We've added new Helm capabilities to both the Maven and Gradle plugins.

• k8s:helm-dependency-update / k8sHelmDependencyUpdate: Allows you to update the dependencies of your Eclipse JKube generated Helm charts.
• k8s:helm-install / k8sHelmInstall: Allows you to install your Eclipse JKube generated Helm charts.
• k8s:helm-uninstall / k8sHelmUninstall: Allows you to remove a Helm release from your Kubernetes cluster.

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.17.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.17.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

I will be delivering a couple of talks at EclipseCon 2024, recently rebranded as OCX – https://www.ocxconf.org/. Here is the abstract for the first of these (link to the slot in the program):

In this talk, we explain the current state of the C/C++ Development Tooling (CDT) and its future alongside Language Server Protocol (LSP) and its associated tooling such as clangd. As software development evolves, the integration of LSP has become pivotal in enhancing code editing experiences across various integrated development environments (IDEs). We will explore the successes and challenges faced in implementing LSP in CDT building on top of the Eclipse LSP4E framework, examining how it impacts productivity, code quality, and developer experience. The talk will also address the compatibility and performance issues encountered and future directions for improving CDT’s tooling. Attendees will gain insights into the practical realities of maintaining and evolving tooling for C/C++ development in a rapidly changing technological landscape.

I will be delivering a couple of talks at EclipseCon 2024, recently rebranded as OCX – https://www.ocxconf.org/. Here is the abstract for the first of these (link to the slot in the program):

This talk introduces an approach to embedded development: running the GNU Debugger (GDB) directly in the browser using WebAssembly, eliminating the need for traditional installations.

Attendees will discover how this solution can be integrated by leveraging the Eclipse CDT Cloud Project targeting popular web based IDEs such as Visual Studio Code (VSCode) and Eclipse Theia. By using WebAssembly, we can run GDB directly in the browser, providing a seamless debugging environment across different systems.

In addition, the talk will cover the exciting capabilities of modern browsers to connect to hardware using WebUSB. This allows developers to interface with embedded devices directly from the browser, further simplifying the development and debugging process.

Join us to explore the future of zero-install embedded C/C++ development and see firsthand how these technologies can revolutionize your development experience.

The Open-Source project: Emscripten

I have been working on a WebAssembly project porting some desktop code to run in a web browser and we have been using Emscripten as our tool chain. Emscripten is an open-source compiler toolchain that allows you to compile C/C++ code to WebAssembly, enabling it to run in web browsers. But it is more than a just compiler, Emscripten is a full SDK as it also includes the runtime library allowing interaction with the web browser with JavaScript.

The bug, a race condition?

My system has an Emscripten compiled C program running in a Web Worker that writes data that is read by another Web Worker. A SharedArrayBuffer is used to connect the two Web Workers together, basically as a queue. When the queue was big enough the program behaved exactly as expected, however when the queue filled up I would observe out of order and corrupt data on the read side.

For a simple example, if the C program did fprintf(f, "abcdefghijklmnopqrstuvwxyz\n“) the receiving Web Worker would receive a random character replaced with a newline, such as “abcdefg\nijklmnopqrstuvwxyz\n". I eventually determined that the corruption only occurred if the queue went from full to not full in the middle of processing a single write.

Determining this was difficult because any debugging I did or logging I added to my program changed the behaviour sufficiently to remove or at least significantly relocate when I saw the bug. This is why I concluded that it was a race condition.

Understanding the problem was related to the queue being full allowed me to configure my test case with a full buffer that I could control when it transitioned from full to not full (by careful placement of breakpoint on the receiving side) allowing me to step through a reproducible test case.

Once I was able to step through the code finding the bug was very easy, a simple loop termination condition was missing in the implementation of the doWritev function that underpins much of the stdio output handling.

Submitting my first issue

The first step in contributing anything non-trivial to an open-source project is to create a bug report. This allows you to discuss with the maintainers and the rest of the project’s ecosystem about the validity of your findings.

I summarized all my findings, along with my probable fix as a bug report in Emscripten’s GitHub issue tracker, Issue #22258.

The Emscripten maintainers were very responsive to my bug report which allowed me to have confidence that my assessment was probably correct, and that the community would be receptive to me doing the work to submit a Pull Request to resolve the issue.

Creating a Pull Request – have a good test case!

I could have created a PR with the one-line fix and called it a day as I already had a fix applied in my code base. The problem was possibly well enough understood to be merged with only that. However, to demonstrate exactly what the fix meant and to ensure it did not regress in the future writing a new test case was something I felt was important.

I had a working test as part of the test suite of my internal work, but it relied on my components that were not suitable to contribute to Emscripten at this time. My tests also relied on running the test in a tight loop to increase the chances of hitting the race condition. Therefore, I needed a more suitable test case.

Emscripten has an extensive test suite. The first step was to make sure I could run some tests and find a similar test I could copy as a starting point. Running some tests was straightforward with the test/runner program. To identify a test that may cover the same code I ran git blame on doWritev and identified a recent fix with associated test case that I used as my basis for my test, test_fs_writev.

I was able to write a simple test case that demonstrated the problem. The process of writing the test case also allowed me to understand the problem better, as well as learn a lot about the Emscripten code base. I captured my better understanding of the original problem in a new comment on my issue, and I submitted a Pull Request with my fix and test case, PR #22261.

The Review Process

Submitting the pull request was just the beginning. The next step was the review process. Emscripten maintainers reviewed my changes, provided feedback, and suggested improvements. This process was incredibly valuable as it helped me learn more and gave me the opportunity to dive into other related parts of the code base, such as the new WasmFS component to verify it didn’t suffer from the same issue. I was also able to submit a few additional smaller issues and PRs that were triggered by working on this bug fix.

After addressing the feedback, my pull request was merged into main. From observing the bug in my project to getting the PR merged was approximately one week and I am pleased that my bug fix will be part of an upcoming release of Emscripten.

Encouragement for New Contributors

I have been an open-source maintainer for many years, including being a project lead on various Eclipse open-source projects. This was my first contribution in a while on a project I had no prior relationship with. It was really useful to be in the position of a new contributor again as I plan to adapt some of my experiences to improving the other open-source projects that I am part of.

If you’re considering contributing to open-source projects, I highly encourage you to take the plunge. The Emscripten is a healthy project with attentive maintainers who engage well with potential contributors. I hope I can help provide contributors to Eclipse projects have the same sense of pride at contributing as I got from being a first-time contributor to Emscripten.

Alors que vous profitez peut-être de votre été et que vous naviguez par ici, laissez-moi vous montrer un petit prototype sur lequel j’ai travaillé par intermittence à travers plusieurs versions de Sirius Web.

Il est maintenant basé sur la dernière version de Sirius Web. Bravo à l’équipe Sirius pour leurs sorties toutes les 8 semaines comme sur des roulettes !

L’idée a été inspirée par Guesstimate :

Un tableur pour les choses qui ne sont pas certaines !

C’est un outil que j’ai toujours aimé, et je voulais voir jusqu’où nous pouvions aller avec Sirius.

Ce prototype est un outil spécifique au domaine pour la « guesstimation » utilisant des simulations de Monte Carlo. Ce n’est qu’une preuve de concept, mais il met vraiment en valeur certaines fonctionnalités sympas de Sirius Web :

• Toute la logique spécifique au domaine est conservée dans un métamodèle basé sur EMF et l’implémentation Java correspondante. Il n’y a que 11 fichiers et 1 028 lignes de code non généré.
• J’utilise le widget de graphiques dans la vue des détails, ce qui ajoute une touche agréable.
• L’intégration avec les bibliothèques Java est super facile – ici, j’ai utilisé Apache Common Maths et PetitParser.

Regardez la vidéo pour le voir en action !

Combien de temps me faut-il pour faire du café ? was originally published by Cédric Brun at CEO @ Obeo on August 08, 2024.

As you might be enjoying your summer and browsing around here, let me show you a little prototype I’ve been developing on and off through several versions of Sirius Web.

It’s now based on the latest Sirius Web release. Kudos to the Sirius team for releasing every 8 weeks like clockwork!

The idea was inspired by Guesstimate:

� ����������� ��� ������ ���� ����’� �������!�

It’s a tool I’ve always liked, and I wanted to see how far we could take it with Sirius.

This prototype is a domain-specific tool for “�������������� using Monte Carlo simulations. It’s just a proof of concept, but it really showcases some cool features of Sirius Web:

• All the domain-specific logic is kept in an EMF-based metamodel and the corresponding Java implementation. It’s only 11 files and 1028 lines of non-generated code.
• I’m using the charts widget in the details view, which adds a nice touch.
• Integration with Java libraries is super easy – here, I’ve used Apache Common Maths and PetitParser.

Check out the video to see it in action!

How much time do I need to make coffee ? was originally published by Cédric Brun at CEO @ Obeo on August 08, 2024.

Earlier this year, a significant group of open source foundations including Apache Software Foundation, Blender Foundation, PHP Foundation, Python Software Foundation, Rust Foundation, and the Eclipse Foundation – joined forces to launch an exciting new initiative. This initiative aims to help all open source participants navigate and comply with governmental regulations, ensuring the continued use and advancement of open source through the software supply chain.

This initiative is now taking shape through what is now called the Open Regulatory Compliance Working Group, hosted at the Eclipse Foundation. Since our announcement in April, we’ve been tirelessly bootstrapping this group with incredible support from the community. We’ve also welcomed additional backing from both industry and the open source community, including organisations such as  CodeDay, FreeBSD Foundation, iJUG, Matrix.org Foundation, NLnet Labs, Obeo, Open Elements, OpenForum Europe, OpenInfra Foundation, OWASP, Payara Services, and Scanoss.

The Open Regulatory Compliance Working Group is bridging a critical gap between regulatory authorities and the open source ecosystem. By collaborating with relevant authorities and standards organisations, the working group aims to formalise industry best practices so they can be properly referenced in legislation and support the authorities in understanding the peculiarities of the open source ecosystem. This ensures that all open source participants can meet regulatory requirements across jurisdictions and improve software quality and security.

While the Open Regulatory Compliance Working Group is chartered to address compliance with open source-impacting requirements in general, our immediate focus is the European Cyber Resilience Act (CRA), which is on the fast track to implementation. The CRA will come into force soon, followed by a three-year transition period for ironing out implementation details. The agenda for the standardisation process in particular is very tight, as the goal of the European Commission is to have the harmonised standards, for which it issued a draft request on April 17, be available a year in advance to give the industry time for implementation. This leaves us with a very limited time to ensure the unique needs of the open source ecosystem are well understood and properly addressed.

We’re addressing this challenge through a series of parallel work streams:

1. Educating the Community: We’re hosting a series of webinars with the European Commission to bring the open source community up to speed on the EU’s legislative process.These sessions are recorded and available online. The first session, “How to read the CRA: Identifying the key parts of the CRA for effective compliance” led by Enzo Ribagnac, Associate Director of European Policy at Eclipse Foundation, is already available. Slides from our second session with Benjamin Bögel, Head of Sector for Product Security and Certification Policy at the European Commission, are also available online, with the full recording coming soon. Our third session on CRA Standards with guest speaker Filipe Jones Mourão⁩, Policy Officer at the European Commission, took place on July 29. A fourth session titled “CRA OSS implementation: Guidelines, attestations and other key documents.” is planned for September 2.

2. Building an Information Hub: We are creating a centralised hub to consolidate all relevant CRA information in one easily accessible location. This hub will contain educational information, such as recordings of the webinars we have organised, a glossary of terms, key references, and the very useful flow-chart that Maarten Artsen from NLnet Labs has kindly contributed. 

3. Collaborating with the European Commission: We’re closely working with the European Commission services to foster understanding of the legislative and standardisation timeline so we can create and deliver the right artefacts at the right time. Following what should be the timeline defined in the Commission’s standardisation request, our immediate focus is on the horizontal standard whose content is defined in Annex I, Part I of the CRA, along with the product-specific, vertical standards outlined in Annexes III and IV. 

4. Pursuing Formal Liaison Status: We are seeking formal liaison status with European and National Standards Organizations to strengthen our collaboration and impact.

5. Formalising Governance: We are structuring the working group so as to allow for the development of  specifications through a process recognized by the European Union, as well as gather feedback from relevant authorities on the results working group community work. Stay tuned for a formal announcement in September.

6. Regular Updates: We will continue to keep the community informed through regular public calls, with the next one scheduled for Tuesday, August 20 at 2pm CEST.

Join us on this transformative journey as we navigate and shape the future of open source regulatory compliance. For more details and to stay updated, join our mailing list or visit our website.

We are happy to announce the Eclipse Theia 1.52 release! The release contains 47 merged pull requests. In this article, we will highlight some selected improvements and provide an overview of the …

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

Integrating AI into custom tools and IDEs is transforming productivity in many industries. However, the true effectiveness of these AI integrations relies not just on the capabilities of Large …

The post AI Context Management in Domain-specific Tools appeared first on EclipseSource.

The landscape of integrated development environments (IDEs) continues to evolve, offering developers an array of choices tailored to various needs. This article focuses on a comparison between two …

The post The Theia IDE vs VS Code appeared first on EclipseSource.

Software development tools and IDEs have traditionally leaned towards openness and transparency. Much like a mechanic who tunes and customizes their own car for optimal performance, this trend has …

The post The Rise of Closed Source AI Tool Integrations appeared first on EclipseSource.

We are happy to announce the Eclipse Theia 1.51 release! The release contains 55 merged pull requests. In this article, we will highlight some selected improvements and provide an overview of the …

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

Recently, AI assistants have revolutionized how users interact with their Integrated Development Environments (IDEs) and tools. By leveraging large language models (LLMs), these assistants can help …

The post Why Good Context Matters for Efficient AI Assistance in Tools and IDEs appeared first on EclipseSource.

The official release of the Theia IDE opens a new chapter in the area of integrated development environments (IDEs) at Eclipse, moving beyond its beta phase in June 2024. Created based on the robust …

The post Introducing the Theia IDE appeared first on EclipseSource.

In the ever-evolving landscape of software development, achieving a consistent development environment across different machines has always been a challenging task. The age-old adage “It works on my …

The post Zero Set-up Development Environment with Dev Containers appeared first on EclipseSource.

We are happy to announce the Eclipse Theia 1.50 release! The release contains 67 merged pull requests. In this article we will highlight some selected improvements and provide an overview of the …

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

We are happy to announce the sixth Eclipse Theia community release “2024-05”, version 1.49.x! New to Eclipse Theia? It is the next-generation platform for building IDEs and tools for the web or …

The post The Eclipse Theia Community Release 2024-05 appeared first on EclipseSource.

More news

The Eclipse Foundation is pleased to announce the successful implementation of two-factor authentication (2FA) for all committers on both gitlab.eclipse.org and github.com. This initiative, aimed at bolstering the security of our source code repositories, mandates that all users with write access to an Eclipse Project repository (commonly known as committers) on GitHub and the Eclipse Foundation GitLab instance must use 2FA.

Two-factor authentication adds an extra layer of security by requiring not only a password but also a second form of verification. This significantly reduces the risk of unauthorized access and enhances the overall security of Eclipse Foundation projects.

The journey to this milestone has been extensive, but adoption has increased steadily over the past 18 months, aided by regular reminders and progressive enforcement.

We deeply appreciate the cooperation of all our committers in enhancing the security of their repositories. Your commitment to maintaining high security standards is invaluable.

Looking ahead, our next project is to implement 2FA support for Eclipse Foundation accounts. Stay tuned for updates.

This work was made possible by the funding the Eclipse Foundation received from the Alpha-Omega Project.

Today, we are announcing the deprecation of the Eclipse User Storage Service SDK (the Eclipse project) and the Eclipse User Storage Service API (hosted and maintained by the Eclipse Foundation).

The Eclipse User Storage Service (USS) API was created in 2015 to enable Eclipse projects to store and retrieve user data and preferences from our servers. Complementing this is the Eclipse User Storage Service SDK which offers a user-friendly Java library tailored for Eclipse RCP-based applications to simplify the integration with Eclipse USS API by managing the authentication and login processes.

Despite their past utility, the usage of this service has been steadily declining, and the costs associated with maintaining it are increasing.

Our current plan is to remove the Eclipse USS SDK from SimRel before the release of Eclipse IDE 2025-03 and to shut down the API service by 2 July 2025.

We appreciate your understanding and cooperation as we navigate these changes. If you have any questions or require further assistance, please don’t hesitate to reach out via our helpdesk issue #4696.

References

• Deprecate the Eclipse User Storage Service (USS) by 2 July 2025.
• Eclipse User Storage Service SDK project
• Eclipse USS OpenAPI Docs
• Eclipsepedia: Eclipse USS
• Eclipse Oomph
• Eclipse MarketPlace Client