AI on foojay.io - Friends Of OpenJDK

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.

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.

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.

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

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.

AI-assisted genealogy

Mon, 31 Aug 2026 05:51:48 +0000

My son recently came to me to brag about using AI to find our ancestors. While the results were correct, I didn’t learn anything new, as it stopped at my grandparents. I was never very interested in my genealogy, but I decided to see if AI would be a good tool for this. TL;DR: Yes, it is, and even more than that. In a little less than one month, I managed to gather more than 600 individuals and get back 12 generations in some branches.

What's New in the August 2026 Azul Payara Release?

Mon, 24 Aug 2026 15:36:28 +0000

The August 2026 release brings Azul Payara Server and Micro 7.3.0, Azul Payara Community 7.2026.8, Azul Payara Server and Micro 6.41.0, Azul Payara Server and Micro 5.90.0, and Azul Payara Server and Micro 4.1.2.191.58.

The headline is in the Community edition. Azul Payara Community 7.2026.8 ships support for MicroProfile 7.1 and a first preview of Jakarta Agentic AI, the new vendor-neutral specification for building AI agents on Jakarta EE runtimes. For the Enterprise lines, this cycle adds gRPC support across the 7, 6, and 5 releases, and carries a security advisory patched across the 6, 5, and 4 lines, with two Jackson CVEs additionally closed on the 5 and 4 lines.

Introducing BoxLang AI Explorer: A Local Catalog for Every AI Pattern

Tue, 18 Aug 2026 14:15:48 +0000

Learning a new AI API usually means jumping between scattered documentation pages, guessing at imports, and copy-pasting code that may or may not still work. We wanted something better for BoxLang AI, so we built the BoxLang AI Explorer : a local, browser-based catalog of runnable BoxLang AI examples, organized by category and difficulty, each with guidance, source code, and sample output. You can also try it online at https://ai.boxlang.io/explorer/

Build Secure AI Chat Applications with BoxLang, RAG, Ollama, and Amazon Bedrock with Dan Card

Thu, 13 Aug 2026 14:52:13 +0000

Build Secure AI Chat Applications with BoxLang, RAG, Ollama, and Amazon Bedrock

AI demos are everywhere. Building an AI-powered feature that can securely work with your documents, databases, and real application data is a very different challenge.

How do you give an AI model access to the right information without exposing sensitive data? Should you use a locally hosted model or a cloud service? How do you move beyond a basic chatbot and build something genuinely useful for your users or organization?

Jakarta Agentic AI Hits Its First Milestone

Wed, 05 Aug 2026 10:43:12 +0000

Jakarta Agentic AI just shipped its first deliverable: version 1.0.0-M1 is live on Maven Central and the draft 1.0 specification is out for review. The project now has a specific API surface that developers can look at, try out and give feedback on.

Quick recap - what is Jakarta Agentic AI?

If you missed the original announcement, Jakarta Agentic AI is a new Eclipse Foundation project bringing vendor-neutral, standardized APIs for building AI agents to Jakarta EE runtimes. The goal is to do for agentic AI what Jakarta Servlet, Jakarta RESTful Web Services and Jakarta Batch did for their respective domains: give Java and Jakarta EE developers a consistent, portable programming model instead of forcing them to hand-roll agent orchestration or lock into a single vendor’s framework.

GitHub agentic workflows and Renovate

Mon, 03 Aug 2026 05:54:08 +0000

I’ve been a big fan of Renovate for a couple of years already. Renovate scans your repositories, detects outdated package versions, and opens pull requests to automatically bump them. It’s similar to Dependabot in that it keeps your dependencies up to date. If I had to compare them in one sentence, I’d say Renovate is less integrated in the GitHub ecosystem, but handles more ecosystems and, more importantly, is extensible. My current company is a happy Renovate user, and I already started to use it in some repositories.

How to Create a Spring Boot Fraud Scoring Service

Fri, 31 Jul 2026 08:45:43 +0000

Most Java teams who want a machine learning model in production end up standing up a Python service and calling it over HTTP. That works, but it buys you, as a Java developer, a second runtime, a second deployment pipeline, a network hop on every prediction, and a team boundary that turns retraining into someone else’s ticket.

Deep Netts removes that split: it’s a pure-Java deep learning library, so the model trains in Java, serializes to a file, and loads back into your Spring Boot application as an ordinary bean. Predictions become in-process method calls measured in microseconds, with nothing extra to deploy, secure, or monitor.

AI Found the Bugs. Who's Patching Your EOL Java Code?

Thu, 23 Jul 2026 15:26:53 +0000

Earlier this year an AI model found a flaw in OpenBSD’s TCP stack that had been sitting there for 27 years. The same scanning run turned up a 16-year-old bug in FFmpeg’s H.264 code.

How do you feel about AI being used to discover bugs in open source, across the board and at scale?

Because that’s what’s happening. It’s tough enough dealing with machine-speed vulnerability discovery in code that has active maintainers. What about all the code with no friendly pair of safe hands?

I Asked GitHub Copilot to Profile a Java App. It Found a Bug in My Heap Sizing, and Offered to Fix It

Tue, 14 Jul 2026 14:42:11 +0000

I built an extension to collapse the entire loop of running and measuring the performance of Java workloads, so it can be used within a place some developers are starting to consider their new “development environment” in the agentic AI era: the GitHub Copilot app.

The idea: Copilot-driven profiling

This extension is called JVM Pulse, and this is a walkthrough of one real run. JVM Pulse is a canvas extension for the GitHub Copilot app. It doesn’t hard-code how to build or run Java projects and it doesn’t need the user to be specific either. You click Run analysis, and Copilot does the project-specific work: it detects your build tool and JDK, writes or compiles a representative workload, and launches it with the right flags: unified GC logging and a JFR recording with settings=profile.

Building AI Systems with MongoDB: Implementing the Planning Pattern

Thu, 02 Jul 2026 10:00:00 +0000

Artificial Intelligence has swiftly evolved from a niche research topic to a technology that impacts nearly every aspect of the software industry. Developers now use AI to generate code, review pull requests, create documentation, and accelerate workflows through methods like vibe coding and specification-driven development. While these applications position AI as an engineering tool, a new trend is emerging: integrating AI directly into business workflows within applications.

This shift offers new challenges for software architects and engineers. Traditional applications rely on deterministic flows, where execution paths are explicitly defined by methods, conditions, loops, and business rules. In contrast, machine learning systems can make decisions during execution, select actions, and adjust dynamically based on context and available information. Architects must therefore design systems that balance the predictability of conventional software with the flexibility of AI-powered reasoning. The Planning Pattern is an effective approach for uniting these domains. Instead of having an LLM address a complex objective in a single step, this pattern breaks the goal into smaller, feasible tasks that interact with deterministic code, external services, and data sources. This creates a more reliable and observable path toward autonomous AI applications.

You’re invited to IntelliJ IDEA Conf 2026!

Mon, 29 Jun 2026 18:35:08 +0000

We are excited to invite you to IntelliJ IDEA Conf 2026, a free virtual event on September 8-9, 2026.

IntelliJ IDEA Conf is a celebration of the developer community, bringing together professionals who strive for excellence in software development. Join us for this free, live online conference and learn from industry leaders and experts on September 8-9, 2026.

You’ll be able to learn about a broad range of topics relevant to modern Java and Kotlin development, including language evolution, enterprise Java, Spring-based applications, build tooling, containerized workflows, JVM performance, and data access technologies. For more details, see the agenda below.

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 3: Stateful Workflows and Human-in-the-Loop

Mon, 29 Jun 2026 09:40:40 +0000

This is the third and final article in the series. Part 1 covered the RAG foundation — loading runbooks into a vector store and grounding model answers in real documentation. Part 2 added short-term and long-term conversational memory. This article introduces stateful workflow checkpointing, tool calls, and a pause/resume mechanism that lets multi-step investigations survive session boundaries.

The Remaining Gap

Where were we? At the end of Part 2 of our tutorial, we have an assistant capable of sustaining a conversation consisting of multiple exchanges and remembering the information exchanged across multiple sessions. For example, an operator can ask multiple questions regarding a CPU spike alert and will receive responses from the assistant that build upon one another, taking into account their preferences or past choices. In fact, across all sessions, the assistant will remember when the operator expressed a preference for using Helm charts for rollback operations and the fact that the payments service runs on a Kubernetes infrastructure consisting of 16 pods.

AI-Assisted Unused & Dead Code Removal

Sun, 28 Jun 2026 07:19:42 +0000

Why Your Codebase Is Forcing AI to Underperform, and What to Do About It

Your AI coding assistant is only as good as the codebase it works on. If your Java application carries years of dead & unused code, and most do, the AI spends its reasoning budget on code that nobody runs. The result is more hallucinations, worse suggestions, and higher token costs. Here’s what to do about it.

Systematic AI Coding: My Takeaways from the Eclipse Foundation Workshop in Brussels

Tue, 23 Jun 2026 19:48:42 +0000

Most developers using AI tools are still guessing. The Eclipse Foundation’s first AI Coding Workshop in Brussels was built to change that. It’s a brand new format they launched in Brussels, which makes sense: most of the Eclipse event team is based there. They plan to bring it to more cities from here, so keep an eye out if you want to attend such a workshop in the future. They offered 10 free tickets to share with the BeJUG and Foojay community. And in all honesty, I used one for myself. Jonas Helming from EclipseSource led the workshop, with a fun quiz hosted by Thomas Froment in the afternoon. Here’s what I took away.

Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius

Mon, 22 Jun 2026 06:54:00 +0000

Your AI-powered Java application is live in production. But have you actually tested whether it can be jailbroken or manipulated into leaking data it should never reveal? In this episode, Iryna Dohndorf walks us through Tiberius, an open-source security testing library for LLM applications in Java, and explains why everything you know about unit testing needs a rethink when non-determinism is part of the design.

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Building an AI-Powered Operations Assistant with Spring AI and MongoDB Atlas — Part 2: Conversational Memory

Wed, 10 Jun 2026 19:23:46 +0000

This is the second article in a three-part series. Part 1 covered the RAG foundation — loading runbooks into a vector store and wiring them to a language model. Part 3 will introduce stateful workflow checkpointing with pause and resume.

The Problem with Stateless Chat

In the first part of the series, we successfully created a chat interface where an operator can ask questions and receive answers based on the actual content of the runbooks they have uploaded and embedded in the system. For example, they can ask in the chat, “What should I check when my server’s CPU usage exceeds 80%?” and the assistant retrieves the relevant sections from the various runbooks and assembles a coherent and concrete response.

Why Spring Teams Don't Need a Second Runtime for AI Agents

Wed, 10 Jun 2026 19:02:58 +0000

A JVM-native runtime for building, governing and operating AI agents on existing Spring infrastructure.

Every time a Spring team decides to add AI agents to a production system, the story tends to follow the same arc. A few prototypes are built, several frameworks are evaluated, and then a new reality emerges: the project is no longer just about adding agents. It is about operating a new platform.

With that new runtime come new deployment pipelines, new monitoring mechanisms, additional security reviews, and new operational responsibilities.

"Agentic" Was Everywhere at Money20/20 Amsterdam

Fri, 05 Jun 2026 08:55:48 +0000

I walked the floor at Money20/20 in Amsterdam with a simple little mission: count the first ten vendor booths using “AI,” “agent,” or “agentic” in their pitch.

My first impression was that this would be hard. Hundreds of organizations, and the buzzwords felt oddly absent — payments, core banking, compliance, the usual fintech furniture, but not the wall-to-wall “agentic everything” I’d braced for. I jotted down my first ten and thought: huh, AI is barely here.