Foojay.io | Friends of OpenJDK and Java Programming

Episode 101 of the Foojay Podcast.
JDK 27 arrives on 15 September 2026 without finalising a single new piece of language syntax. It is still worth the upgrade: object headers shrink from 64 bits to 32, which the JEP measures at 22% less heap and 8% less CPU on SPECjbb2015, and G1 becomes the default garbage collector on every machine. Both changes live inside the JVM, so an application you compiled years ago picks them up with no code change at all.
Simon Ritter, Deputy CTO at Azul and Java Champion, takes us through all nine JEPs in the release, explains why a non-LTS version is still worth testing against, and makes the point that "long-term support" describes the binary you download rather than anything in OpenJDK itself. We also cover the move from quarterly to monthly security updates that started in August 2026, and then look ahead to March 2027, when Project Valhalla reaches its first preview after roughly twelve years of work.
Topics include:
Compact object headers by default, and what 22% less heap actually buys you in production
Post-quantum key exchange in TLS 1.3, and the harvest-now-decrypt-later attack it defends against
JFR redaction: keeping access tokens and passwords out of flight recordings you share
Structured concurrency in its seventh preview, and why an evolving API stays in preview
The Vector API's twelfth incubation, and what it is waiting for
Value Objects in Java 28: a new value keyword, 179,000 lines, 1,800 files, and why it will not be final in JDK 29
Whether a Simple JSON API in the JDK will survive its previews, or go the way of string templates

Guest: Simon Ritter
Deputy CTO at Azul, Java Champion
Simon on LinkedIn
Simon on Foojay
Links:
Full show notes, with every JEP linked
JDK 27
What CSPUs Mean for Your Release Pipeline
What to Know About Garbage Collection as a Java Developer!
Project Valhalla
Timestamps:
00:00 Introduction of the topic and guest
01:27 How long Simon has been doing Java
01:54 Why release 27 is important, even when not being a Long Term Support release
04:55 Quarterly and monthly security updates between new version releases
08:07 Which JVM versions are most used in companies
09:23 JEP 534: Compact Object Headers by Default
14:51 JEP 523: Make G1 the Default Garbage Collector in All Environments
18:59 JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3
22:55 JEP 538: PEM Encodings of Cryptographic Objects (Third Preview)
25:35 JEP 536: JFR In-Process Data Redaction
28:02 JEP 531: Lazy Constants (Third Preview)
29:55 JEP 532: Primitive Types in Patterns, instanceof, and switch (Fifth Preview)
33:13 JEP 533: Structured Concurrency (Seventh Preview)
38:21 JEP 537: Vector API (Twelfth Incubator)
40:28 Looking forward to Java 28 and Project Valhalla
42:31 JEP 401: Value Objects and JEP 539: Strict Field Initialization
47:36 Can we expect this to be finalized in Java 29?
48:26 LTS releases every 1, 2, or 3 years?
49:55 JEP 541: Deprecate macOS/x64
51:53 JEP 540: Simple JSON API (Incubator)
55:30 Conclusion, what to remember from the 28 release

Episode 100 of the Foojay Podcast. No grand plan. It just happened.
To mark the milestone, Frank turned the microphone around and invited other podcasters: Adam Bien (airhacks.fm), Jennifer Reif (Breaktime Tech Talks), Kadi McKean and Steve Pool (10xInsights), and Oumaima Zerouali (JCast). Same questions for each: why did you start, what broke, and what did you learn?
Along the way: why a no-prep podcast works when you have 20 years of experience, the difference between writing a blog and recording a podcast, burnout from editing, AI tools that changed someone's voice into Batman, and why a Dutch Java podcast about the human side of development got its first episode from a calendar invite that became a recording.

Guests:
Adam Bien — airhacks.fm
Jennifer Reif — Breaktime Tech Talks
Kadi McKean and Steve Pool — 10xInsights
Oumaima Zerouali — JCast

Links:
airhacks.fm on Spotify
Breaktime Tech Talks on Spotify
10xInsights | 10xInsights on Spotify
JCast
Foojay Podcast #67: Writing a book. Does it make you rich and famous?
Foojay Podcast #71: 30 Years of Java with James Gosling
Foojay Podcast #99: Testing the Untestable: LLM Security for Java Developers with Tiberius
Frank on JCast
Other podcasts mentioned:
Spring Documentary

Content:
00:00 Introduction
01:00 Adam Bien (airhacks.fm)
12:52 Jennifer Reif (Breaktime Tech Talks)
26:25 Kadi McKean and Steve Pool (10xInsights)
38:43 Quote by James Gosling
39:46 Oumaima Zerouali (JCast)
48:01 Conclusion

Hosted by Frank Delporte | foojay.io

Your Java AI application is live in production. But have you tested whether it can be jailbroken, manipulated into revealing its system prompt, or tricked into printing content it should never output?
In this episode, Iryna Dohndorf, Software Engineer at Karakun Group and creator of Tiberius, explains how to bring security testing to LLM-powered Java applications. We cover why traditional unit tests break down with non-deterministic systems, how the Scan-Fixture-Validate workflow works, what buff mutation testing is, and why even well-trained models can be cracked with something as simple as the grandmother attack.
Topics include:
Why LLM non-determinism breaks the classic input/output test model
The Scan-Fixture-Validate principle and sharing test artifacts across teams
Prompt injection, jailbreaks, and emotional manipulation attacks
Buff mutation: testing linguistic surface coverage
Probabilistic security contracts and multi-trial scans
Fingerprinting and why your model choice should not be detectable
LLM as a judge: using a second model as a guardrail
Getting started with Tiberius in Spring Boot and LangChain4j
Guest
Iryna Dohndorf - Software Engineer at Karakun Group
LinkedIn
Links
Article on Foojay
Tiberius on GitHub
Security Testing Guide
Timestamps
00:00 Introduction of topic and guest
01:05 The problem Tiberius wants to solve
06:39 How "traditional" unit tests don't work for LLM integrations
10:23 Scan-Fixture-Validate principle and sharing artifacts
15:15 Using different skills, for example, the grandmother skill
17:33 Testing for required versus forbidden bias
19:35 The probes across nine attack categories used by Tiberius
20:44 Buff mutation testing
26:55 Using Tiberius in your pipelines and when to fail
29:35 Using multi-trial scans
31:14 Fingerprinting: which model you use, should not be detectable
32:55 Combining multiple models, model as a judge
34:41 Sharing JSON models to improve tests
36:05 How to get started with Tiberius in Spring and with LangChain4j
36:41 Quarkus not supported yet, plans for the future
39:07 Conclusions and a call out to everyone to become a Foojay author

WebAssembly is already running inside Java applications, but most developers just don't know it yet.
In this episode, Andrea Peruffo walks us through how WebAssembly is becoming the modern, safe alternative to JNI. Run Rust, C, and other native libraries directly on the JVM, without the crash risks, per-platform packaging headaches, or the observability blackhole that JNI creates.
From JRuby's Prism parser to SQLite and full Postgres running as pure Java bytecode, the use cases are real. And the project making it possible, Endive, under the Bytecode Alliance, is open and ready to explore.
Guest
Andrea Peruffo
GitHub: https://github.com/andreaTP/
LinkedIn: https://www.linkedin.com/in/andrea-peruffo-32269178/
Bluesky: https://bsky.app/profile/andreatp.bsky.social

Links

A New Generation of Java Libraries: Wasm Becomes the Implementation Detail

Chicory on GitHub

Endive on GitHub

Endive documentation

Bytecode Alliance

OpenJDK Project Detroit
Timestamps
00:00 Introduction of topic and guests
00:56 What is WebAssembly?
03:35 Comparing the performance with JavaScript
05:45 JRuby already uses WebAssembly
09:04 JNI versus FFM API versus WebAssembly
13:58 Other Java-related tools that use WebAssembly
17:56 History of the Chicory and Endive projects to bring WebAssembly to Java
21:03 Projects of the Bytecode Alliance
22:02 The Endive project as the glue to bring WebAssembly tools to Java
23:30 Integration of the Redline compiler
28:59 Why this is the perfect solution to modernize existing Java applications
31:18 Is this approach performant?
32:24 What future changes in Java and the JVM will make this even better
35:04 How Endive can be used in AI development
37:28 What to expect in Endive
41:29 Conclusions

BoxLang is a modern dynamic JVM language built for rapid application development. It's 100% Java-interoperable, compiles to JVM bytecode, and deployable anywhere from OS to AWS Lambda to Spring Boot. In this episode, we sit down with Luis Majano (CEO of Ortus Solutions and creator of BoxLang) and Cristobal Escobar (BoxLang community manager) to dig into the wave of innovation that has hit the platform over the past few months.

We cover the BoxLang AI v3 release, a major overhaul that ships multi-agent orchestration with parent-child hierarchies, an AI Skills system based on Anthropic's open standard, MCP server integration (both consuming and serving), a composable middleware layer with six built-in classes including a FlightRecorder for deterministic CI testing, and a unified API spanning 17 AI providers. Luis and Cristobal walk us through the highlights of a 7-part BoxLang AI deep dive series, covering tools, memory systems & RAG, streaming, middleware, and MCP. We also touch on the BoxLang Spring Boot Starter, BoxLings (an interactive TDD/BDD learning platform), and TestBox 7's real-time streaming test runner.

Whether you're a Java developer curious about dynamic JVM languages, an AI engineer looking for a productive alternative to Python-based agent frameworks, or just want to see what the JVM ecosystem can do in 2026, this episode is for you.

Guests
Luis Majano
Foojay author page
LinkedIn
Cristobal Escobar
Foojay author page
LinkedIn
Links
On the BoxLang website:
BoxLang docs
BoxLang AI docs
BoxLang Academy
BoxLang for desktop applications
BoxLang Spring Boot Starter
BoxLings
Announcing MatchBox Open Beta: BoxLang, Now Running in New Places
Try BoxLang
On Foojay:
Overview of all recent BoxLang AI articles: Complete Guide to Building AI Agents
BoxLang AI v3 Has Landed
BoxLang AI Deep Dive series, Parts 1–7
How to Develop AI Agents Using BoxLang AI: A Practical Guide
Introducing the BoxLang Spring Boot Starter
Introducing BoxLings!
Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Content
00:00 Introduction of topic and guests
01:17 What is BoxLang and how to use it
05:25 Multi-runtime (WASM) with MatchBox, based on Rust
07:00 Combining BoxLang with Spring Boot
10:40 The abstraction approach in BoxLang AI, compared with LangChain4j and others
14:18 Markdown skill files similar to Claude are also used in BoxLang AI
15:21 About the 7-part Foojay BoxLang Deep Dive posts series, agents, event-driven,...
19:28 BoxLang can be used for MCP server and client
23:01 Premium features in BoxLang and building a company on an open-source project
27:52 BoxLings, an interactive learning tool for BoxLang that teaches TDD and BDD
30:25 TestBox 7, real-time streaming test execution and a browser-based IDE
32:58 How to get started with BoxLang?
34:14 How the evolutions in the JVM and Java language influence BoxLang development
39:33 Which article to read first on Foojay about BoxLang?
43:27 More learning resources and ideas for the future and desktop development
48:05 Conclusions