Java on foojay.io - Friends Of OpenJDK

Adding RAG to a Jakarta EE 11 App With Only the JDK and Jakarta Specs

Wed, 07 Oct 2026 00:00:00 +0000

The standard story about AI in the enterprise goes something like this. Your app needs AI, so you spin up a Python service. You add a vector database like Pinecone or Weaviate. You pick an orchestration framework. You now have two deployment pipelines, two languages, and two teams. The original Java monolith that handled your business logic just fine becomes one half of a distributed system that exists mostly to connect to the other half.

Green Build, Wrong Task: A Working Agreement for Java Teams Using AI Coding Agents

Wed, 07 Oct 2026 00:00:00 +0000

You open a pull request. ./gradlew check is green, the diff is 400 lines, the description says “added tests as requested”. You scroll and see a dozen unit tests for one service class. What you asked for, in a two-line Jira comment, was end-to-end coverage of the checkout flow.

Nobody lied. The agent filled a gap in the request with the most likely reading and got to work. This is the first of three failure modes our team went through in a webinar on September 28. I am writing it up because the fixes turned out to be boring and mechanical, and they work with whatever agent your team has already installed.

Real-Time Fraud Detection in Java with Kafka Streams and Vector Similarity

Wed, 07 Oct 2026 00:00:00 +0000

This content is based on a talk that my colleague Tim Kelly and I presented at DevNexus 2026 in Atlanta, one of the largest Java conferences in the world.

Imagine you’re at a supermarket or shopping online. You tap your card or click “Buy Now”. In that exact moment, your bank has to make a decision: is this transaction legitimate, or is it fraud? And it has to do that in milliseconds, and get it right. If it blocks a real transaction, it frustrates the customer. If it approves a fraudulent one, it leads to financial loss. So the question is: how do banks actually do this? What’s happening behind the scenes? In this article, we’ll explore a real-world approach to solving this problem using Java, Apache Kafka, Kafka Streams, and vector similarity with MongoDB.

Building a Code Editor Control in JavaFX

Tue, 06 Oct 2026 00:00:00 +0000

JavaFX doesn’t ship with a code-editor control, and TextArea isn’t built to grow into one — no per-character styling, no gutter, no virtualization tuned for thousands of lines. Building a real one means going back to Control + Skin and constructing the editor surface yourself. This post walks through several pieces of a custom editor control.

The core idea: two virtualized lists, not one

The instinctive design is a single ListView<String>, one row per line, with each row containing both the line number and the code. This approach has a drawback: when the user scrolls horizontally, the line numbers disappear.

Run Java in the Browser with TeaVM

Tue, 06 Oct 2026 00:00:00 +0000

There’s something satisfying about editing a line of Java on a web page, clicking Run, and seeing the result appear right there in the browser. I use this approach for the live Java snippets at nablatensor.com/learn and for source code used to bootstrap nablatensor.com/quantlab. In this article, I’ll explain how the pieces fit together and walk you through a React app you can run yourself.

From Java source to a result

TeaVM compiles Java bytecode into JavaScript or WebAssembly for the browser. To let readers edit and compile the examples, I use teavm-javac, which brings a Java compiler into the browser as well. Compilation happens directly in the reader’s browser: the edited source is sent to a Web Worker in the same tab, without sending a compilation request to a server.

Foojay Podcast #102: Why Foojay Walked Away From WordPress for Static Sites

Mon, 05 Oct 2026 00:00:00 +0000

Foojay.io quietly moved off WordPress and onto Hugo, a static site generator. No more CMS login, no database, no admin panel — just Markdown and AsciiDoc files, built and deployed straight from GitHub. In this episode we dig into why that move happened, and into the bigger question behind it: is a traditional CMS still the right way to run a content site in 2026, or has static tooling caught up? Along the way we go through the real security numbers behind WordPress’s plugin ecosystem — more than 10,000 vulnerabilities found in WordPress plugins since 2025 alone — and put very different static site generators head to head: Hugo and Jekyll, the veterans, versus Roq, the Java-and-Quarkus-based newcomer.

Changes Included in Release 26.08 of Azul Zing Builds of OpenJDK

Fri, 02 Oct 2026 00:00:00 +0000

Azul Zing Builds of OpenJDK, the optimized Java runtime within Azul Platform Prime, has reached the release of the 26.08 Stable Release line. This Stable Build represents an August 2026 promotion from Stream to Stable status, consolidating six months of Stream Build work into a single, supported release line. The headline addition is Compilation Streaming, which lets a JVM download pre-compiled code from Azul Optimizer Hub at startup instead of waiting on its own JIT compilation queue.

Announcing 'Skinning JavaFX Applications'

Thu, 01 Oct 2026 00:00:00 +0000

If you’ve ever tried to make a JavaFX application look like Microsoft or JetBrains, you know that CSS is not enough. Skinning JavaFX Applications is my attempt to close that gap — a practical, code-first book built from years of shipping real desktop business applications.

The main purpose of this book is to cover the Control-Skin architecture, so you can create your own custom controls and skins. We’ll cover how to implement custom window chrome, runtime theme switching, Fluent Design materials like Mica and Acrylic, and a full set of micro-interactions.

Lathe: A Java Language Server That Works Straight From Your Maven Build

Thu, 01 Oct 2026 00:00:00 +0000

I have written Java in many editors and IDEs over the years, and they all seem to struggle with the same thing.

For me, the hard part of a Java IDE or language server was never the code intelligence. It was getting the project structure right. The IDE reads your build files and then tries to guess the module structure from them. And over time, Java’s compiler and runtime configuration has become more and more complex: annotation processors, the module system, and more. So you often end up in a familiar place: the code compiles and runs in the build, but not in the IDE. Even the best ones tend to break the project setup after an upgrade.

Durable Execution Is a Property, Not a Product

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

Three method calls. That is my entire workflow: charge a payment, reserve inventory, send a confirmation email.

Run those three calls on a dedicated workflow engine and here is what happens before your business logic is done: 23 history events are appended, 15 durable state transitions are committed to a database, and 15 gRPC round trips travel between your worker and the orchestration cluster.

That, in one paragraph, is why I want to talk about durable execution. Not because the engines are bad. They are impressive systems built by serious engineers. I want to talk about it because the Java community is being sold a property as if it were a product, and I think most of us already own the property.

Lies, Damn Lies and Benchmarks

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

There’s an old joke about three kinds of lies: lies, damn lies, and benchmarks. Codename One did very well in our benchmarks. But were they accurate? Were they representative?

Performance is the fitted sheet of programming. Just when you get the damn corner into place, the rest of the bed is a complete mess.

My love-hate relationship with Java formatters

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

Disclaimer: I don’t want to turn this into “Java formatters week”, but I started my own project a while ago, and I think it’s time for it to come out of stealth mode.

I’ve been writing Java for many, many years, and the Sun Code Conventions were my favorite bedside reading. I’ve seen plenty of variations over the years, and even after they became the Oracle Code Conventions, they were still the same few-page guide on how to write a hello-world app with the standard class library. For some reason I never took to the Google conventions: too C-flavored, with tiny indents, too few columns on the screen, and so on.

The Java 21 Doomsday Clock Countdown

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

The Java 21 Countdown Is Pressing

Oracle JDK 21 was free to use in production under Oracle’s No-Fee Terms and Conditions (NFTC) license. That free ride is over. Oracle’s licensing rule ties free NFTC use to one year after the next Long Term Support (LTS) release ships, and since Java 25 became generally available on September 16, 2025, the license window closed on September 16, 2026.

The date that matters now is October 20, 2026. That is Oracle’s next quarterly update — the first batch of Java 21 patches, including Critical Security Patch Updates (CSPUs), that no longer reaches you under the free license. Every Java 21 fix from that day forward requires a paid Oracle subscription. This is not a one-time event: the same mechanism already retired free updates for Java 17, and it will retire Java 25’s free updates in turn once Java 29 ships. It’s a recurring toll booth built into Oracle’s licensing terms.

How much will post-quantum migration cost your Java codebase?

Mon, 28 Sep 2026 00:00:00 +0000

The post-quantum transition has stopped being a research topic and become a set of dates. NIST finalized ML-KEM (FIPS 203), ML-DSA (FIPS 204) and SLH-DSA (FIPS 205) in August 2024. NIST IR 8547 deprecates RSA, ECDSA, (EC)DH and the rest after 2030 and disallows them after 2035, and similar timelines are turning up in government guidance elsewhere.

So the destination is settled. For most Java teams the hard question is not what to migrate to. It is how much the migration will cost for their specific codebase, and where the expensive parts are hiding. That question has been oddly hard to answer, and most of the post-quantum migration tooling I could find targets C, C++ and Rust, even though a great deal of enterprise cryptography runs on the JVM.

Testing Kafka Consumer Recovery Contracts With Testcontainers and JUnit

Mon, 28 Sep 2026 00:00:00 +0000

A Kafka consumer can pass a unit test and still fail when production redelivers a record.

That happens because the unit test usually checks the handler, not the recovery contract. It verifies that one message produces one expected side effect. It rarely verifies what happens when the same event arrives twice, when a malformed record reaches the topic, or when the consumer applies a side effect and then crashes before committing the offset.

One Database, Two Models: Building AI-Friendly Java Applications with MySQL JSON Duality Views

Sat, 26 Sep 2026 00:00:00 +0000

MySQL can now hand your application a complete JSON document, such as an order with its customer and line items, while the data stays in normal relational tables. You can even send the document back and MySQL updates the right rows. I built a small Java app to see how far that goes. Reading got much simpler. Writing works too, but it comes with a few sharp edges you should know about before you use it.

VoIP, VPN, and the Build System Behind Them

Fri, 25 Sep 2026 00:00:00 +0000

In 2019, a reader asked whether our WhatsApp clone included VoIP. I said no. It would require native integration, and the setup was too much for that project. For years, that was the line.

VPN sat behind the same line. These features do not live neatly inside the application process. On iOS, a VoIP push can arrive before the application installs a Java listener, yet CallKit expects the incoming call to reach the lock screen on its deadline. A Call Directory integration is a separate extension executable with its own lifecycle and signing identity. Managed VPN adds Network Extension entitlements and profile rules. Android solves the same jobs through ConnectionService, VpnManager, VpnService, manifest declarations, and foreground-service rules.

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.

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