Friends Of OpenJDK Today on foojay.io - Friends Of OpenJDK

Diagrams as Code: Mermaid Support on the new Foojay

Thu, 24 Sep 2026 00:00:00 +0000

Some things are much easier to show than to describe. A request travelling through three services, a class hierarchy, the states a connection moves through: a paragraph explaining it takes real effort to write and still leaves the reader assembling the picture themselves.

The usual answer is to open a drawing tool, export a PNG, and drop it in the article folder. That works, and it is what most Foojay articles have done so far. It also means the diagram is now a binary file that nobody can review, nobody can correct a typo in, and nobody can update without finding the original file again, assuming they still have it.

AsciiDoc Support on the new Foojay

Wed, 23 Sep 2026 00:00:00 +0000

Markdown is a good default. It is easy to write, everybody already knows it, and for most articles it is exactly enough.

For some articles it is not. If you have ever wanted to put a caption on a code block, number the interesting lines and explain them underneath, or set a warning apart from the paragraph before it, you have found the limits of Markdown.

Large parts of the Java ecosystem document in AsciiDoc for exactly this reason. So posts here on the new Hugo-driven Foojay, can now be written in it too. Thanks to Brice Dutheil for requesting this feature, and for naming exactly which parts of it he uses. And of course, this post is written in AsciiDoc to show it off!

Announcing The New Foojay

Tue, 22 Sep 2026 00:00:00 +0000

Foojay has moved, but the address stays exactly where it was, just like every URL you have bookmarked, linked or cited. Everything behind that address is new. Foojay is now a static site, its entire content lives in a public Git repository, and publishing an article is a pull request.

If you only read one paragraph: nothing you have written has moved, and nothing you need to do has changed, except if you want to contribute content.

World geography gotchas

Sun, 20 Sep 2026 05:51:17 +0000

Years ago, a colleague of mine told me about two pockets of foreign land surrounded by Switzerland: Campione d’Italia and Büsingen am Hochrhein, respectively Italy and Germany. Both are enclaves of their respective country in Swiss territory:

An enclave is a part of the territory of a state that is enclosed within the territory of another state. To distinguish the parts of a state entirely enclosed in a single other state, they are called true enclaves. A true enclave cannot be reached without passing through the territory of a single other state that surrounds it.

BoxLang 1.17.0 Released: Module Inception, CLI Checker, Jar Loading and much more!

Thu, 17 Sep 2026 20:20:32 +0000

BoxLang has always been an extensible language. As of 1.17.0, it is a hierarchically extensible one.

Modules can now contain other modules; aka Module Inception . Recursively. To any depth. Each nested module gets its own class loader, chained to its parent’s, and BoxLang’s own ModuleService discovers, registers, activates, and unloads that entire tree itself. No package manager. No build tool. No install ordering. Drop in one artifact and everything it depends on comes with it, already wired up and already isolated. Not only that, you can now package modules into a single jar.

What's New In The September 2026 Azul Payara Release?

Wed, 16 Sep 2026 16:46:54 +0000

The September 2026 release brings Azul Payara Server & Micro 7.4.0, Payara Community 7.2026.9, as well as Azul Payara Server & Micro 6.42.0 5.91.0 & 4.1.2.191.59.

The headline for Azul Payara is MicroProfile 7.1. It shipped in the Community release last month; this cycle it arrives on both the commercial 7 and 6 lines. That upgrade brings one change that needs reading before you upgrade: MicroProfile OpenTracing has been removed, and the specification defines no automatic migration path.

Can You Explain the Diff Your AI Agent Just Wrote?

Tue, 15 Sep 2026 14:12:01 +0000

Every Java developer has been in a code review where the question is simple: “What does this method do?”

The answer used to tell you something. The developer who wrote it would describe the intent, the edge cases, the trade-off they considered and rejected. The code review was a conversation about the invariant the code protects.

Now the answer is sometimes: “The agent wrote it.”

The code compiles. The tests pass. The linter is clean. Nobody in the review can explain the architecture of the PR, including the person who submitted it.

How I Built an AI Assistant for My Career with Java, Spring AI, and MongoDB

Tue, 15 Sep 2026 11:51:17 +0000

The best way to learn a technology is by putting it into practice in a real system.

A few months ago, I decided to build a virtual assistant that could answer questions about my career, help people learn more about my articles, videos, talks, and projects, and even schedule a call on my calendar.

At first, the idea was simple: give the assistant access to my content and let people ask questions about it. But as the project evolved, I realized that not every question should be handled in the same way. Some questions can be answered with a direct query to the database, while others benefit from semantic search. In other cases, the assistant may need to use a tool or execute multiple steps before reaching an answer.

Hello Java 27! Have You Been Working Out?

Tue, 15 Sep 2026 08:00:00 +0000

It’s been six months since we saw a new Java release, and this new edition seems to be ready to flex its muscles. With numerous improvements to performance and security, Java 27 is like that friend that you haven’t seen all summer, and when you finally see them again it’s clear that they spent a lot of time in the gym!

This post focuses on everything that has been added in this release, giving you a brief introduction to each of the features. Where applicable the differences with Java 26 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to start using these features after reading this.

Foojay Podcast #101: Java 27 in Practice: Smaller Heaps, Smarter Defaults, and Valhalla on the Horizon

Mon, 14 Sep 2026 06:11:42 +0000

JDK 27 arrives on 15 September 2026, and it is a feature release rather than a Long-Term Support one. That distinction matters less than it sounds: as Simon Ritter points out, all OpenJDK releases are delivered the same way, and “long-term support” is a property of the binary distributions you install, not of the platform itself. What JDK 27 does have is two changes that switch on by default and cost you nothing but the upgrade. Compact object headers shrink the per-object header from 64 bits to 32, which the JEP measures at a 22% reduction in heap and 8% in CPU on SPECjbb2015 — and because it is internal to the JVM, a JAR you built years ago benefits without a single line changing. Alongside it, G1 becomes the default garbage collector everywhere, including the small, single-core machines that used to fall back to the serial collector.

Come for Java. Get a Whole Lot More.

Fri, 11 Sep 2026 09:33:46 +0000

JCON USA returns inside IBM TechXchange 2026 with two rooms of deep Java content, a dedicated community home, and direct access to one of the years biggest technical conferences.

From Orlando to Atlanta

Last year, we tried something new. We brought JCON USA into IBM TechXchange and created a Java community conference inside a much larger technology event. The result showed us that these two worlds fit together remarkably well. JCON brought the independent, developer-to-developer spirit of the Java community. TechXchange provided the scale, infrastructure, learning opportunities, and access to experts that only a major international conference can offer.

Reflection-Free Serialization on the JVM: Four Formats In, Avro Out

Thu, 10 Sep 2026 06:56:00 +0000

I run a model layer that accepts the same business data in JSON, XML, YAML, and TOML and converts it all to Avro. The project was greenfield, so the question was never what to migrate away from. It was a question of which serialization library the layer would be built with: Jackson or kotlinx.serialization. Jackson was the safe answer, with a module for every format we needed and years of production behind it. What pulled me the other way was the assumption that runtime reflection costs real CPU under load. That turned out to be true of one Jackson path and not the other, which I will get to. The reasons the choice held up were not the reasons I made it.

One Base URL, Many Coding Agents: What an OpenAI-Compatible Gateway Looks Like From java.net.http

Wed, 09 Sep 2026 16:09:53 +0000

Somewhere in every coding agent there is an HTTP client. Claude Code, Codex, Cursor, Cline, OpenCode: strip away the terminal UI or the editor pane and each of them serializes a conversation into JSON, POSTs it to a base URL with an API key in a header, and streams the answer back. The client owns the prompt assembly, the tool loop and the rendering; the model sits on the far side of that socket.

Masking a JVM thread dump without breaking the analysis

Wed, 09 Sep 2026 07:32:00 +0000

A few weeks ago I posted on r/java about detecting virtual thread pinning from a plain thread dump. The technical discussion was fine. The comment that stuck with me had nothing to do with pinning: “the problem isn’t taking the dump, it’s that uploading a production dump to a third-party site is against policy”. Not a preference. Policy. And the person saying it was right.

I run ThreadMine, a hosted thread dump analyzer, so that comment describes my own product. This article is about what I built in response: a small open-source CLI that rewrites the dump on your machine before it goes anywhere, in a way that keeps the analysis working. It’s called tm-anon, it’s MIT, and it works with any analyzer, mine included. The interesting part isn’t the tool, it’s the constraint: you can’t just strip everything, because the analyzer needs most of what’s in there.

Debugging Is Invariant Discovery: What One Kafka Session Taught Us About AI Agents

Tue, 08 Sep 2026 14:14:36 +0000

Every Java team has a sentence like this one somewhere:

Any operation on a TID must go through the single asynchronous path and must not let TMS and EMV drift apart.

It is the kind of rule that is obvious once said and invisible until then. A terminal ID (TID) in a payments system, an asynchronous pipeline that updates two downstream systems, and the requirement that the two never disagree. Nothing in the type system enforces a rule like that, and no single class owns it. Rules of this kind live between consumers, services and stores.

Community Spotlight: BoxLang Express Brings Node-Style HTTP to the JVM

Tue, 08 Sep 2026 11:25:18 +0000

If you’ve spent years in Spring Boot, Micronaut, or Jakarta EE, “web framework” usually means a servlet container, an embedded Tomcat or Netty, a build step, and a fat jar before anything answers a request. What if you could skip all of that and still be on the JVM?

BoxLang Express , a new community module built entirely by developer Robert Zehnder of KISDigital, does exactly that. It’s built directly on com.sun.net.httpserver.HttpServer, a class that’s been sitting in the JDK since Java 6, so there’s no embedded server to configure and nothing extra on the classpath for the HTTP layer itself. boxlang server.bxs is the whole deployment story.

“Commit created” — but it isn’t: why the agent’s word needs external verification, and what the mistake costs

Tue, 08 Sep 2026 08:54:03 +0000

A detailed report reads like proof. The agent lists the files it touched, names the branch, quotes a commit hash, adds a test count and closes with “done”. The work has a shape. The shape looks right. You have six more tickets.

The report is model output. The commit, if it exists, lives in .git. The file, if it exists, lives on disk. The build result lives in a process exit code and a run log. The chat window is none of those places, and it can only vouch for itself.

From OpenTelemetry to DuckDB

Tue, 08 Sep 2026 08:29:37 +0000

Observability platforms generally expect you to do your analysis inside them, using their query language and their dashboards. That works for the questions you already know you have. It works less well for the ad-hoc ones: a quick percentile , a pivot by status code , or “which service is actually eating the latency budget?” once the data is in front of you.

This article describes a small pipeline for that kind of question. On one side is DuckDB, the in-process analytical database that reads CSV, JSON and Parquet directly. On the other is the Dash0 CLI, which pulls OpenTelemetry spans, logs, metrics and traces out of Dash0 and prints them as CSV or JSON.

Featured Foojay Authors for September 2026: Marit van Dijk and Graeme Robinson

Mon, 07 Sep 2026 08:38:56 +0000

Foojay wouldn’t exist without the many contributions from its community, whether it’s a single post or an ongoing stream of knowledge sharing. That’s why we highlight two of them each month as Featured Authors. After Igor and Steve in July, and Cristobal and Shai in August, September belongs to Marit van Dijk and Graeme Robinson. Want to read more from either of them? Click their name to visit their Foojay author page, where you’ll find their full list of posts.

Bringing Raspberry Pico to Quarkus with Firmata

Mon, 07 Sep 2026 06:06:42 +0000

Java applications are usually associated with APIs, databases, messaging systems, and cloud infrastructure. But Java can also interact with the physical world—reading sensors, controlling LEDs, driving motors, and communicating with microcontrollers.

That is the goal of Quarkus Firmata, a new Quarkus extension that connects Quarkus applications to Firmata-compatible boards such as the Raspberry Pi Pico.

The project combines three technologies:

Quarkus for application development and dependency injection
firmata4j as the Java implementation of the Firmata client protocol
ConfigurableFirmata running on the microcontroller

The initial version focuses on a practical MVP: digital input and output, analog input, PWM output, and USB serial communication with a Raspberry Pi Pico.

Build an AI Agent (From Scratch)

Mon, 07 Sep 2026 05:52:13 +0000

This review is about Build an AI Agent (From Scratch) by Jungjun Hur and Younghee Song from Manning.

Facts

10 chapters
$29.29 (at the time of this writing)
315 pages

Chapters

Building your first LLM agent
1. What is an AI agent?
2. The brain of AI agents: LLMs
3. Enabling actions: Tool use
4. Implementing a basic ReAct agent
Developing advanced agent capabilities
1. Building knowledge bases with RAG
2. Adding memory to your agent
3. Planning and reflection for complex tasks
4. Empowering agents with code execution
5. Orchestrating multi-agent systems
6. Evaluating agents

Pros and cons

At Manning, I consider the following two books to be references:

From Spec-Driven Development to Living Specifications in Java Projects

Fri, 04 Sep 2026 05:51:45 +0000

From Spec-Driven Development to Living Specifications in Java Projects

Coding agents have changed the speed at which we can produce software. But producing code faster does not automatically mean producing better software.

As I started using agents more frequently in real-world software development, one question became increasingly important: how do we give an agent enough freedom to be useful without losing engineering intent?

Trying to control every line of code generated by an agent removes much of the value it can provide. At that point, it might simply be faster to write the code ourselves.

Building an Agentic Warehouse Management System — Part 3: Tools, Decisions, and Actions

Thu, 03 Sep 2026 16:50:36 +0000

If you haven’t read the first two parts yet, I recommend starting with Part 1: Where AI Agents Add Value and Part 2: Designing and Planning the Agent. There, we introduced the WMS scenario, discussed where an AI agent can add value, and built the first stages of the implementation with Java and Spring AI.

In this third and final part, we will build on the execution plan created in Part 2 and focus on the remaining stages of the agent workflow. We will see how each task is executed using controlled tools, how operational and business context is gathered, how the replenishment decision is made, and how the agent acts on that decision when necessary.

Building an Agentic Warehouse Management System — Part 2: Java and Spring AI

Thu, 03 Sep 2026 16:39:59 +0000

If you arrived here without reading the first part, I recommend starting with Agentic WMS — Part 1: Where AI Agents Add Value. There, we introduced the WMS scenario, explored the replenishment problem, and discussed where an AI agent can add value without replacing deterministic application logic.

In this second part, we will move from the design to the first steps of the implementation.

We will look at how the agent is built with Java and Spring AI, how its capabilities and boundaries are defined, how it is triggered by the WMS, and how the planner turns the agent’s goal into an execution plan.

Agentic WMS — Part 1: Where AI Agents Add Value

Thu, 03 Sep 2026 16:23:14 +0000

I spent a large part of my career working in banking and logistics. In logistics, I spent more than eight years working across different stages of logistics systems, from development to implementation and production support.

That experience shaped the way I think about technology. Knowing a tool or framework is important, but what interests me most is understanding the business problem behind it and where technology can actually add value.

Did Your AI Agent Ever Run a Debugger? One JVM Bug, Two Agent Runs

Thu, 03 Sep 2026 13:48:32 +0000

Java developers reach for the debugger without thinking about it. Set a breakpoint, run the failing test, look at the variables, then decide what to change.

Most AI coding agents I have watched skip that step. They read the stack trace, read the source, and propose a patch. The reasoning can look excellent and still be a guess about a program nobody ran.

I wanted to know what that guess costs. So I took one real JVM bug, one model, one prompt, and ran it twice with two debugging workflows. Here is what the two transcripts show.

No Database Operations Found: What Writing a Spring Boot Analyzer Taught Me About Spring

Thu, 03 Sep 2026 06:26:00 +0000

I spent months building a static analyzer that answers one question about a Spring Boot codebase: if I change this endpoint, what does the change reach?

Every serious bug I found in it had the same shape.

Not a wrong edge in a graph. Not a missing feature. A confident absence — the tool stating, definitively, that an endpoint touched no database, opened no transaction, published no message, when it did all three.

MongoDB Search Server, improved!

Wed, 02 Sep 2026 10:00:00 +0000

In this article, we’re going to revisit and improve the MongoDB Search Server originally described in the article How to Build a Search Service in Java with MongoDB.

First, let’s remind ourselves why an intermediate search service deserves our attention and effort: Search powers the most important part of your application, getting users to the content they need, fast. The search bar often serves as the main entry point to your services. Search results can be returned with all the information needed to present to the user without querying the source database at all. With search serving this important, heavy load on its own, separating the search service into an independently scalable tier allows us to control, scale, and version the search server as needed. Having a gateway from the application to MongoDB Search also allows us to simplify the interface by passing only the key parameters, without getting entangled in the specifics of the aggregation pipeline syntax.

Aggregation Optimization in MongoDB: Sorting With Indexes (Part 5)

Tue, 01 Sep 2026 14:07:36 +0000

And why MongoDB might be a better relational database than you ever realized.

Design reviewsare one-on-one meetings where MongoDB experts deliver advice on data modeling best practices and application design challenges. In this series, we are going to explore common real-life scenarios where design reviews helped developers achieve meaningful success with MongoDB.

In this series, we’ve described our steps to improve the performance of a slow running MongoDB aggregation pipeline. The pipeline was part of a fictional video streaming service application, mapping user profiles to the devices those users were using to access the service, and was based on a real use case I’d encountered during a recent design review.

Announcing BX-WORD: Native Microsoft Word Automation for BoxLang

Tue, 01 Sep 2026 11:31:16 +0000

Every enterprise runs on Word documents. Contracts. RFPs. Proposals. Board reports. Offer letters. HR handbooks. Compliance policies. Invoices. Statements of work. Legal memos. Today, we are incredibly proud to announce bx-word 1.0.0, a first-class, fluent, production-ready module for creating, populating, and transforming Microsoft Word documents natively in BoxLang. This is not a wrapper. This is not a converter. This is a real document builder designed for the way enterprise teams actually work.