Over almost two decades, the Eclipse Platform and Rich Client Platform (RCP) have been foundational technologies for building extensible desktop applications, tools, and custom IDEs. From engineering …

The post The Future of the Eclipse Platform and Eclipse RCP appeared first on EclipseSource.

Java grants new wishes every six months in feature releases.

Photo by Louis Hansel on Unsplash

Wishing or Waiting?

I made a wish in 2004 for lambdas to find their way into Java. I waited for a decade for lambdas to arrive, and they eventually arrived. Java has been a much better programming language to work in ever since. Lambdas, method references, and default methods were all amazing features in Java 8 that library developers could use to develop even better products. Java 8 kind of gave me everything I ever wanted in Java, except for eight tiny little things with generics.

In the rest of this blog, I will explain a wish we are still patiently hoping will arrive in the the JDK one day, but that we decided over a decade ago to not wait for. Waiting for the feature would have hamstrung development of Eclipse Collections primitive collection support. Not waiting was absolutely the right decision for the library. Eclipse Collections users have been able to leverage a plethora of Functional Interface type combinations with lambdas for the past decade. This combination of Functional Interfaces will likely not be found anywhere else. I’m sure many developers have had to create a smaller number of their own named Functional Interfaces when they needed them, just as we have in Eclipse Collections. Java Stream did exactly the same thing with IntStream, LongStream, and DoubleStream, just on a smaller scale than we did in Eclipse Collections.

Library first, Valhalla later

Lambdas implemented with nominal types simultaneously created a tremendous opportunity, and unfortunate deficiency for Java. Java has support for lambdas, but does not have support for Generics Over Primitive Types. We have Object and primitive collections in Eclipse Collections, and wanted our Functional Interfaces to work with all combinations of primitive types.

We decided to solve this problem in the library, as we couldn’t wait for the language to have support for primitives in generics. Sometimes library developers are faced with the difficult decision of incurring cost and implementing something today, that may be made much simpler in the future with improved language support. We made the decision to implement primitive collections with a feature-rich API around 2012 (pre-lambda days), so the cost of implementing the interfaces has long been paid off in my opinion. Code generation using StringTemplate made the problem much easier to implement.

Below is an image depicting one dimension of the resulting cost of supporting all primitive types in Functional Interface type combinations in Eclipse Collections. This mind map shows the explosion of types that occurred for one set of Functional Interfaces called Procedure. Procedure is the equivalent of Consumer in the JDK. Ideally, there should only be two Procedure Functional Interfaces in Eclipse Collections — Procedure and Procedure2. As the diagram below shows, there are a lot more than two Procedure types in Eclipse Collections.

Mind map drawn with my favorite UML/Mindmap tool — Astah UML

Note, Procedure has a void return type. The picture for Predicate would be equally and painfully annoying to draw, because Predicate has a boolean return type. The picture for Function which has a variable return type would be too painful for any human to draw by hand. You just need to imagine it is really bad. Yes, Eclipse Collections did the hard work of generating all of the Functional Interface types to support primitives for Procedure, Predicate, Function, and Comparator. Note: Click the links to see the actual code generated interfaces in JavaDoc.

I created a much abbreviated version of this picture in a table in the book Eclipse Collections Categorically. The table requires you to imagine replacing a wildcard (?) with combinations of boolean, byte, char, short, int, float, long, double and sometimes Object. This shows why Function is even worse. It has an extra ? to deal with in the type names for the return type (see row 2 and 4 below).

The bottom two rows show the abbreviated version of “Procedure” Functional Interfaces

The resulting explosion takes eight rows from this table and results in hundreds of named types being code generated to support primitives in Functional Interface types. If the support for generics for primitives eventually arrives in Valhalla, we would only need to have eight Functional Interface type in Eclipse Collections.

The types probably have very little meaning for folks reading this blog, without knowledge of the Eclipse Collections API and how these types are encountered and/or used by developers. Below, Example 21 from the Kindle edition of Eclipse Collections Categorically shows two methods that use primitive functional interfaces that are code generated. The method select on an IntList takes an IntPredicate. As explained in comment 2, an inlined lambda is used here, so the method parameter type is never seen in the code by the reader. The method collect on IntList takes an IntToObjectFunction<Integer>. As explained but not visible in comment 4, an inlined method reference is used here, so the method parameter type is never seen in the code by the reader.

If we had waited for Valhalla to solve this type explosion problem for Eclipse Collections, we would still be waiting unfortunately. We decided to go library first, and worry about how we can possibly reduce the number of necessary types later when Valhalla with Generics Over Primitive Types arrives in some form. The Valhalla strategy has progressed and evolved over the last decade. Thankfully, we committed to and have stuck with our approach delivering much appreciated primitive collection support to our user base. It was an expense to “bite the bullet” over a decade ago and code generate all of these Functional Interfaces, but it was a one time expense. Since then we’ve been able to focus on API development and evolution on our Object and primitive container types. Lambdas and method references are available in so many magical combinations of types for Eclipse Collections.

So if we’re not waiting for Valhalla, what have we been waiting for in Java for Eclipse Collections?

We’ve been waiting for Java 17!

Wait… what? Why Java 17? What about Java 21 or the soon to be released Java 25?

Core Java library development necessarily lags behind application development in terms of language version usage. We’ve been developing using Java 11 for Eclipse Collections development for the past couple of years, but honestly there are not that many interesting language features for Eclipse Collections in 11 compared to 17. Eclipse Collections 11.x was compiled using Java 8, which is now eleven years old. Java 11 is now almost 7 years old. Java 17 is only 4 years old! Development in Eclipse Collections on Java 17 will now feel like driving in a certified pre-owned car! It might have 40K miles on it, but it is super reliable and still goes vroom!!! We are excited by the upgrade!

Eclipse Collections just went through a rapid upgrade cycle in order for us to adopt Java 17 in a release and development. Eclipse Collections 11.1 was released on Java 8, almost three years ago. Eclipse Collections 12.0 was just released on Java 11 a few weeks ago. Eclipse Collections 13.0, which is identical in features to 12.0, was released on Java 17 three days later. Development on Eclipse Collections 14.x is baselined to Java 17.

Note: The release notes and release blog for Eclipse Collections 12.0 and 13.0 are still forthcoming. Stay tuned!

We’ve been waiting for four years to upgrade Eclipse Collections development to Java 17. With the imminent release of Java 25 in September, and the completion of the Eclipse Collections 12.0 release, we decided to have another major Eclipse Collections release to just uptick the version of Java we use to compile. Upgrading to a new language version is straightforward for us in Eclipse Collections, as we continue testing against LTS versions of JDK, the current JDK release, and the current early access (EA) version of OpenJDK.

There are some features in the language in Java 17 that we can now use to simplify code in Eclipse Collections. Pattern matching for instanceof is one feature, Java Records, and Sealed Types are some others. If Pattern Matching for Switch wasn’t in preview in Java 17, we would use that in the Iterate and other utility classes as well. I hope the upgrade is another reason for developers to consider using and contributing to Eclipse Collections. The library continues to evolve thanks to folks from the open source community.

Stop wishing and waiting for unicorns

Java continues to evolve at a rapid pace. If you are waiting for something specific and epic to arrive (like Valhalla), you may be waiting for a bit still. You may also get something slightly different than you originally wished for when it arrives. I feel like we are closer than ever to seeing some major changes in the language from Valhalla, but I’m glad that we did not wait for it for Eclipse Collections. I’m excited to see if it will eventually help us reduce the number of interfaces and classes we have to support in Eclipse Collections today.

A healthy horse you can ride today is better than the unicorn you are wishing might arrive one day.

Java is great today, no matter what version you use. Java has been great since Java 8 in my opinion, and continues to get better with each release. Eclipse Collections started out its existence developed using Java SE 1.4. I will save you the trial and tribulation stories of adding generics support to Eclipse Collections in its proprietary form when I worked at Goldman Sachs after Java 5 arrived. Java 8 was, for obvious reasons, my favorite release with my most important wish granted — lambdas. It even came with a few awesome extra wishes I didn’t make including default methods, method references, and Java Stream.

If you’re wishing you had a more feature-rich collections API available in Java today, I have great news for you. That already exists in third-party library form, just not in the JDK. Eclipse Collections has been evolving a feature-rich collections API for over twenty years solving mission critical problems for applications and libraries. If you want to learn more about the Eclipse Collections API, I can recommend my book, Eclipse Collections Categorically. There are other free learning options like blogs, katas, reference guide and the Eclipse Collections README as well.

On the Valhalla waiting front, I am happy for the work to get done well instead of fast. It is, after all, an “epic refactor”, and we need it to be both useful and not break all the apps we’ve written the past 25 years. Evolution is hard and takes time. When enough interesting functionality from Valhalla arrives, I will likely advocate to get Eclipse Collections development upgraded as soon as possible so we can begin leveraging it.

Thank you for reading!

I am the creator of and committer for the Eclipse Collections OSS project, which is managed at the Eclipse Foundation. Eclipse Collections is open for contributions. I am also the author of the book, Eclipse Collections Categorically: Level up your programming game.

Thank you for being a part of the community

Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Newsletter | Podcast | Twitch
• Start your own free AI-powered blog on Differ 🚀
• Join our content creators community on Discord 🧑🏻‍💻
• For more content, visit plainenglish.io + stackademic.com

What are you wishing or waiting for in Java? was originally published in Stackademic on Medium, where people are continuing the conversation by highlighting and responding to this story.

There have been recent reports of critical security vulnerabilities on the mcp-remote project, and the mcp inspector project.

I do not know all the technical details of the exploits, but it appears to me that in both cases it has to do vulnerabilities introduced by the MCP Server implementation. and use of the stdio MCP transport.

I want to emphasize that example described in these two posts

Integration via Remote Tools

Example Using Remote Services

is using mechanisms that are...though heavy usage by commercial server technologies over the past 10 years...not subject to the same sorts of remote vulnerabilities seen by the mcp-remote and mcp-inspector projects.   

Also, the flexibility in discovery and distribution provided by the RSA Specification and the RSA implementation used, allows for addressing MCP Server remote tools, or protocol weaknesses, quickly and easily, without having to update the MCP Server or tooling implementation code.  

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

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

Manual testing takes time. Writing end-to-end tests takes even more. What if you could automatically test your web app by simply talking to an AI agent? Now you can-with the App Tester Agent in the …

The post AI Driven E2E Testing with the Theia IDE appeared first on EclipseSource.

It has become popular to build Model Context Protocol Servers.  This makes a lot of sense from the developer-as-integrator point of view, since the MCP specification and multi-language SDKs make it possible to easily integrate resources, prompts, and tools into multiple LLMs without having to use the model-and-language-specific model APIs directly.

MCP tools spec provides a general way for LLMs to use tool meta-data (e.g. text descriptions) for the tool's required input data, behavior, and output data.  These text descriptions can then be used by the LLM...in combination with interaction with the user...to decide when and how to use the tool...i.e. to call the function and provide some output to the LLM and/or the user.

Building an MCP Server

When creating a new MCP Server, it's easiest to create the tool metadata and implement the tool functionality as part of a new MCP server implementation.   But this approach requires that every new tool (or integration with existing API/servers) results in a new MCP server or an update/new version of an existing MCP server.

Remote Tools

It's frequently better architecture to decouple the meta-data declaration and implementation of a given tool from the MCP Server itself, and allow the MCP Server to dynamically add/remove tools at runtime, as tools can then be discovered, added, meta-data made available to the model(s), called, evaluated, and potentially removed or updated without the creation of an entirely new MCP Server, but rather dynamically discovering, securing, importing, using, evaluating, updating, and removing tools from an MCP Server.  

This approach is potentially more secure (as it allows tool-specific authentication and access control), more flexible, and more scalable, since remote tools can be distributed on multiple hosts over a network.  And it allows easy integration with existing APIs.

In the next post I describe a working example that uses remote tools.

In a previous post, I described how using dynamic remote tools could make building MCP Servers more flexible, more secure, and more scalable.  In this post, I show an example MCP Server that uses remote services and Bndtools to build.

To use/try this example yourself see Installing Bndtools with Remote Services Support below.

Create a Bndtools Workspace via File->New->Bndtools Workspace, and choose the ECF/bndtools.workspace template from this dialog

Choose Next->Finish

Choose File->New->Bnd OSGi Project to show this dialog

1. MCP ArithmeticTools API Project  (example name: org.test.api)

2. MCP ArithmeticTools Impl Server Project (ArimethicTools RS Server) (example name: org.test.impl)

3. MCP ArithmeticTools Consumer Project (MCP Server Impl/ArithmeticTools Consumer) (example name: org.test.mcpserver)

4. MCP ArithmeticTools Test Client Project (MCP Client) (example name: org.test.mcpclient)

Note:  For the Impl/Consumer/Test Client project creations you will be prompted to provide the name of the project that you specified for the API Project (1)

Click Finish for each of the first 3 (server) projects.

If you wish to use your own MCP Client, and start the MCP Server (MCP ArithmeticTools Consumer Project) from your own MCP Client (stdio transport), see the Readme.md in the MCP ArithmeticTools Consumer project.

MCP ArithmeticTools Example Test Client

There is also a MCP Example Test Client Project template, implemented via the MCP Java SDK that makes a couple of test calls to the MCP Server/Arithmetic Tools Consumer server.

Note:  When creating the test client, the project template will as for you to specify the names of the API project (1) and the MCP Server/ArithmeticTools Consumer project (3).   For example:

Click Finish

You should have these four projects in the Bndtools Explorer

You can open source for any/all the projects, set breakpoints, etc.

Launching the ArithmeticTools Remote Service Impl server

The ArithmeticTools Impl server (2) must be launched first

To launch the ArithmeticTools Impl (2), see the Readme.md in that project

Launching MCP Client and MCP Server (with stdio transport)

The MCP Client (4) may then be launched, and it will launch the MCP Server (3) and use the MCP stdio transport.   The MCP Client (4) Readme.md more info on launch and expected output of the MCP Client.

You may examine or set breakpoints in the ArithmeticTools Impl Server (2) or the MCP Client (4) to examine the communication sequence for calling the ArithmeticTools.add or multiple tools.

Installing Bndtools with Remote Services Support

1. Install Bndtools 7.1 

2. Add ECF Latest Update site to Eclipse install with URL: https://download.eclipse.org/rt/ecf/latest/site.p2

3. Install Feature:  SDK for Bndtools 7.1+

Tired of micromanaging every code suggestion your AI coding assistant makes—manually reviewing each file and fixing its mistakes yourself? There’s now a faster, more powerful alternative: Agent Mode …

The post Theia Coder Agent Mode: From AI Assistant to Autonomous Developer appeared first on EclipseSource.

Checking for containment in direct and indirect ways.

Photo by Super Tseng on Unsplash

Asking a collection in Java if it contains a specific thing is kind of like playing peekaboo. I was experimenting with different ways of seeing if a Collection in Eclipse Collections contains a specific element. I used a combination of contains, containsBy, anySatisfy, Stream.anyMatch. I look for a specific String in uppercase and lowercase, which is stored in lowercase in two different kinds of Bag. One Bag just uses hashCode and equals for identifying via contains. The other Bag uses a HashingStrategy.

@Test
public void testingIfAnElementIsContained()
{
    MutableBag<String> bag =
            Bags.mutable.with("ant", "bat", "cat");

    // using contains on a Bag is o(1) but requires an exact match
    assertFalse(bag.contains("CAT"));
    assertTrue(bag.contains("cat"));
    assertFalse(bag.contains("dog"));

    // using containsBy is o(n) and can be lenient on the item contained
    assertTrue(bag.containsBy(String::toUpperCase, "CAT"));
    assertFalse(bag.containsBy(String::toUpperCase, "cat"));
    assertFalse(bag.containsBy(String::toUpperCase, "DOG"));

    // using anySatisfy with equalsIgnoreCase is o(n) and is lenient
    assertTrue(bag.anySatisfy("CAT"::equalsIgnoreCase));
    assertTrue(bag.anySatisfy("cat"::equalsIgnoreCase));
    assertFalse(bag.anySatisfy("DOG"::equalsIgnoreCase));

    // using anyMatch with equalsIgnoreCase is o(n) and is lenient
    assertTrue(bag.stream()
            .anyMatch("CAT"::equalsIgnoreCase));
    assertTrue(bag.stream()
            .anyMatch("cat"::equalsIgnoreCase));
    assertFalse(bag.stream()
            .anyMatch("DOG"::equalsIgnoreCase));

    // Using map, anyMatch, equals is o(n) and lenient on the item matched
    assertTrue(bag.stream()
            .map(String::toUpperCase)
            .anyMatch("CAT"::equals));
    assertFalse(bag.stream()
            .map(String::toUpperCase)
            .anyMatch("cat"::equals));
    assertFalse(bag.stream()
            .map(String::toUpperCase)
            .anyMatch("dog"::equals));

    MutableBag<String> hsBag =
            HashingStrategyBags.mutable.fromFunction(String::toUpperCase);
    hsBag.with("ant").with("bat").with("cat");

    // using contains on a Bag with HashingStrategy is o(1) and is lenient
    assertTrue(hsBag.contains("CAT"));
    assertTrue(hsBag.contains("cat"));
    assertFalse(hsBag.contains("dog"));
}

The methods contains, containsBy, anySatisfy, anyMatch are all categorized as “Testing” methods in my book Eclipse Collections Categorically, as these methods help you test for the presence or absence of an element in a collection.

I felt like writing a short coding blog, so that’s all! Thank you for reading!

I am the creator of and committer for the Eclipse Collections OSS project, which is managed at the Eclipse Foundation. Eclipse Collections is open for contributions. I am also the author of the book, Eclipse Collections Categorically: Level up your programming game.

This security advisory provides additional technical details following our initial statement and the corresponding CVE record.

TL;DR

A vulnerability in the Eclipse Open VSX Registry’s automated publishing system could have allowed unauthorized extension uploads. It did not affect existing extensions or admin functions.

The issue was reported on May 4, 2025, fully fixed by June 24, and followed by a complete audit. No evidence of compromise was found, but 81 extensions were proactively deactivated as a precaution.

The standard publishing process was not impacted. Recommendations have been issued to reduce future risk.

The Issue

On May 4, 2025, the Eclipse Foundation Security Team received a notification from Koi Security researchers about a potential vulnerability in the Eclipse Open VSX Registry extension publication process. The Security Team promptly contacted the Open VSX team, which confirmed the issue and began working on a fix. A first version of the fix was proposed within two weeks.

The Eclipse Open VSX Registry allows developers to publish extensions via CI/CD systems. To increase the availability of widely used extensions to its growing user base, it also includes a mechanism that automatically pulls, builds, and publishes a curated list of extensions. This list is publicly maintained in a configuration file. The vulnerability was found in this automated process.

Specifically, build scripts were executed without proper isolation, which could have inadvertently exposed a privileged token. This token allowed publishing of new extension versions under any namespace, including those not owned by an attacker. However, it did not allow deletion of existing extensions, overwriting of published versions, or access to administrative features of the registry.

To exploit this vulnerability, an attacker would need to either:

• Take over an already accepted extension (e.g., by compromising the developer’s account) and inject malicious code to exfiltrate the token; or
• Submit a new extension for inclusion in the auto-publish list, have it accepted (following a manual review of the pull request), and later push a new version with code designed to exfiltrate the token.

In both scenarios, any extension published using the token would appear to originate from the privileged user, which serves as a basis for the ongoing investigation into potential exploitation.

The Fix

The Eclipse Open VSX team implemented sandboxing for the extension build process to isolate builds and protect credentials. The fix underwent several iterations and was successfully deployed on June 24, 2025.

Importantly, this vulnerability only affected the auto-publishing mechanism. An attacker would have needed to control an extension listed for automatic updates or get their own extension added to the list. The standard extension publishing workflow is not affected by this vulnerability.

Timeline Summary

• May 4, 2025 – Vulnerability reported by Koi Security researchers
• May 5–17, 2025 – Issue confirmed and first version of fix developed
• May 17–June 24, 2025 – Development and testing of updated versions of the fix
• June 24, 2025 – Final fix approved and deployed; privileged token rotated
• Post-deployment – Audit of all affected extensions completed
• June 27, 2025 – CVE-2025-6705 published
• July 2, 2025 – Security advisory published

Investigation Summary

As the root cause was the lack of build isolation, the implemented patch introduces sandboxing and separation between build processes. It was deployed on June 24, 2025, and the potentially exposed privileged token was rotated following the deployment.

To determine whether the vulnerability had been exploited, the Eclipse Security and Open VSX teams audited all extensions published using the privileged token. These were cross-referenced with all extensions listed for automatic publication, whether currently or previously included. The focus was first on extensions that were published using the privileged token but were never added to the auto-publish list.

Findings: 14 extensions, encompassing a total of 20 unique published versions, were identified as having been published by the privileged user without a clear link to the auto-publish list. Although this is atypical, there has long existed a one-off workflow allowing Open VSX Registry operators to publish new extensions manually. It is most likely that these 20 revisions were published using this workflow.

As automation had reached its limits, the team manually reviewed the suspicious extensions. All were deemed legitimate and did not display signs of compromise. Indicators of compromise considered included:

• Mismatches between publication dates and repository tags/releases
• Publication of unknown versions
• Discrepancies between Eclipse Open VSX and the Microsoft Visual Studio Code Marketplace
• Sudden change in publishing behavior (e.g., from the extension owner to the privileged user)
• Other anomalous patterns

We then examined extensions legitimately published by the privileged user (by virtue of being listed for auto-publishing), searching for irregularities based on the indicators mentioned above. We identified 51 such extensions (61 unique extension versions), warranting further manual investigation. In all cases, however, the anomalies were ultimately ruled out. For example, while certain extension versions lacked a corresponding tag or formal release in their source repository, their version numbers had previously appeared in the build configuration history within the source repository. These versions were never officially released, but their publication dates aligned with the commit dates, strengthening the confidence that these were false positives rather than signs of compromise.

Conclusion: None of the 65 identified extensions (81 distinct published versions) showed evidence of being compromised. Nevertheless, as a precaution, all 81 versions have been deactivated while we contact their respective authors. Should evidence of compromise emerge, further advisories will be issued.

Recommendations

Based on our findings, we recommend the following actions to address the root causes of this vulnerability:

For Open VSX Registry operators:

• Mitigate risk from untrusted code: enforce a documented vetting process for new extensions before adding them to the auto-publish list. This limits exposure from potentially malicious submissions.
• Reduce exposure window: periodically review accepted extensions, especially after updates, to detect suspicious behavior that may emerge post-approval.
• Contain credential blast radius: replace shared, privileged tokens with namespace-specific credentials. This enforces the principle of least privilege and prevents cross-namespace publishing.
• Eliminate insecure workflows: consider disabling the auto-publishing mechanism entirely, or at a minimum, remove the one-off manual publishing feature, which bypasses the protections applied to the automated pipeline.

For the Open VSX user community:

• Exercise caution when installing or updating extensions. Extensions can access your development environment and may introduce risk if compromised. They are a critical part of the software supply chain and must be treated as such.

More Information

The Eclipse Open VSX Registry has grown significantly in popularity. We are grateful to Koi Security researchers for their responsible disclosure and encourage all users and vendors relying on Eclipse Open VSX to contribute to its continued security and sustainability. The Eclipse Foundation remains committed to ensuring the Open VSX Registry is a safe, trusted, and reliable platform for distributing and consuming secure, high-quality extensions.

For technical or security-related inquiries, please contact the Eclipse Foundation Security Team at security@eclipse-foundation.org.

Are you using AI agents to assist with feature development or bug fixing—only to find yourself stuck in an unstructured back-and-forth chat session? Of course, you could wait for the next generation …

The post Structured AI Coding with Task Context: A Better Way to Work with AI Agents appeared first on EclipseSource.

Shelf space for technology books in book stores seems to be shrinking.

The very hard to locate technology section of my local book store

For thirty-five years, I have been a retail book store junkie. I have easily spent hundreds of hours walking through the technology sections of book stores over the years. In the process, I have found and bought many amazing books. In the 1990s and early 2000s, books stores I frequented would include Borders, Barnes and Noble, Foyles (London) and other independent book stores like Politics and Prose in Washington D.C. I still occasionally drop in to a Barnes and Noble for coffee and to see what has become of the technology section. I have been fairly disappointed with the rapid decline in availability of technology books in book stores since the pandemic. The technology sections continue to shrink, and recently was so hard to find at my local book store, I thought maybe it had completely disappeared. I finally found it after refusing to give up hope. The picture of the technology section I found is above.

My Book Shelves are Almost Full

The resulting benefit of having been a book store junkie for so long is that I have an amazing technology book shelf at home. The variety and age of technology books varies from the 1980s to released in 2025. I have some older books outside of the tech space, like poetry, history, jokes, cookbooks, yearbooks, but the technology books fill the most cubbies on my book shelf.

As a new Java programming book author myself, I expected and planned on being disappointed by the technology section of my local retail book store. I do not expect I will ever see my book on the bookshelf there. I saw the post-pandemic technology book shelf shrinking happening in real time. Literally two full rows of book shelves in 2019 consolidated down to a single book shelf with mostly books “for dummies” and books from No Starch Press in 2025. I have a few titles from both publishers on my book shelf.

Bad Medicine

I had a hard time finding any Java programming books on the shelf of my local book store. Then I looked at the shelf right next to the Technology section which was labeled “Medicine.” I think the title of the shelf says all that needs to to be said. Queue the Bon Jovi song. This is a tough pill for a programming book author to swallow. If you’re planning or thinking of becoming a programming book author, it’s best to set your expectations accordingly. Check out your own local book stores to confirm, as it is possible my experience with technology book shelves is a statistical anomaly. I’ve had to explain to family and friends that it is very unlikely that my book will ever be found on a retail book store shelf. I am much more hopeful for my book to appear in my local library, especially once I offer to donate a copy.

Two Java books in a mostly empty shelf titled “Medicine”

I find it hard to blame book stores for the sparse number of technology and programming books on their shelves. I’m pretty sure they put up books that sell. If tech books aren’t selling, it’s most likely because there are not enough tech folks going to buy programming books in retail book stores. This is not for a lack of some amazing technical books having been written over the years. I know this because I have bought some of them for my own bookshelf.

Searching for Retail Book Stores with Tech Books

I’ve only sampled a few book stores that are near where I live, or occasionally when I travel. The experience of shrinking technology book sections has been fairly consistent so far. I used to go to Foyles book store in London and scan the technology section for great books when I lived in London in 2004. They had an amazing selection. I haven’t been in London since 2014 so am not sure how the past decade has impacted Foyles.

If you know of any book stores that have a decent selection of technology books, regardless of city, state, country, planet, please leave a comment on this blog.

I would love to visit book stores that still stock great works (old and new) on their book shelves. Maybe collectively we can help bring some foot traffic and business to any retail book stores that stock important technology works, before finding and buying books online is the only option that is available. That’s if it is not already too late.

Thank you for reading!

I am the creator of and committer for the Eclipse Collections OSS project, which is managed at the Eclipse Foundation. Eclipse Collections is open for contributions. I am also the author of the book, Eclipse Collections Categorically: Level up your programming game.

On May 4th, the Eclipse Foundation (EF) Security Team received a notification from researchers at Koi Security regarding a potential issue in the Eclipse Open VSX marketplace extension publication process. The EF Security Team immediately contacted the Eclipse Open VSX team, and upon confirming the issue, work on a fix was promptly initiated.

Following several iterations and thorough testing (necessary due to the intrusive nature of the change to the extension build process) the fix was successfully deployed on June 24th.

We would like to thank the researchers for reporting the issue, reviewing the proposed fixes, and supporting the resolution process, as well as the members of the Eclipse Open VSX team who were involved.

The researchers have published their findings at Koi Security’s blog, providing further insight into the issue. Additionally, we have published CVE-2025-6705 to track and document this vulnerability.

A more detailed technical security advisory will be published in the coming days.

Eclipse Open VSX has grown in popularity in recent months, and we’re grateful to independent researchers for their investigation and responsible disclosure. We encourage all projects that depend on Eclipse Open VSX to consider contributing to or financially supporting the initiative.

As developers, we interact with an ever-growing range of tools that help us write, fix, and understand code. From rule-based linters that enforce formatting to autonomous AI agents capable of planning …

The post The AI Coding Spectrum: 6 Levels of Assistance Developers Should Know appeared first on EclipseSource.

Eclipse Collections 12.0 and three print books are available now.

Three Years, where have you gone!?!?!

If you ask me what we’ve been up to in the Eclipse Collections space the past three years, the answer is A LOT! I started writing the Eclipse Collections Categorically book at the beginning of 2024, and published the first version of the book in paperback on March 16, 2025. Since then I have continued working on additional print versions of the book (see below), as I work to release the first eBook version of the book for Amazon Kindle on June 30, 2025.

Meanwhile, development in the the Eclipse Collections library has been quietly progressing every day. Eclipse Collections 12.0 was released on Maven Central this week. The last milestone release for 12.0 (12.0.0.M3) was released two years ago. This is the first formal release of Eclipse Collections since 11.1 was released on July 6, 2022.

Read on to find out more about updates for Eclipse Collections Categorically and the Eclipse Collections 12.0 release.

Three print versions now available

Eclipse Collections Categorically is now available in three print versions. The print versions of the book are all printed in color, with the larger hardback version printed with premium paper. Printing in color adds some cost, but significantly enhances the experience for the reader. Unfortunately, color printed versions of the ECC book are not yet available in all countries. I am working on adding additional print distribution channels for the book, so folks who prefer physical books (like myself) have access. Stay tuned.

In the picture above, you can see the paperback and two hardcover versions of Eclipse Collections Categorically. Below you will find some of the details and links to sites where the books are available for purchase.

📕(left) 📘(center) 📗(right)

📕 Paperback (glossy), 7.5 x 9.25 inches, standard paper (Amazon)
📘 Hardcover (matte), 7.5 x 9.25 inches, standard paper (Barnes and Noble)
📗 Hardcover (glossy), 8.25 x 11 inches, premium paper (Amazon)
🔸 An eBook version will be available for Amazon Kindle on June 30, 2025.

This is a sample page from the preface in the hardcover glossy version of the book with the larger pages and premium paper.

Preface: The Joy of Programming from glossy hardcover version of Eclipse Collections Categorically

The road to the eBook

On June 30, 2025, the first eBook version of “Eclipse Collections Categorically” will be available on Amazon Kindle. This should significantly increase the global distribution and availability of the book.

I will eventually look to add other eBook options. I have been testing the book on Amazon Kindle and Apple Books.

This is a sample of pages from the preface in Apple Books on my MacBook Pro.

Preface: The Joy of Programming from Eclipse Collections Categorically in Apple Books

I hope you enjoy the book in one of the print versions or digital eBook version once it becomes available. In the mean time, there is something else available that you may have been waiting for.

Eclipse Collections 12.0 Available Now!!!

The Eclipse Collections 12.0 release is available now. Woo hoo! Thanks to Nikhil Nanivadekar for making this happen. It has been three years since Eclipse Collections 11.1 was released. 11.1 is the version I cover in the book, with examples developed using Java 21. The API of Eclipse Collections has not changed too much in 12.0. There have been a few new methods added to various interfaces, and there have been a large variety of other improvements to the library over the past three years. Go to the Eclipse Collections Github repo for notes and info on the latest release.

Thank you for reading, and I hope you experience the Joy of Programming today!

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 also the author of the book, Eclipse Collections Categorically: Level up your programming game.

With the inclusion of PR 15795, the Theia 1.63.0 release that has been built today now supports Ollama release 0.9.0 which has introduced several improvements, which are now also available in Theia AI. This post highlights those improvements and gives a few general hints on how to improve your experience with Ollama in Theia AI.

Streaming Tool Calling

One of the most interesting features of the Ollama 0.9.0 release is support for streaming tool calling in the API. This makes working with the LLM much more convenient, as you can follow the output and tool calls during the generation. As a side effect, this also boosts output quality especially for tool calls for the models that support them. See this article for more information on this.

Starting with Theia 1.63.0, Theia AI uses the new streaming API including tool calling so that Ollama models now behave more like models from other providers, such as OpenAI, Google, and Anthropic.

Explicit Thinking Markup

Thinking or reasoning in LLMs have received much attention in the recent months, especially since deepseek-r1 was announced. While Ollama did support reasoning models for several months now, the reasoning steps have always been part of the actually generated response and could only be extracted by looking for <think>...</think> or similar markup generated by the LLM. 

Ollama 0.9.0 has added support for distinguishing reasoning output and actual output on the API level. The new Ollama provider in Theia propagates this feature so collapsible reasoning blocks are rendered on the UI level.

Token Usage Reporting for Ollama

Of course, as you are running Ollama most likely on your own hardware, the token usage report is not as crucial as with paid third-party services. But still, it might be at least interesting to know how many tokens you are using with your own Ollama server. 

The new Ollama provider released in Theia 1.63.0 now reports token usage statistics in the AI Configuration View in the tab Token Usage.

Support for Images in the Chat Context

Theia 1.63.0 has added preliminary support for images in the Theia AI chat. Using the + button in the AI Chat, it is now possible to add images which are passed to the LLM as part of the context. This is also supported for Ollama LLMs; but note that not many models support images. One example is the llava model.

If unsure, you can use the ollama show command in a terminal to check for the image capability of a model.

Configuration and Usage Hints

Using an Ollama server running on usually limited local hardware is most likely no competition for paid 3rd party services. But maybe the absence of token limits and privacy concerns are still sometimes more important than performance. To make Ollama models at least a bit more usable in practice, it is important to tweak the configuration to adapt it to your hardware and needs. This section gives some hints about possible optimizations. Note: these settings have been tested with an Apple Silicon M1 Max system; for other hardware, please refer to other blog articles that discuss Ollama optimizations.

Ollama Server Settings

To reduce the memory footprint of the request context, set these environment variables before executing ollama serve:

• OLLAMA_FLASH_ATTENTION=1

• OLLAMA_KV_CACHE_TYPE="q8_0"

See the Ollama FAQ for more details.

Theia AI Considerations

We might be tempted to download and use different models for different Theia AI agents, e.g. a universal model, such as qwen3 for universal tasks, and more specialized models, such as codellama for code-centric tasks like the Coder or Code Completion agent. However, we need to consider that each model that is loaded at the same time uses a lot of memory so that Ollama might decide to unload models that are not used at the moment. And since unloading and loading models takes some time, performance decreases if you use too many models.

Therefore, it is usually a better idea to use fewer models, for example one smaller model for tasks that should not take too long (such as Code Completion and Chat Session Naming), and one larger model for complex tasks (such as Architect or Coder agents). The best results can be achieved if both models fit in the available VRAM so that no model loading/unloading occurs.

Theia AI Request Settings

One important thing to note is that Ollama per default uses a context window of just 2048 tokens. Most tasks in Theia AI will not provide satisfactory results with this default. Therefore it is important to adjust the request settings and to increase the num_ctx parameter. As with the model size discussed before, the context size should be set to match the agent and task because a larger context leads to results with higher quality but longer runtimes. Therefore, it is important to play around with the settings and find the optimal settings matching the used models and the use case.

These hints provide some initial help:

• Check the Ollama server logs and keep an eye out for messages like this:
  "truncating input prompt" limit=2048 prompt=4313 keep=4 new=1024
  This message indicates that the input prompt exceeds the required context length, so the input prompt will be truncated (which will usually lead to bad answers from the model, as it will forget half of the question you were asking...)
• Also during the process of loading a model, if you see a message like 
  llama_context: n_ctx_per_seq (2048) < n_ctx_train (40960)
  this indicates that the current num_ctx (2048) setting is smaller than the context window the model was trained with (40960).
  Alternatively, you can also use ollama show to check for the context length property of the model. (Do not confuse the context length property, which is the theoretical maximum context length for this model with the num_ctx parameter, which is the actual context length used in requests).

To adjust the num_ctx parameter in Theia, go to Settings > AI Features > Model Settings and follow the link to open the settings.json file in the editor.

Then create a new setting like this:

"ai-features.modelSettings.requestSettings": [
{
  "scope": {
    "agentId": "Coder",
    "modelId": "ollama/qwen3:14b",
    "providerId": "ollama"
  },
  "requestSettings": { "num_ctx": 40960 }
}]

In the scope part, you declare the provider, model, and agent to which apply the settings. You can leave out either key to apply the setting for all providers, agents, and/or models, respectively. 

In the same way you can adjust and play around with the other Ollama parameters, such as temperature, top_k, etc. 

Want to automate your daily workflows with AI - without writing any backend code? In this demo, we show how to create a custom AI agent from scratch using the AI-powered Theia IDE, based on Theia AI. …

The post How to Build Custom AI Agents in the Theia IDE appeared first on EclipseSource.

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

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

The connections in your network are important to discover and invest in.

The Foreword written by José Paumard, from “Eclipse Collections Categorically”, in the upcoming eBook version

Build lasting connections

The moments that matter most in my life are the ones where I have connected and built lasting relationships with people. I revisit these connections in stories I tell to family, friends, sometimes in talks, and now even in books. Stories have connected us as a species since we started telling them via spoken and written language.

Sometimes connections happen in unexpected and surprising ways. The amazing José Paumard wrote the Foreword for my book, “Eclipse Collections Categorically”. The Foreword, Acknowledgements, Introduction, and some of Chapter 1 are available in the online reading sample at the Amazon link. In the Foreword, I was surprised to learn about the day that José discovered that I existed. I remember vividly the day when I had met José in person at JavaOne 2015, but did not know until reading his Foreword, that he had seen me speak a year earlier at JavaOne 2014. Read the Foreword above to learn the connection story of myself and José. Thank you, José!

If you read the story that José has written in the foreword, you will learn something about networking that only happens when you do something. I may not be able to help you find the motivation and courage to do something, but what I can tell you is that amazing stories are much less likely to happen in your life until you start socializing your interests and connecting with others.

In the rest of this blog, I will show through personal examples how building connections can happen by telling stories and going to conferences and meetups and working up the courage to talk to developers and speakers.

Where can you build lasting connections?

Go to user group meetups and conferences. Build up 15 seconds of courage, and introduce yourself to folks who have left a positive impression with you. If you’re like me, that first introduction may be awkward. Some folks may seem intimidating at first, but we’re all just human beings like you doing our best to prioritize our time and build lasting connections while we can. Unfortunately, nobody can prioritize their time for everyone, so sometimes the connection won’t last beyond that first introduction. That is ok.

Pro tip. Once a connection is established, make sure you revisit it now and again. Say “hello” and share an update in social platforms where you are connected. Your connections will not always maintain themselves.

Make your next connection at a conference

I’ve known of Venkat Subramaniam since 2010, when I first spoke at GIDS (Great International Developer Summit) in Bengaluru. I was too shy to introduce myself then. I actually met Venkat in person at the JVM Language Summit in 2011 and had a longer conversation with him. A year later, at GIDS in 2012, I had the amazing fortune of having Venkat attend my talk titled “Java Collections Reloaded”. I know Venkat attended my talk because he asked me two questions at the end of my talk, which at the time earned him two, one-of-a-kind USB thumb drives with Goldman Sachs design that I offered to folks who asked questions. I can’t remember the questions Venkat asked, but I do recall that Venkat told me and the audience that I did not stipulate that they had to be good questions. Well done and thank you, Venkat!

USB Thumb Drive from GIDS 2012 with GS Collections 1.0 library on it

The connection at GIDS 2012 will be a lasting memory for me. In addition to the USB drive I still have (pictured above), I have a picture of poster that connects myself, GIDS, Venkat and my first GS Collections talk together all at once. It would seem unbelievable if I hadn’t taken a picture at the time.

Pictures of Venkat Subramaniam and me on a large session poster at GIDS 2012

This connection and picture would never have happened if I didn’t submit a talk, get it accepted, and then attend GIDS in 2012. I had to do something, and I did not know what would happen at the conference. I had hoped I would raise awareness of GS Collections. Everything beyond that was a bonus.

There are tens of Java conferences held every year, so go!

There are hundreds, maybe thousands of connections I have made at user group meetups and conferences since I gave the talk named in the picture above at GIDS in 2012. As descrived in the Foreword above, I would meet José Paumard for the first time at JavaOne 2015. If you read the Foreword, you will learn about how we first became connected, and met a year later. I did not know I had made a connection with José the year before at the JavaOne 2014 Strategy Keynote. When you put yourself out there publicly in talks, keynotes, blogs, podcasts, you quietly make connections you may never learn about. Below is a picture of the talk details outside of the room where I would first meet José after his talk. He has probably never seen this picture before (at least from me). Thank you and you’re welcome, José!

José’s talk at JavaOne 2015

In a few months, I will be at the dev2Next conference with Vladimir Zakharov presenting “Refactoring to Eclipse Collections: Making Your Java Streams Leaner, Meaner, and Cleaner.” Do you know the only thing that might be missing? Of course it’s you.

The dev2Next conference is a great U.S. conference held in Colorado Springs. There is a great set of speakers, and if meeting Venkat Subramaniam is on your professional network bucket list, then this is a great conference to go to. He organizes the conference so will be there the entire week.

Don’t stifle your connection opportunities watching replay videos.

It saddens me when folks skip out of meetups saying that they will watch the recorded video again. The recording of any talk is not nearly as interesting as the potential for the talk to answer a specific question you might have, or an insight you might share in a conversation with the speaker or other developers. I just attended InfoQ Dev Summit in Boston this week. I went to see my friend Vlad give a talk on Data Frames in Java. I knew a few of the speakers at the conference, so figured it would be a good way to freshen up some of my connections that I mostly see at conferences. This was an opportunity for a few “hellos” and to meet a couple of folks I know through social media in person for the first time. I also enjoy seeing Vlad give talks, and have enjoyed delivering a few slides from Vlad’s talk at both dev2Next 2024 and JavaOne 2025. It’s rare you get to see a talk these days with a donut diagram about donuts. “Donuts… Is there anything they can’t do?” -Homer Simpson

Vlad showing an example and explaining the differences between an OO and a DO Donut Shop

Overcoming the fear of greetings

I find initial greetings awkward. You never know what is going to happen after that first awkward hello. Practice helps. I am challenged with remembering names the first time I meet someone. It usually takes hearing and saying the person’s name and connecting with them in person few times. So if I really want to make a point to remember someone’s name, I may have to say hello to that person with their name a few times so it sticks. I like to believe I’m not the only person on this planet who faces this challenge. It may make me feel or look like an idiot sometimes, but I just get over it and get on with it. Nobody cares as long as you are trying.

I’ve had many people over the years introduce themselves to me at conferences. They will sometimes know me through social media posts, blogs, previous talks, or through friends of theirs who tell them about me. I usually get minimal written feedback online when I write a blog or post social media, so find it surprising when someone knows me through an online platform. That first in person greeting usually leads to follow up connections happening in online platforms. It is more awkward sometimes to connect with someone online before meeting them in person. Pro tip: I ignore most connection requests on LinkedIn if I have not met the person virtually or in person, unless we have a large number of shared connections, then I will see what the person posts about. You are more likely to increase your online connections if you make in person connections first. I made a connection I hadn’t expected with a person I met for the first time at InfoQ Dev Summit this week. He took the initiative to take a selfie with me, and then share it on LinkedIn and tagged me so I would see it. This is a great example of creating that initial connection and following through. Thank you, Jagadeesh!

I had a great time attending the InfoQ conference at Boston. | Jagadeesh Lakkasani

Do something, connect, say something

I saw a fellow Java Champion at a talk we both attended at InfoQ Dev Summit this week. I walked up to introduce myself and say hello after the talk. We hadn’t met in person before but we have been connected through social media for a while. We both recognized that it was our first time meeting in person, and she took out her camera, took a selfie and posted it along with other selfies and pictures she shared in a conference update. This simple practice is so important in building and maintaining connections in your professional network. Thank you, Loiane!

Thank you InfoQ for the opportunity to have presented a talk on "Orchestrating AI Services with the Spring AI Framework" yesterday at the InfoQ DevSummit in Boston! | Loiane G.

This is something I have learned from other Java Champions and conference speakers over the years. You can increase your impact and connections well beyond your talk if you take the time to post about your conference experience immediately after (or during) the conference.

I know a lot of conference speakers and attendees that do this, and an even greater number of people who do not. I get it. Posting on social media is not for everyone. I am terrified each time I post that I am going to say something dumb or annoying. I just close my eyes and do it, and then ask for feedback after. At first, I would ask for feedback before, but that can be challenging and awkward as well.

All I can tell you is that connections become persistent if you make an effort and share. You may leave a memory that can jog others memories, including your own. This can be helpful later in so many ways.

Your mission, if you choose to accept it

One of the biggest mistakes I continually see developers make is not attending free local meetups in person. I don’t understand this at all. Developers are not saving time by believing they can watch the video later. Sure, they can watch the talk on fast forward on YouTube, or not watch it at all. Watching a recorded video is less likely to impact someone’s career in any meaningful way than making an in person connection will.

Make the connections!

I gave a talk at a virtual Pittsburgh Java User Group meetup recently. Only one person that I didn’t know attended. We had a great conversation after the talk which was also part of the recording at the end. I’ve since had direct conversations on social media with the developer who attended the talk. Another connection established ✅. So if you think attending talks is a waste of time because not a lot of folks attend, you are missing something very important.

I also occasionally attend the Garden State Java User Group and New York Java SIG meetups. Who knows, if you attend a meetup at either of these, you may actually spot me in the audience, or maybe in a Java Champion panel or something. Don’t be shy if you see me there. Say hello!

Finally, a recommendation

If you are looking for a good developer conference recommendation in the U.S. where you can make some new connections and maybe refresh some old ones, I highly recommend attending dev2Next, which is run by Venkat Subramaniam. Disclaimer: I am speaking there again this year. I am speaking at the conference a second time, because I had such a great experience the first time! Colorado is beautiful. The weather was very pleasant last year. You do have to be mindful of the elevation and dry air, so stay hydrated and be mindful of how you are feeling. Last year, I met up with some of my favorite speakers including the amazing Venkat.

Mala Gupta and José Paumard pausing for a selfie in the Hallway Track of dev2Next 2024 with me

Top Golf outing at dev2Next 2024 and Sharat Chander congratulating Venkat for the first ever dev2Next

Thank you for reading, and I hope you find some time in your busy schedule to attend meetups and conferences to increase your connections.

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 also the author of the book, Eclipse Collections Categorically: Level up your programming game.

https://code.visualstudio.com/docs/copilot/chat/mcp-servers 

We are delighted to announce the tenth Eclipse Theia community release, “2025-05,” incorporating the latest advances from Theia releases 1.59, 1.60, and 1.61. Special Note for Adopters: This community …

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

We just merged an exciting new feature into Theia: the ability to install MCP servers via VS Code extensions. This drastically improves the developer experience by eliminating the need to manually …

The post Installing MCP Servers via VS Code Extensions appeared first on EclipseSource.

CDO 4.31 is now available, as usual, together with the Eclipse Simultaneous Release 2025-06.

This CDO release contains no new features because most of my time was absorbed by working on the new build system and the new CDO Homepage:

The internet is full of “vibe coders” - developers who build games and websites from scratch in minutes using AI. These viral demos are exciting, but they don’t reflect the reality of enterprise …

The post Why AI Coding Still Fails in Enterprise Teams - and How to Fix It appeared first on EclipseSource.

To make it easier for our community to maintain an active contributor status, we’re introducing a new notification service for the Eclipse Contributor Agreement (ECA).

Starting June 11, 2025, we will begin sending email reminders before a standalone ECA is set to expire. For those who need to take action, the email will have a subject line of “Action Required: Your Eclipse Contributor Agreement (ECA) is Expiring Soon” and will contain a link to renew the agreement.

If you are an Eclipse committer who has signed an Individual Committer Agreement (ICA), or an employee of a member organization that has signed the Member Company Committer Agreement (MCCA), you do not need to renew the standalone ECA, as both agreements already include it. If you are covered by one of these agreements, an expiring standalone ECA will not affect your ability to contribute. In this case, you will receive a separate informational email with the subject: “No Action Required: Your Eclipse Contributor Agreement (ECA) is Expiring Soon” to confirm your status.

For those covered only by a standalone ECA, if it expires, you won’t be allowed to contribute to open source projects at Eclipse until you sign it again. Specifically:

• You will no longer be able to submit a merge request to an Eclipse project repositories hosted on Eclipse Foundation GitLab.
• Your commits included in a GitHub Pull Request will fail our automated ECA validation check.

If this happens, you can always restore your ability to contribute by visiting https://accounts.eclipse.org/user/eca and signing the ECA. Your contributor status will be restored once the new agreement is processed, which may take 5 to 15 minutes for our system caches to update.

For any questions or feedback, please join the discussion on our HelpDesk issue.

The Model Context Protocol (MCP) is a new protocol for integrating AI/LLMs with existing software services.  MCP Server Tools allow LLMs get additional context-relevant data, write/change remote data, and to take actions.

Most current MCP servers declare their tools statically.  When the MCP server starts up it's available tools and any tool meta-data (such as text descriptions of the tool behavior provided in decorators or annotations) are made available to MCP clients that connect to an MCP server.  The MCP client (LLM) can then call an available tool at the appropriate time, providing tool-specific input data, and the tool can take actions, get additional data, and provide those data to the client.

OSGi Remote Services/Remote Service Admin provides a open, standardized, multi-protocol, modular,  extensible way to discover, dynamically export and import, and secure inter-process communication between services.  Combining Remote Services with MCP Tool meta-data allows the creation of dynamic remote tools.

Remote Tools for MCP Servers

This README.md shows an example 'Arithmetic' service, with 'add' and 'multiply' tools defined and described via Java annotations to an ArithmeticTools service. The python MCP Server communicates with the Java Server (startup and after) to dynamically add to/update from its set of tools that it exposes to MCP Clients.

Here is a simple diagram showing the communication between and MCP client, the Python MCP Server, and a Java Arithmetic Service Server.

MCP Client (LLM)  <- MCP -> Python MCP Server <- Arithmetic Service -> Java Server

The ArithmeticTools service is a simple example, but exposes a powerful and general capability,  Arbitrary remote tool services may be declared and provided with the appropriate tool description meta-data, and then made dynamically available to any MCP servers created in Python, Java, or other languages.  Both the MCP and RS/RSA are transport agnostic, allowing the service developer and service provider to use the remote-tool-appropriate-and-secure communication protocol.  

Ever wondered how to build your own GitHub Copilot—customized for your domain and embedded into your specialized tool or IDE? We just published a new video tutorial on YouTube that shows exactly how …

The post Custom GitHub Copilot with Theia AI – New Video Tutorial appeared first on EclipseSource.

What I lack in artistic talent, I also lack in desire for a free ride.

A picture I drew on a late 1980s Mac that was included in my high school art and literary magazine

I was the Production Editor on my high school art and literary magazine in my senior year. There were many talented artists and writers in my high school. I was proud to work with all the editors and contributors on making an amazing 25th anniversary edition of the magazine. The end result was a beautiful collection of seventy-two pages of paired art and writing.

I am a writer. I discovered this in my sophomore year of high school when I wrote my first poem. I’m not a writer because I’m good at it, I’m a writer because I love writing. I love words. Sometimes I put words in an order that is pleasing to me and others. I love reading words that are put together with care. I love words that convey thought, feeling, and meaning. I submitted many poems for consideration, and several were accepted and included in the issue of the magazine in my senior year. I have shared some of my high school poetry the past few years in separate blogs here.

I am not an artist, at least not the kind that can draw anything many would consider art. I doodle, but usually just basic shapes like triangles and squares. I love symmetry. I love doodling on graph paper, because it helps me create block shapes quickly. I may have developed this particular habit after several years of hand drawing dungeon layouts for D&D (Dungeons & Dragons) games, where I would always wind up as the DM (Dungeon Master), because no one else had read the DM Guide and knew all the rules.

My senior year of high school, I used a Mac SE/30 to help prepare and layout pages in the magazine and for all the typesetting. I had spent the summer of my junior year in high school working at a desktop publishing firm, which is where I learned Pagemaker and other desktop publishing software.

I decided one day to doodle with drawing shapes on the Mac to see what I could come up with. The picture at the top of this blog was the result. I submitted it for consideration in the magazine. I think the novelty of computer art and its production cost being out of reach of most high school students in the late 1980s is what led to the inclusion of this picture in the magazine.

The “computer art” is pixelated, but there is something simple and relatable about the picture. When I stare at it, this is what I see now. Daredevil danger diving into pool. Square peg, round hole. “Move to Trash.” Ladder conveying the Sisyphean nature of this cuboids existence. Anyone with an office cubicle can probably relate. Cold obsidian pyramid structure. An arduous return commute. At the top, it looks like an “h”. I saw that for the first time today. Maybe three decades ago I subconsciously thought the cuboid needed h-elp to break this cycle. I can’t unsee the “h” now. Yeah, no, that’s just my mind playing tricks. Nothing was that deep or intentional in the thought process. I think I just decided on this shape to give the picture depth. But this is what art is supposed to do, make us feel and think, right?

I could probably have drawn this by hand back then. It would have taken me a hundred tries, and I would have just given up before getting to something I would be happy with. That’s the tricky part with art on a canvas or paper. There is no undo, or just move this bit here or there. The computer let us explore and share our ideas more easily. It did its job aiding me in the drawing and the experimenting. The ideas were limited by my imagination and patience. I created this much faster than I could have without being aided by a computer.

I thought about this picture today as I expressed on social media some recent feelings I have had about the flood of AI generated art that has been all over my feeds.

I throw up a little bit in my mouth when I see AI generated pictures now. I miss the joy of being surprised and mesmerized by the creativity of people with artistic talent. Art isn’t a burger. It’s much too special to be dispensed at a fast-art drive-thru.

I don’t want to use Generative AI to generate any pictures that I use in my own products and posts. I’m not an artist. I would not be proud to use an AI generated picture to represent something I could not create myself. My AI generated art would look like everyone else’s AI generated art, created by regurgitating the work of someone else who I will never meet, and will never get the credit nor compensation. The novelty is gone, and the awful feeling I would get benefiting from someone else’s work and style is too icky to contemplate.

I’m a writer. I find joy in writing, and getting feedback from people who read my work. I do not enjoy reading words generated by a machine. I want to read the unvarnished essence of truth written in the words of the person sharing the writing with me. Even if it is not that great. It’s easy to provide feedback and improve things. This creates an opportunity for humans to connect and collaborate. This is still a good thing, right?

I’d like to live in a world where artists produce art, and writers produce writing, because it is something they love and practice for years to improve their skills. I’m happy for the computer to be an aid to the creation of art, like a paintbrush, a canvas, a pencil, a typewriter, an eraser, or even a helpful mentor. I want to be able to see and experience the creative thoughts and feelings of the person behind the computer. I don’t want to ad nauseam see everyone flex their prompt muscles and show they are capable of being the same artist, that has someone else’s soul in their work. I know I don’t live in that world any more. I hope we don’t discourage future artists and writers from developing their talents, or force them to hide their work. We need them, and not to feed the regurgitation machines. We need them to remember and remind us of our humanity.

Thanks for reading, and I hope my eighties computer aided art brings positive thoughts and feelings to your day!

Note: This blog was written by me. I’m a human, who randomly thinks too much and writes a lot. I shared it with a couple folks for early feedback. I edited a few times, deleted some stuff, and then just decided to publish with imperfections and all. It was good fun, you should try it!

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 also the author of the book, Eclipse Collections Categorically: Level up your programming game.

More code, community, conferences, books, stickers, t-shirts, and coffee!

After 30 years, I have enough Java books for three Java sections in my book case

Java keeps on moving!

Thirty years may seem like a long time, unless you’re a programming language like Java. Java feels younger today than it did fifteen years ago! I’ve been learning Java since 1997. I’m still learning new stuff in Java, and it keeps moving with youthful exuberance and evolving with new features every six months. I went all in with Java twenty-five years ago. I wrote a happy birthday blog for Java’s 25th anniversary, five years ago, and shared my story of using Java. I love when I write stuff down. Then I don’t have to remember or repeat it all. 👇

After two decades of programming in Java, I can honestly say I am just getting started. There are still so many things I would like to accomplish, and the future is looking very bright for this relatively young programming language.

Happy 25th Birthday Java

The picture in the blog included an inception-style collection of photos from Oracle CodeOne 2018 to JavaOne 2014 and included four JavaOnes and two JavaDays. Planning is everything.

Classic and newer Java books spanning 30 years

This is the list of books in the picture of my bookshelf up above. I have linked to each book in Amazon below, trying to find the latest edition if available.

• The Java Language Specification
• Concurrent Programming in Java
• Java Concurrency in Practice
• Effective Java
• The Well-Grounded Java Developer
• 97 Things Every Java Programmer Should Know
• Java in a Nutshell
• Java 9 Modularity
• Java 8 Lambdas
• Java SE 8 for the Really Impatient
• Getting to Know IntelliJ IDEA
• Eclipse Collections Categorically
• Rasperry PI with Java
• Head First Java

Full disclosure: I am the author of Eclipse Collections Categorically, and a contributing author to 97 Things Every Java Programmer Should Know.

Thriving, not just surviving

Thank you to all the folks who work on OpenJDK, and the core platform, product, and DevRel teams at Oracle for keeping the lights on, the fires of progress stoked and burning, and the coffee nice and hot!

Thank you to the millions of users, tens of thousands of contributors, and thousands of maintainers of Java open source projects and communities out there. You are the key to so much innovation that millions of Java developers benefit from, and help the Java language continue to evolve.

Thank you to the millions of Java developers quietly just getting stuff done with Java, year over year, and decade after decade in large, medium, small, and single person teams out there. I’ve been there, it’s quiet, and I know you’re out there. It’s nice to know we have a stable programming language that continues to stay relevant and keep our skills current and desirable.

JavaOne 2025

I didn’t post a blog about JavaOne 2025. It was a great conference. Here are some of my pictures from J1. Less text, more pixels. There are YouTube video links where available in the captions.

JavaOne 2025 Entrance (Java 24 Launch at JavaOne 2025)

Java Tip and Tail release talk with Alex Buckley (YouTube)

Duke showing Java is still competitive at 30 years young

Duke copping a squat after championship level foosball

Brian Goetz showing us the long road ahead (YouTube)

You get a project, and you get a project, and you get a project!

Quality Outreach stories with David Delabassée, Stuart Marks in the Community Keynote (YouTube)

Stuart Marks summarizing his talk on Sequenced Collections (YouTube)

Learn you a Data Frame for Java for great good, with Vlad Zakharov!

A fireside chat at JavaOne 2025 with the Java Architects

Looking forward to the next 30 years!

It’s been a crazy fun 30 years watching Java evolve and solve problems. I am thankful I became actively involved in the Java Community Process Executive Committee, Java User Groups, Java Specification Requests, OpenJDK Quality Outreach Program, and several open source Java projects. I’ve also presented at every JavaOne since 2014, and have now been involved in two JavaOne keynotes (2014 and 2025). It was a great honor to be selected as a Java Champion in 2018.

My advice if you’re on the fence about what to do in your career. Get involved. Become part of the amazing Java community.

I know Java and the Java Community will continue to be a part of my future. Thank you for reading, and Happy 30th Birthday, Java!

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 also the author of the book, Eclipse Collections Categorically: Level up your programming game.

Exciting news for developers and tool builders: Theia AI and the AI-powered Theia IDE now support the new Claude 4 Sonnet and Claude 4 Opus models right out of the box. These revolutionary models, …

The post Theia AI and Theia IDE support Claude 4 Sonnet and Opus appeared first on EclipseSource.

Growing an open source community through communication.

Photo by Pavan Trikutam on Unsplash

The sound of one hand clapping

Back in the day, when phones looked like those pictured above, there was no mute button. If you wanted to try and keep the person on the other side of the call from hearing you, you would cup your hand over the bottom part of the handset. Times change. Mute is now a prominent, and often unintentionally engaged feature in many conversations.

I gave a talk at the Open Source Strategy Forum run by FinOS Foundation in 2017 with the title “They can’t hear you on mute.” This quote is now in the Desktop Don Reference under the Communication category. The point of the talk was that sharing code on GitHub or other social coding platforms is usually a very small part of being successful in open source. You have to regularly communicate on multiple channels if you want your work to be discovered and build a community around it.

There is no mute button with successful open source projects

For developers who want to build a sustainable community around their project, there is a lot more work to be done after the code is open sourced. It’s usually not effective to only have one-on-one communication with folks about your project. That is unless the folks you are communicating with believe in your project, and are connected enough to share information about your project in forums that can help it become discovered. While it’s not impossible for this to happen, for most of us working in open source, we have to explore and leverage multiple channels to help more developers discover and engage with our projects.

The key thing to measure when working in open source over a long period of time is how much you continue to learn. If you are not learning anything, even if your project is successful, you are stagnating. After twenty-one years of working on an open source Java collections framework, I am still continuing to learn. The learning mostly comes from communicating with others, across multiple channels.

In the rest of this blog, I will share some of the things I have learned over the past decade working in open source. If you want to help others discover your work exists and convince them it is worth taking their time to investigate further, you need to start from the ground floor and build credibility in your work and yourself.

Building credibility

I spent eight years communicating to many developers and teams inside of Goldman Sachs before open sourcing GS Collections. I had successfully established that there was a potential market for a feature-rich Java collections framework. Once the project was open source, I initially only had one communication vehicle to help developers discover the project … the GitHub README.

Start with your project README.

Write the most helpful README you can about your project. This is the first window to your project that many will see. You want them to look at other things in the repo, and fork and star your project. There are projects out there that can help you write an effective README. I’m not going to claim any authoritative expertise in the README writing space. We continue to evolve our README with feedback from the community.

Build a website for your project.

Both your README and website will establish that you care about your project and show that the work is professional. Take contributions to your README and website over time. Some of the best contributions the Eclipse Collections project has received over the years are language translations of the website. There are now twelve language versions of the Eclipse Collections website. It helps to keep your website simple, so a translation takes less time to write and review. Be sure to thank those that make contributions publicly. This increases the incentives for others to want to get involved.

Talk about your project at user groups

I started communicating publicly about GS Collections and then Eclipse Collections by talking at Java User Group meetups. This helped me build credibility in smaller local Java communities. By the time GS Collections was migrated to the Eclipse Foundation and became Eclipse Collections, there were already around 1,500 stars on GitHub and 20K downloads from Maven Central.

Then both stats were reset to zero, and Eclipse Collections had to start from scratch. It took a lot of passion, patience, and persistence to recover from this branding reset.

Building a recognizable brand

There’s a lesson in here about the downsides of building credibility and then rebranding. GS Collections was just beginning to build brand recognition in the Java community. When Eclipse Collections came into existence it became part of another stronger brand with the name Eclipse. It wasn’t obvious at first, but this stronger brand would act as an unintentional mute button for Eclipse Collections over the last ten years. Eclipse is recognized as being a world-class open source IDE. Eclipse Collections would not only have to build its own recognizable brand as a world-class open source Java collections library, but would continually help reinforce the brand of the Eclipse Foundation as distinct from the Eclipse IDE. I have told literally hundreds of developers over the past ten years that Eclipse Collections is distinct from the Eclipse IDE, and is one of hundreds of projects managed at the Eclipse Foundation. I have told developers that I write all of my code contributions to Eclipse Collections using IntelliJ IDEA, and have used IntelliJ since 2002, just to illustrate the independence of the project from the Eclipse IDE. I realize every time I say this that I have been fighting an uphill branding battle. The brand of the Eclipse IDE is incredibly strong. This is deservedly so. The Eclipse IDE is an amazing open source IDE and has a strong and loyal developer community. I continue undaunted in this seemingly Sisyphean task of building brand recognition of Eclipse Collections in the shadow of the Eclipse IDE. I hope the clarification here helps some folks who were not aware of the difference between Eclipse IDE, Eclipse Collections, and Eclipse Foundation. Progress continues.

I am proud for Eclipse Collections to be a part of and contribute to the Eclipse Foundation brand. Eclipse Collections will never be as well recognized as the Eclipse IDE, and that is fine with me. I didn’t create Eclipse Collections to win a popularity contest. I created Eclipse Collections so a sustainable development community could form and grow around the project that I created and believe in. This measure of success has been met by Eclipse Collections being a project at the Eclipse Foundation.

Eclipse Collections has developed a recognizable brand over the past ten years. How do I know that Eclipse Collections has become an independently recognizable brand? I gauge this measure of success on a few metrics.

Gauging your project success

I’ve been watching several metrics around Eclipse Collections for the past decade that it has been at the Eclipse Foundation. I pay attention more to trends with these metrics than absolute numbers. I don’t think it’s helpful to compare your project to other projects, unless they are in direct competition for the same market .

GitHub Stars

The first metric is a vanity metric. This is the number of GitHub stars for the project. Eclipse Collections just passed 2,500 stars on its GitHub repository. All this really tells me is that 2,500 people have a GitHub account and stopped by the Eclipse Collections project to drop a star on the repo. GS Collections by comparison has 1,800 stars. So after starting over again at zero, I am happy at least Eclipse Collections finally passed the level that GS Collections had achieved. This took several years to achieve, so for me this feels like some form of success. Averaging out the total number over the total number of years, and the project has been receiving ~250 stars per year.

Comparing Eclipse Collections and GS Collections trends with Star History

Maven Central Downloads

The second metric is more difficult to attribute than GitHub stars, but I find it more interesting. The second metric is monthly downloads from Maven Central. GitHub stars can be traced to individual GitHub accounts. I can’t trace the monthly downloads to anyone specific, and the downloads can be the result of transitive dependencies, which means the library was downloaded as part of the dependencies for another project. This doesn’t matter in my opinion. If a project uses Eclipse Collections, and folks use that project, then they are most likely using Eclipse Collections without knowing it. I believe production usage is more important than individual developer usage, but both are nice. In the chart below, we can see there were 1.2 million downloads of the eclipse-collections library from Maven Central in April 2025.

Downloads of Eclipse Collections for the past 12 months from Maven Central

Open Source Dependencies

The third metric is the number of open source projects that depend on Eclipse Collections. This metric probably has the greatest effect on the second metric. If a popular project depends on Eclipse Collections, then it stands to reason that Eclipse Collections will see more transitive downloads due to that project’s dependency.

According to GitHub there are 2,752 repositories that depend on Eclipse Collections

GitHub Traffic

The fourth metric I look at is GitHub traffic. With the standard GitHub traffic view, it’s possible to see only the past two weeks of traffic. You can see Git clones and Visitors, as well as referring sites.

GitHub clones and visitors

Growing your community

This is where the mute button has to be turned off. There are a lot of different channels you can explore in helping to grow awareness of your project.

Writing articles

The first article I ever wrote was for InfoQ. I wrote a two part series about GS Collections. I can’t tell how much traffic has visited these articles in the past decade, but when I first wrote them, I could see how much traffic they referred to the GS Collections repository on GitHub.

Articles take a commitment of time and patience. Depending on the platform you are writing for, you will need to be prepared to write a minimum number of words in the article, and go through a formal editing process. The platform has its own brand and audience expectations to uphold.

I would recommend writing a few formal articles, at a few places. I have written articles for InfoQ, DZone, and the JVM Advent Calendar, which runs annually during the month of December.

Presenting at conferences

One of the best ways to get the word out there about your project is to give talks at technical conferences. It usually helps to build credibility around your project before presenting at conferences. This is why I suggested starting at user group meetups first. Once you have come up with a talk idea and content, it will help you potentially get your first conference talk proposal accepted. It is sometimes required to share a video of you speaking as well. If you were recorded talking at a user group meetup, this can help check off that requirement.

One of my favorite blogs about speaking at technical conferences was written by Holly Cummins. The blog is linked here:

So, you want to speak at conferences - Holly Cummins

Writing Blogs

Blogging is not for everyone. However, it is an effective medium to help get your story out there and grow a community around your open source project. After about 1,000 one on one conversations where you have to repeat the same story about your project, it will become clear that it is impossible to scale your story without some help. If you are reading this right now, you already understand the potential reach of blogging.

My recommendation is to start writing for yourself. Write down your important thoughts that you want shared about your project. Nobody else may read them at first, but you can share them to shorten the repetitive cycle of communication. As you develop your voice and see the reading metrics around your various blogs, you will learn what your audience is interested in reading. I don’t know the secret sauce for writing a hugely successful blog, other than just writing and doing it consistently. You know the things you like to read, and that keep you engaged. Write things that you would be interested in reading.

Blogging here has been one of the best decisions I have made in my professional life. I am sad that I started blogging so late in my career. If I had known the impact it would have, I would have started in my twenties. I started blogging well into my forties. There are twenty years of stories I am still having to catch folks up on, and I’ve forgotten so much already. I wish I had blogged about Clipper and Smalltalk when I was programming professionally in them. I also wish I knew about open source and got involved when I was working with them. My suggestion… save wishes for birthdays, and start writing blogs instead.

Don’t ask me for a blogging platform recommendation.I blog here, but will not recommend it as better or worse than any other platform, as I have never used any other blogging platform. Do your own research, and there are loads of opinions folks have shared. I have settled with this platform as being adequate for my needs. I have overcome some problems in the platform over the years, like how to represent tables other than using images. I use Asciidoc in GitHub gists for tables. It’s possible eventually there is a solution added to the platform. At some point Medium added support for syntax highlighting code examples. At that point, I stopped using GitHub gists for code examples and inlined them directly.

If you do decide to blog, and want to know how your blog is doing, check your blogging platform for the kind of stats it shares about your blog. I will share a picture of the Story Stats for my latest blog here on Medium, which I published five days ago. It shows the number of views and reads over time.

Story Stats for my latest blog

RSS Feeds, Email Subscribers and Blog Aggregators

Having your blog available to RSS readers and email subscribers is very useful. Make sure the blogging platform you choose supports both of these options. Different folks like finding out about things in different ways. Of the 2,300+ folks who follow me here, 55 have signed up for email subscriptions. A small percentage overall, but it is not zero. Pay attention to your audience. If they are telling you something, like clicking on a subscribe button, then listen.

My blogs are also aggregated by Planet Eclipse. There are surely a lot of other better options in this space. I signed my blog up there quite a while ago since I am an active blogger about an open source library maintained at the Eclipse Foundation.

Social Media

We used to have this amazing platform called Twitter. It was a great place for having conversations and helping build communities around open source projects . You could really get a sense of being connected with the technical community. Today we have a collection of social media options that are less engaging. To be honest, I now find LinkedIn is the most effective platform for communicating about my own projects. This is probably because I have used LinkedIn to build a professional network, and many folks who I have worked with over the years are connected with me and are active there.

I find the topic of social media a bit sad these days. The level of engagement feels like it is way down from the levels it used to be at. I use BlueSky, Mastodon, LinkedIn as the primary social media channels for sharing links to blogs, talks, project updates, etc. As I said, LinkedIn is now the most effective of these platforms that I personally use for sharing information and raising awareness. YMMV.

The platforms that often generate a burst of interest in a blog post are Reddit and Hackernews. I don’t have an account on or post to either of these platforms, but occasionally someone else will share a blog of mine there. If I see a sudden spike in traffic with thousands of views, I can tell someone has shared a blog on one of, or sometimes both of these platforms. If you use these platforms and you’re comfortable with posting on them, then maybe you have some additional options to get your ideas and project out there.

Writing Books

If your project reaches a level of success, it might be a good time to think about making an investment in writing a book. This is what I did after 20 years of working on the Eclipse Collections project. I wish I could have written the book a decade ago when lambdas first became available in Java, but I wasn’t in a position to do that at the time, as my personal life was in crisis mode. I wrote almost 200 blogs before deciding to finally take the time off to write a book. I recommend writing a book because you love your project or a specific topic, not because you hope to have a New York Times Best Seller. You most likely will not. It’s unlikely to even see a return that remotely matches your investment. I wrote a book about Eclipse Collections because I had invested 20 years of my life working on a project that I believe in and am proud of. I can point developers to 240 blogs or a Reference Guide, but I thought the project deserved a detailed story from its creator about why it has existed and evolved for 20 years.

Below is a link to my book. It is more than a story about Eclipse Collections. It is a story about one developer’s journey and his mission to share the joy of programming with other developers.

Book: Eclipse Collections Categorically

Podcasts

Up until a year ago, I steered clear of podcasts. In retrospect, this may have been a mistake. There are some great podcasts out there. I have participated in three podcasts so far. With the exception of Duke’s Corner, I knew both of the hosts of the podcasts I participated in. Some people fear writing. I have a fear of speaking publicly. I have battled this fear by doing a lot of public speaking. I always have the fear, but realize that the fear is a challenge to my own success. If I don’t use my voice, and keep the mute button on, no one else will speak for me.

I was fortunate to be asked to join three podcasts in the past year. This likely happened because I have networked and built relationships over the past fifteen years. I have kept my network active and alive by sharing information directly with people on a regular basis.

Here are links to the three podcasts I have done in the past year. I wrote blogs about the first two experiences.

• How I Survived My First Ever Podcast
• Surviving my second podcast

While writing this blog, I realized I failed to write a blog about my third podcast. I also didn’t write an experience report about my JavaOne trip in March. This is what happens. We get busy and we forget. I was busy working on the publishing of my book and doing things in preparation for JavaOne. On the last day of JavaOne, I participated in the Community Keynote, participated in an interview livestream with Billy Korando immediately afterward, gave a talk on Data Frames with my friend Vladimir Zakharov, and then participated in my third podcast with Josh Long. It was a lot for one day. The third podcast is available on YouTube.

Networking

Do not go it alone. Open source is community, not just code.

Networking is so important. So many of the things I wound up getting involved with around Eclipse Collections happened because I was learning from others. There are so many talented folks out there doing amazing things and they are happy to share what they know. Thankfully, they understand the importance of taking themselves off of mute.

Networking doesn’t have to be just in public spaces. I networked with thousands of developers inside of Goldman Sachs by doing internal talks, writing internal blogs, answering questions on internal Q&A sites, and teaching many Eclipse Collections Katas over the year in both four and eight hour classes. I was challenged and learned from so many folks I worked with as well.

Your network can help you amplify your message, but only if you build meaningful long term relationships. It takes being authentic, taking time and care to build your network. Your network is not a marketing tool. Your network can help you validate if you’re having a meaningful impact in the work you are doing. If you’re fortunate, members of your network may become involved as contributors in your projects and write blogs, give talks, post/comment/like on social media.

I’ll be giving a talk at dev2next at the end of September with my friend Vlad with the title “Refactoring to Eclipse Collections: Making Your Java Streams Leaner, Meaner, and Cleaner”. I gave a talk about Data Frames at JavaOne 2025 and dev2next 2024 with him. Vlad is giving a talk about Data Frames next month at InfoQ Dev Summit Boston. I will be attending the conference and watching from the audience. I’ve known and worked with Vlad for 30 years. He’s fricken’ awesome! You should attend his talk if you’re in Boston at InfoQ Dev Summit next month! I hope to see you there in the audience. If you bring a copy of my book and find me after Vlad’s talk, I will be happy to autograph it for you in the hallway track of the conference, where some of the best networking happens.

That’s just one example of what networking and long term relationship building can do for you. There is so much more value in networking than any other thing you will ever do in your career. Take care and invest in your network.

Some final thoughts…

I hope you found something in here helpful. When we first open sourced GS Collections in 2012, the marketing and community building strategy was TBD. We had a GitHub README, and a desire to learn and grow. The project got a recognition boost the first year GS Collections was open sourced, when I presented at the GIDS conference in India and at the JVM Language Summit in California. I was a member of the JSR 335 Expert Group (Lambdas/Streams) at the time and was fairly certain lambdas would eventually make it into Java. In 2014, I would give my first talk at JavaOne on GS Collections, as well as participate in the Strategy Keynote about the potential use of Java lambdas in our code bases. I think this was the largest audience to ever hear about GS Collections, with several thousand folks in the room.

I did not have a guide to help me on the marketing and community building front with Eclipse Collections. I asked a lot of questions and tried out different things to see what worked. I shared some of the things that have helped out Eclipse Collections over the past decade. There’s no guarantee you’ll see the same results. When you try things, remember the following quote, which I learned from a senior leader at a bank I worked at.

Measure, execute, repeat.

Try different communication channels. See what works for your projects. After you do something, measure the results. If they are good, rinse and repeat.

Blogging has been the best long term investment in my opinion. Networking has helped the most in validating my efforts, helping get my stories out there, and growing the community.

I wish you success in all of your open source endeavors. Best of luck out there!

Thank you for reading!

I am the creator of and committer for the Eclipse Collections OSS project, which is managed at the Eclipse Foundation. Eclipse Collections is open for contributions. I am also the author of the book, Eclipse Collections Categorically: Level up your programming game.

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

The post Eclipse Theia 1.61 Release: News & Noteworthy appeared first on EclipseSource.

Learning how to talk with other developers, through time, with code

Photo by Helena Lopes on Unsplash

Occasionally, I read something that instantly becomes a permanent and prominent memory. This was the case when I read a section of Chapter One in “Smalltalk Best Practice Patterns” (SBPP) by Kent Beck titled “Talking Programs.” I first read SBPP in the late 1990s, while I was a Smalltalk programmer. I have recommended this book to developers who work in any programming language for over twenty-five years.

I like reading books that make me think. I really like books that show and explain to me things that have been staring me in the face, without me even noticing them. You can look at SBPP as a way to learn how to become a better Smalltalk developer, or you can look at it as a book that can help you recognize and identify patterns, to help you become a better developer in any programming language.

Talking Programs and Good Software

In the section of SBPP, Chapter One, titled “Talking Programs”, Kent wrote the following question, which surprised me.

Did you know that your program talks to you? I don’t mean those “Buy more Jolt Cola messages. I mean important stuff about how your system ought to be structured.

-From “Talking Programs” in Smalltalk Best Practice Patterns, Kent Beck

The first time I read this, I thought “So that’s that voice I’ve been hearing!” Many of us are aware of the only metric in software that matters — WTFs per minute. That’s your program talking to you!

The conversational style Kent starts this section off with has become something I expect and enjoy reading in many of his books. I don’t know if this brief passage will make you feel differently about code. It’s had a lasting impact on me since the first time I read it.

I can tell right away if a developer is crafting a conversation in code for the next developer, or if they are just typing quickly to get stuff done. Many developers are more concerned with the transactional now (make it work), and less concerned with the conversational later (make it right).

In the section of Chapter One titled “Good Software”, Kent writes a profound statement which cuts to the chase.

If there’s a radical thought here, that’s it; that when you program, you have to think about how someone will read your code, not just how a computer will interpret it.

-From “Good Software” in Smalltalk Best Practice Patterns, Kent Beck

Before I read SBPP in the late 1990s, I thought I was writing code for the computer, not other developers. Writing code that works is one thing, and a lot of people can do that. Writing code that reads and communicates intent clearly is another. Your code is a persistent conversation you are having with all the developers who were there before you and come along after you, including yourself. While coding you should think how best to change the conversation to suit the current needs of the users of the system, while communicating the intent clearly to future developers of the system. Code is a communal conversation which evolves and will be read over months, years, or possibly even decades.

Code like you are telling a story

I’ve told developers who I’ve worked with that over the years that when we work on a project together, we should think of our system as a story we are writing together. If we learn from each other, communicate regularly, and establish and continuously refine code writing practices and style (e.g. good tests, formatting, naming, method size, symmetry, regular refactoring, etc.), then we might be able to write a story that looks like it was written by one consistent person, instead of by 5, 10, 20 different authors with different styles. Whether a team’s coding story becomes a non-fiction novel, a science-fiction/fantasy, or a murder mystery depends on how well the team communicates while they are collaborating.

The next time you are working on code, listen closely. The code will tell you when something doesn’t feel quite right. Take time to work on refactoring with your team until everyone is satisfied with the evolution of the story you are writing.

Thank you for reading!

I am the creator of and committer for the Eclipse Collections OSS project, which is managed at the Eclipse Foundation. Eclipse Collections is open for contributions. I am also the author of the book, Eclipse Collections Categorically: Level up your programming game.

Why You Should Not Fine-Tune LLMs in 2025 Fine-tuning large language models (LLMs) is often a go-to strategy for adapting AI to domain-specific use cases. But in 2025, it’s time to rethink that …

The post Why You Should Not Fine-Tune Models in 2025 appeared first on EclipseSource.

Are you using AI coding agents but finding they sometimes struggle with your project’s specific conventions or best practices? Of course, you could wait for the next, more powerful LLM, the next …

The post Enhancing AI Coding Agents with Project-Specific Information appeared first on EclipseSource.

A simple teaching strategy to help developers learn large APIs.

Photo by Buddha Elemental 3D on Unsplash

I wrote a programming book titled Eclipse Collections Categorically: Level up your programming game. There are important lessons in this book for developers who program in any programming language. I hope one or more of these lessons will be a compelling reason for you take a look at the book. The front matter of the book is available in the online reading sample for free if you want to get a taste of what’s inside!

Eclipse Collections Categorically: Level up your programming game

What’s in this book for you?

Buckle up. This is one book you might not want to overlook.

The Eclipse Collections library provides open source collections for Java that follow the “Tell Don’t Ask” principle. You tell the collections directly what it is that you want to be done and they do those things for you. Eclipse Collections has hundreds of efficient solutions to common problems Java developers face every single day. This is in contrast to the standard Java collections which require asking for a Java Stream to do interesting and useful things with the data in a collection.

The Eclipse Collections Categorically book was organized to help developers divide and conquer the hundreds of methods in the library to efficiently match problems to solutions. The book is more than a book about data structures and algorithms. It is a book about categories of algorithms, that are available across data structures. The book defines recognizable categories of problems that Eclipse Collections types can solve. The book includes 200+ examples using specific methods available on Eclipse Collections types in each of the categories, in full color with syntax highlighting.

Here are the categories of things explained in the book that you might need to do with collections:

🧮 Count things (Chapter 3)
🧪 Test things (Chapter 4)
🔍 Find things (Chapter 5)
🚰 Filter things (Chapter 6)
🦋 Transform things (Chapter 7)
🏘️ Group things (Chapter 8)
📊 Aggregate things (Chapter 9)
🔌 Convert collections to different collection types (Chapter 4)
🔄 Iterate over things and do stuff (See Appendix A)

Eclipse Collections Categorically will help you find methods and data structures that can help you solve problems in each of these categories.

The nine categories (counting, testing, finding, filtering, transforming, grouping, aggregating, converting, and iterating), cover all 134 of the non-overloaded methods available in the RichIterable parent type in Eclipse Collections. Click the RichIterable link to see how the methods have been organized on the type in the source code. This categorization works in Javadoc and in IntelliJ IDEA structure view to help you find things. I’ve blogged about this previously.

Grouping Java methods using custom code folding regions with IntelliJ

There is another category in the book that is specific to Set types, covered in Chapter 10.

🔢 Set operations (Chapter 10)

The Set operations covered in the book includes union, intersect, difference, symmetricDifference, and cartesianProduct. The Eclipse Collections library includes additional Set operations. These five methods were good enough to cover in the book, as they cover the most common use cases.

Why should you care about Eclipse Collections?

There are several reasons to care about Eclipse Collections, and all have to do with reducing costs. The first, and probably the most overlooked cost is the “Cost to read code.” The book explains in detail, with 200+ syntax highlighted color code examples this particular cost.

Cost to read code

If you believe that reducing the cost of reading code for developers is important, then you should care about Eclipse Collections. Most of the code examples in the book assess a cost of reading the code with a number of books 📕.

There are examples that solve problems using Eclipse Collections, Java Stream and Collectors in the book. I wrote the examples in the book using Java 21. The book was published in paperback a couple of days before Java 24 was GA, so there are no Gatherer examples to compare with in the book. I may write some Gatherer examples in a future edition of the book. I wrote a blog recently that demonstrated using a couple of methods on Gatherers and their alternative in Eclipse Collections. I did not assess a cost to read the code in these examples, but you can decide which examples have a higher cost to read.

Categorizing the Methods of Set Types in Eclipse Collections

Memory cost

I explain in the preface of the book, why I created Eclipse Collections. One of the reasons included having to solve problems I faced over twenty years ago working in a memory constrained space. Whether you work with large or small Java heaps, if the cost of memory is a concern for you, then you should be aware of the memory saving benefits of Eclipse Collections. Even if you already use Eclipse Collections, Eclipse Collections Categorically can help you discover, learn and leverage more of the amazing methods you may not know exist on the Eclipse Collections types.

Project Valhalla will hopefully one day arrive and help us all. I couldn’t wait for Valhalla to solve the problems I faced in financial services applications, and you don’t have to either. Eclipse Collections has an extensive set of primitive collections and is an alternative available today that works in every version of Java since Java 8. If you are learning for the first time that Eclipse Collections can help you save memory at runtime, then read the following free blog before buying the book.

The missing Java data structures no one ever told you about — Part 3

Performance cost

Performance is where you need to do your own homework. If you are concerned that the Java Collection or Stream code you are writing might be a performance bottleneck, then you should write some application level benchmarks with alternatives like Eclipse Collections and find out for yourself if you can improve any unacceptable performance.

I’ve written a lot of micro-benchmarks with Eclipse Collections that will probably be of no specific help to you. The micro-benchmarks helped me and other developers tune the Eclipse Collections library in specific places. This tuning may or may not help applications you work on noticeably in specific situations. I prefer to see application level benchmarks that show that something we did in Eclipse Collections over the past two decades has a benefit. Here’s one blog that compares Data Frame libraries used to execute the One Billion Row Challenge (#1BRC) written by Vladimir Zakharov. It demonstrates some specific benefits Vlad was able to measure in his open source Java Data Frame library called dataframe-ec. YMMV.

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

Costs and benefits of parallelizing code

There are examples in the book that demonstrate ways to parallelize code. I do not provide any benchmarks in the book to show that performance of any of the use cases improved. I provided some tips on how to determine whether something is worth parallelizing, along with some warnings about taking an undisciplined approach to parallelizing code.

The book has some parallel examples that show you how to do things, but it can’t tell you if you should. Only you can determine that, for your use cases, verified with your own benchmarks.

Here is a free blog with some random micro-benchmarks that hopefully do nothing more than make you curious to try things on your own. Writing parallel code and hoping it will magically go faster can be expensive. As I say in the book, “the dragons are real.”

The unparalleled design of Eclipse Collections

Energy Cost

For years, I wondered what effect the memory and performance savings we factored into Eclipse Collections might have on energy cost. I never measured the cost of energy in micro-benchmarks myself, but I discovered the past few years that there were others that had. The following is the most recent blog I’ve seen that measures energy cost of different collections for specific operations. These benchmarks may be of no real use to you, but might be helpful to think about if “going green” is of interest to you. Again, measure the benefits for your own application code. There is a framework the author mentions in this blog, called JoularJX, that may be worth checking out. Note: I have not yet tried this particular framework, so can’t endorse it directly.

Measuring Java Energy Consumption

Not a Java programmer?

There are a lot of programming languages available to program in besides Java. You might be happy as a clam programming in Rust, Go, Python, Kotlin, Scala, JavaScript, TypeScript, Scala, Groovy, Swift, C#, C++, etc. Maybe you don’t need or care about a third-party collections library for Java. What could be in this book that could help you improve the programming language(s) you work in, or the way you write your own code?

Spoiler alert: message categories.

I didn’t include Smalltalk in this list of programming languages. There is a reason. Smalltalk has a feature built in the language and tooling called message categories, which I refer to as method categories in the book. I don’t believe any of the file based languages listed above have support for this feature (please, correct me if I’m mistaken). Smalltalk has had message categories since before 1980. Please see page 42 of the book Smalltalk-80: The Language, by Adele Goldberg and David Robson, for the answer why.

Even though Smalltalk has message categories, current and former Smalltalkers can still learn some things from this book. I say this as a former Smalltalk developer who learned something very important about message categories that I didn’t appreciate 30 years ago when I learned Smalltalk. We current and former Smalltalkers are lucky to have message categories built into Smalltalk. We can and should focus on using them more effectively, for the humans that have to read and learn our code. I have an appendix in the book dedicated to Smalltalk, with a visual hint showing how message categories in the Collection base type in Pharo Smalltalk might be improved by better balancing the the counts in some categories.

If you don’t program in Smalltalk, and love your programming language, then you might be able to help yourself and your favorite programming language to understand what might be missing that can help organize feature-rich APIs. This can help make your favorite programming language easier for developers to learn in the future. We can make all programming languages better, if we learn from each other.

The book can offer you and the designers of your favorite programming languages an advanced class on information chunking and how it can aid human comprehension.

But wait, there’s more…

Imagine what it would be like if a former Smalltalker spent twenty years of his life working on a comprehensive collections library in Java. Mirror mirror on the wall, who’s the… what the… oh no... darn…

My ten year quest for concise lambda expressions in Java

I was not alone in my journey to make Java more productive. I doubt anyone would have enough time to learn everything that has been done in Eclipse Collections. I’ve worked on the library for twenty-one years, and not even I know everything that is in there. There is over one million lines of code in the library. No one can or would want to read all that code line by line and remember everything.

Eclipse Collections Categorically shows you how to take a million plus lines of code and break it down into symmetric patterns that can help you navigate and discover things.

Eclipse Collections does not have everything, but it has enough things to make it interesting for so many use cases. Eclipse Collections may help you become a more constructive and instructive programmer in other programming languages. We can do so much better to improve our programming languages, environments, libraries, and tools. We settle early very often due to costs. We should learn to expect more, and not just settle for what we’re given. We’ve occasionally got to be willing to roll up our sleeves and get involved. Java didn’t have lambdas. Collaborative folks got to work, and now we have lambdas in Java, since 2014. Java needed better collections. Collaborative folks worked for twenty-one years and are still working on stuff, and we got Eclipse Collections. You can get involved if you want as well. There are plenty of problems to solve.

That’s how stuff works. When people need things, they roll up their sleeves, and they get to work. It’s not rocket science. It’s fun to break through walls no one else has gone through once in a while. First, you need the determination to see something beyond that wall. I saw lambdas in Java clearly in 2004. People I worked with probably thought I was crazy. All they saw were these ugly anonymous inner classes I was willing to write code with. Build an ark, get a lambda flood. :)

Why did I write a book about Eclipse Collections?

I wanted to find a more efficient way to teach developers how to leverage a million plus lines of productivity enhancing, memory efficient, Java collections code. I took a year plus off of work to write a book that does this. Writing the book led to an epiphany of the importance of method categories. It led to me discovering other things as well.

There are more things in the book that may surprise you. The inside of the paperback and hardback versions of the book are in full color. You may learn things completely unrelated to Java, collections, or anything to do with software development. In the following code example, you can learn some stats about generations and United States presidents.

And with that… my ten minutes are up. Thank you for reading! I hope you will check out the book, and get value from it for as long as you write code. Thank you in advance if you buy the book! 🙏

Note: The paperback and hardback versions of Eclipse Collections Categorically are now both available on Amazon. The eBook should be available on Amazon by June 30th. Other platforms and distribution channels will eventually follow.

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 also the author of the book, Eclipse Collections Categorically: Level up your programming game.

You won’t believe this—the entire system prompt of the AI-powered Theia IDE just got exposed. But here’s the twist: we did it on purpose – and from the start. While other proprietary AI coding tools …

The post System Prompt of the AI-Powered Theia IDE Leaked!? appeared first on EclipseSource.

We’re excited to share a new video from EclipseSource! In this session, you’ll learn about the future of (building and using) AI-powered tools and how you can take full control of your development …

The post Theia AI: Discover How to Build AI-Native Tools with Full Control! appeared first on EclipseSource.

Theia AI and the AI-powered Theia IDE support OpenAI’s brand new GPT-4.1 family of models out of the box! This includes support for: gpt-4.1 gpt-4.1-nano gpt-4.1-mini o3 o4-mini These models can be …

The post Theia AI and the AI-powered Theia IDE support GPT-4.1, o3, o4-mini (and friends) out of the box! appeared first on EclipseSource.

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

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

In late March 2025, a security researcher in our community reported a security concern about a publicly accessible API endpoint containing user information on accounts.eclipse.org. After reviewing the issue, we determined this API endpoint was unnecessary and have since disabled it.

We looked through our access logs for the past few months and confirmed that the only requests were from the security researcher and the Eclipse Foundation staff who verified the report.

Background

The incident was introduced by the Drupal core JSON:API module being enabled in production without recommended field access restrictions. This module exposes data such as user entities and fields based on Drupal’s default permissions. While email addresses were not visible, other custom fields were publicly accessible for some users and staff:

• City
• Province/State
• Country
• Matrix ID

We did not intend for this information to be publicly accessible by this module. While we do ask our committers to provide their full postal address, that additional information is not stored in Drupal and was not exposed.

Timeline of Events

• January 19, 2025: Endpoint became accessible after going live with our Drupal 10 migration of accounts.eclipse.org
• March 26, 2025 (08:16 AM EDT): Received initial security report from ethical security researcher in the security@eclipse.org inbox.
• April 3, 2025 (11:08 AM EDT): Security Team confirmed the issue, and notified the WebDev team.
• April 3, 2025 (12:39 PM EDT): Endpoint was disabled.

Resolution and Next Steps

To resolve the issue and prevent similar incidents in the future, we have:

• Disabled Drupal’s JSON:API module from accounts.eclipse.org
• Installed and configured the Field Permissions module to enforce field-level access control.
• Initiated a full audit of all our Drupal-based sites to ensure the JSON:API module is disabled and the Field Permissions module is enabled and properly configured.

We remain committed to continuously strengthening our security practices and protecting user data. We would like to thank security researcher Gaurang Maheta for promptly reporting this issue. If you have any questions or concerns, please contact us at privacy@eclipse.org or security@eclipse.org.

Vibe coding—the concept of letting AI generate entire codebases from natural language prompts—offers a glimpse into what’s possible with today’s large language models. But as we’ve discussed, it often …

The post Delegating Code Tasks to AI: From Challenge to Breakthrough appeared first on EclipseSource.

The rise of AI in software development has sparked discussions, excitement and criticism about vibe coding — the idea that developers let AI generate entire codebases based on natural language and …

The post Dibe Coding: The Developer-First Approach to AI-native Development appeared first on EclipseSource.

JavaOne 2025, celebrating the 30th birthday of the Java programming language, was held at the Oracle Conference Center in Redwood Shores, California. This three-day event consisted of 80 sessions and hand-on labs, and two keynotes. Day Two, scheduled on March 19th, 2025, included presentations from various conference tracks.

Many Eclipse developers (mis)use logging for debug messages. As the result, the Error Log view in Eclipse, which is supposed to show important errors or warnings, is quickly filled up with debug infos, hiding relevant warnings or errors:

But there is advanced tracing capability built in into Eclipse that provides exactly the required functionality (reporting low level, debug related information) and doesn't spam the Error Log view by default.

Here is the "classic" introduction into tracing that explains briefly the idea of debug tracing. Note, that tracing is switched off by default but can be switched on via command line or by a user via General -> Tracing preferences, so tracing functionality is available not only during debug session.

It is pretty straightforward to enable tracing for a plug-in.

Steps:

1. Remove the current code to read any debug options flag from your plug-in (all what you did after reading article above :-))
2. Your plug-in's activator must implement org.eclipse.osgi.service.debug.DebugOptionsListener
3. In the plug-in's activator start(BundleContext context) method register debug options listener with the OSGI framework
4. Create boolean fields to cache the debug flags state
5. Update the flag state in the optionsChanged(DebugOptions options) method of the DebugOptionsListener interface (added in step 2)

Here is a simple code that does that:

To make your options show up in the preferences dialog:

• Contribute to the org.eclipse.ui.trace.traceComponents extension point in the plugin.xml and add your bundle entry there:

• Create a new .options file in the plugin directory with following content:
  
  

  your_bundle_symbolic_name_as_in_the_manifest/debug=false

  your_bundle_symbolic_name_as_in_the_manifest/debug/traceExtraData=false

  
  
• and add it to the build.properties (so it is shipped with the bundle):
  
  bin.includes = .options,\

We are excited to introduce a powerful feature available in the AI-powered Theia IDE and the underlying Theia AI framework: SCANOSS integration. SCANOSS scans AI-generated (and of course any other) …

The post Introducing SCANOSS Integration in Theia: Transparent License Compliance for AI-Generated Code appeared first on EclipseSource.

We are happy to announce the ninth Eclipse Theia community release “2025-02”, version 1.58.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 2025-02 appeared first on EclipseSource.

We are excited to announce the public release of Theia AI, an open framework that empowers tool vendors to seamlessly integrate cutting-edge AI capabilities into their custom tools and IDEs. As part …

The post Introducing Theia AI: The Open Framework for Building AI-native Custom Tools and IDEs appeared first on EclipseSource.

We’re happy to announce the alpha release of the AI-powered Theia IDE, the open source development environment that puts the power of AI in your hands—with full transparency and control. Unlike …

The post Introducing the AI-powered Theia IDE: AI-driven coding with full Control appeared first on EclipseSource.

GitHub has recently introduced GitHub Models, a free service that allows developers to experiment with selected AI models via an API. While this service is not suitable for production use due to rate …

The post Testing the AI-Powered Theia IDE and Theia AI Applications for Free Using GitHub Models appeared first on EclipseSource.

When discussing AI integration in development environments, the conversation often centers around chat interfaces. While chat-based interactions with AI are powerful, they represent just one dimension …

The post Beyond AI Chat Agents with Theia AI appeared first on EclipseSource.

In modern development environments, AI assistants have become indispensable for enhancing developer productivity. However, a persistent challenge has been presenting complex AI-suggested changes to …

The post Theia AI Change Sets: Managing Complex AI Change Suggestions appeared first on EclipseSource.

I am delighted to announce the release of Eclipse CDT 12 and CDT LSP 3, which will be generally available this Wednesday as part of the Eclipse IDE 2025-03 release.

The preferred way to get CDT is to install Eclipse CDT as part of the Eclipse IDE for C/C++ Developers using the installer. Further release information on how to get CDT will be published on Wednesday on the GitHub CDT 12 release page.

The two themes for the CDT 12 release are highlighting the new C/C++ editing experience based on the CDT LSP project by leveraging clangd and improved CMake integration, especially for CDT extenders. But there are many other new and noteworthy items, along with over 200 issues and PRs closed across CDT and CDT LSP repos.

Here is a video highlight of the new C/C++ Editing Experience based on the Language Server Protocol (LSP) using clangd and showing the improved CMake integration.

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

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

Meet Theia Coder, an open, flexible, and transparent AI coding assistant designed to seamlessly integrate into your development workflow. It can generate and apply code and arbitrary file changes …

The post Introducing Theia Coder - the open AI coding agent with full control appeared first on EclipseSource.

Imagine a world where your AI-powered IDE can manage your development workflows, e.g. the entire Git process—branching, committing, viewing diffs, and more—at your command. With the AI-powered Theia …

The post Let AI commit (to) your work - With Theia AI, Git and MCP appeared first on EclipseSource.

In today’s AI-powered tools, giving users the ability to scope their requests with relevant context is essential. Whether it’s a file, a symbol, a hardware component, or any other domain-specific …

The post Enhancing Your Tools with Chat Context in Theia AI appeared first on EclipseSource.

We are pleased to announce that the Eclipse Foundation has been selected by the Sovereign Tech Agency for a new service agreement. Through this collaboration, the Sovereign Tech Fund—a program of the Sovereign Tech Agency—will invest in the development, improvement, and maintenance of open digital base technologies worldwide, driving significant security enhancements across Eclipse Foundation projects.

Why This Matters

Open source software is the backbone of countless industries and technologies. At the Eclipse Foundation, we host a diverse range of critical projects, including:

• Eclipse IDE — Powers approximately 10% of developers worldwide and widely used in embedded systems and hardware development.
• Jakarta EE — Provides enterprise-grade Java APIs for leading application servers, including Payara, WildFly, Apache TomEE, and more.
• Eclipse Jetty — A high-performance web server essential for scalable and secure web applications, referenced by over 3,700 artifacts in the Maven Central repository.
• Eclipse Temurin — Delivers secure, high-quality Java distributions, with over 20 million downloads each month.
• Eclipse GlassFish — Offers cloud-native Jakarta EE implementations.
• Eclipse Software Defined Vehicle (SDV) — Collaborates with major European automotive manufacturers to shape the future of software-defined vehicles.

For more than two decades, Java has remained one of the top five programming languages, underpinning critical systems in finance, healthcare, aerospace, and power grid management. Ensuring robust security and reliability for these foundational tools is paramount. Our engagement with the Sovereign Tech Agency will further strengthen the security and long-term sustainability of these essential open source technologies.

What Is Being Commissioned?

The Sovereign Tech Fund is funding two key initiatives to enhance security, transparency, and vulnerability management across the Eclipse Foundation ecosystem:

1. Software Bill of Materials (SBOM) Generation

• Integration into Build Pipelines – SBOM generation will be embedded directly into the build processes of Eclipse Foundation projects.
• Central SBOM Registry – A unified repository will provide clear insights into components and dependencies across our portfolio.
• SBOM Tools Evaluation – We will assess and select the most effective tools for various project categories, ensuring compatibility with diverse technology stacks.
• Eclipse IDE Support – SBOM generation capabilities will be developed for Eclipse IDE products, enabling developers to effortlessly produce SBOMs for custom IDEs and products developed on top of the Eclipse Platform.

2. Vulnerability Management Enhancement

• Continuous Vulnerability Monitoring – We will implement ongoing monitoring solutions to rapidly detect newly discovered vulnerabilities in project dependencies, even post-release.
• Developer Education and Best Practices – Training and resources will empower maintainers and contributors to triage and remediate security issues swiftly, strengthening our overall ecosystem.
• New Tooling and Automation – Investments in advanced scanners and management platforms will streamline vulnerability detection, reporting, and resolution.

These initiatives will reinforce our supply chain security, enhance transparency, and ensure that Eclipse Foundation’s open source projects remain reliable and resilient for the millions of developers who depend on them.

Looking Ahead

Our partnership with the Sovereign Tech Agency underscores our commitment to open source security and quality. This service agreement further solidifies the Eclipse Foundation’s leadership in delivering critical software technologies worldwide. Ultimately, this collaboration will benefit organisations of all sizes—from large enterprises to individual contributors—who rely on open source software to power their infrastructure, operations, and innovation.

Stay tuned for updates as we make progress on these initiatives. We look forward to sharing new features, best practices, and milestones that will help secure the future of open source technology for everyone.

For additional details about this collaboration, visit the Sovereign Tech Fund’s technology page in English and German.

For more information about the work of the Sovereign Tech Fund—an initiative of the Sovereign Tech Agency—please visit their official website.

Great news for fans of cutting-edge AI: Theia AI and the AI-powered Theia IDE support the latest GPT-4.5-preview model right out of the box! Wondering what’s new or haven’t heard of Theia AI yet? Be …

The post Theia AI and the AI-powered Theia IDE support GPT-4.5-preview by default! appeared first on EclipseSource.

The landscape of large language models (LLMs) is rapidly evolving, with numerous models available and new ones released every day. These models can be accessed through cloud-based services, on-premise …

The post Why Theia supports any LLM! appeared first on EclipseSource.

Building tools or Integrated Development Environments (IDEs) is a complex process, and without a clear strategy, it’s easy to get lost in technical details too soon. At EclipseSource, our blog …

The post How to Build a Custom IDE or Tool appeared first on EclipseSource.

Eclipse Ditto team is excited to announce the availability of a new minor release, including new features: Ditto 3.7.0.

The focus of this release was to ease the migration of Things “definitions” (following WoT Things Models) and to provide a new Policy decision API to check permissions for a logged-in user.
On the operating side, it is now possible to configure extra fields to be proactively added to Things in order to optimize cluster roundtrips and to throttle the amount of updates to the search index after a re-used policy was updated.

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

• Introduce new Policy decision API to check with a single request what a logged-in user is allowed to do with a specific resource
• Include current entity revision of a resource (thing and policy) in the response of requests (commands) and in all emitted events
• Support updating referenced WoT ThingModel based thing definition for a Thing by defining a migration payload and when to apply it

The following non-functional work is also included:

• Add option to configure pre-defined extra fields (enrichments) to be proactively added internally in Ditto in order to save cluster roundtrips
• Include throttling configuration option for updating the search index as a result of a policy update targeting many things
• Add namespace to Ditto Helm chart managed Kubernetes resources

The following notable fixes are included:

• Fix flattening of JSON objects in arrays when an exists() RQL condition was used e.g. as a Ditto evaluated condition

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

Exciting news for developers and tool builders: Yesterday, the new Anthropic model Claude 3.7 Sonnet has been released and Theia AI and the AI-powered Theia IDE now support the new model right out of …

The post Theia AI and the AI-powered Theia IDE support Claude 3.7 Sonnet out-of-the-box appeared first on EclipseSource.

Recent reports indicate that cybercriminals are exploiting the Windows DLL side-loading technique using the legitimate jarsigner.exe executable to propagate malware. This binary is commonly included in Java distributions such as Eclipse Temurin, which is also bundled with the Eclipse Integrated Development Environment (IDE). This has understandably raised concerns about the role of our software and whether the Eclipse Foundation or its projects bear any responsibility.

As the Head of Security at the Eclipse Foundation, I want to clarify the situation, explain DLL side-loading, and reaffirm our commitment to security and collaboration with the community. My goal is to provide a clear understanding of both the technical aspects of this misuse and our approach to maintaining a secure ecosystem.

Understanding the Situation

Dynamically Loaded Libraries (DLL) side-loading, or DLL hijacking, is a well-documented Windows vulnerability. It occurs when an application like jarsigner.exe starts up and Windows loads required DLLs. It is important to note that this attack can exploit any other legitimate, signed binary that loads DLLs, as seen in multiple past security exploits. If an attacker places a malicious DLL in a directory prioritized by Windows’ search order, the system may load the rogue library instead of (or alongside) the legitimate one.

The sequence of events leading to malware infection unfolds as follows:

1. The victim downloads a ZIP file from a rogue website or a malicious email, often with an enticing name such as Employee Performance Report and Termination List.zip, as initially reported by AhnLab.
2. The victim opens or extracts the contents of the ZIP file.
3. Executing the (renamed) .exe file triggers the infection. In the initial report, the executable attempted to masquerade as a regular document, though its name—Documents2012.exe—was already suspicious.

In this case, the Eclipse Temurin distribution of jarsigner.exe remains unmodified and legitimate. It is merely renamed and packed within the ZIP file distributed by malicious actors. The attack relies on an attacker-supplied DLL placed alongside the trustworthy executable, not on any flaw within jarsigner.exe itself.

Why This Does Not Implicate Eclipse Temurin or the Eclipse Foundation

The misuse of jarsigner.exe stems from Windows’ DLL loading behavior, not a vulnerability in Eclipse Temurin. The technique affects countless Windows applications and does not reflect a security flaw in Eclipse Foundation software.

There is no evidence of compromise within the Eclipse Foundation’s infrastructure, Temurin build systems, or projects—not that an attacker would need any. Attackers are simply leveraging a legitimate, signed binary post-distribution by bundling it with malicious files.

Our Response

Although this is not an Eclipse Foundation software vulnerability, security remains our top priority. We actively engage with project teams, security researchers, and downstream distributors to share information and mitigate risks. Even when an issue originates outside our control, we take steps to help users protect themselves and their organisations.

We continuously monitor security advisories and threat intelligence to detect potential misuse. When relevant, we update our documentation with best practices to help users secure their environments. If packaging or configuration adjustments can reduce DLL hijacking risks, we collaborate with downstream maintainers to implement them.

We strongly encourage Windows users and organisations to adopt proven defenses against DLL side-loading, including:

• Application whitelisting to restrict execution of unauthorised binaries.
• Code integrity policies to enforce signed DLL execution.
• Strict application control policies using tools like Windows AppLocker.
• File integrity monitoring to detect unexpected DLLs near trusted executables.
• Principle of least privilege restricting write access to application directories to prevent attackers from placing malicious DLLs.

Looking Ahead

The Eclipse Foundation remains committed to open collaboration and secure software development. While DLL side-loading is a Windows OS issue—not a flaw in Eclipse Temurin, the Eclipse IDE or jarsigner.exe—we take a responsible, transparent approach to securing the software supply chain. Specifically, we provide guidance to all Eclipse Foundation projects as needed, including best practices for hardening executables against malicious actors

We appreciate the security researchers and organisations who brought attention to this issue. By clarifying the technique and its risks, we aim to help organisations enhance their defenses against such threats.

Attackers will continue to misuse legitimate software. While Eclipse Temurin’s jarsigner.exe has been targeted in this case, the real issue lies in Windows’ DLL search order, not a vulnerability in our software.

As always, we remain committed to supporting our users, collaborating with security professionals, and taking proactive measures to safeguard the integrity of the Eclipse ecosystem.

For security concerns or questions, contact our Security Team.

References & Further Reading

• The Hacker News: Cybercriminals Use Eclipse JARsigner to Evade Detection
• AhnLab ASEC Blog: Cybercriminals Abusing Eclipse JARsigner
• MITRE ATT&CK: T1574.002 - DLL Search Order Hijacking
• Eclipse Temurin / Adoptium Project
• Eclipse Foundation Security Policies

In today’s AI-powered development environments (IDEs) and tools, chat interactions are no longer just about answering questions. They have evolved into dynamic dialogues where the AI can ask users for …

The post Introducing Interactive AI Flows in Theia AI appeared first on EclipseSource.