Java on Ron's Tech Blog

Java 27 - JEP 537 - Vector API, Twelfth Incubator

Tue, 28 Jul 2026 00:00:00 +0000

A look at what the Vector API is actually for, and why it's still incubating after twelve rounds.

Java 27 - JEP 538 - PEM Encodings of Cryptographic Objects (Third Preview)

Mon, 20 Jul 2026 00:00:00 +0000

The PEM API's third preview lands in JDK 27 with real API polish and no more excuses to hand-roll PEM parsing yourself.

Spring AI Series: 7-Advisors

Sat, 18 Jul 2026 00:00:00 +0000

Advisors are Spring AI's interceptor layer. Learn how the advisor chain works, then build up logging, sanitizing, and blocking advisors to guard BrightCart's support tickets.

Spring AI Series: 6-Tool Calling

Fri, 10 Jul 2026 00:00:00 +0000

Give the model hands. Let BrightCart's classifier call real Java methods to look up live order data from a database, and learn how the tool-calling loop actually works.

JEP 536 - JFR In-Process Data Redaction

Mon, 06 Jul 2026 00:00:00 +0000

Learn how JDK Flight Recorder now redacts secrets from command-line arguments, environment variables, and system properties before they ever hit disk.

Spring AI Series: 5-Structured Outputs

Fri, 03 Jul 2026 00:00:00 +0000

Turn free-text LLM responses into typed Java objects — enums, records, lists, and maps — and give BrightCart a ticket classifier you can actually route on.

JEP 534: Compact Object Headers by Default

Mon, 29 Jun 2026 00:00:00 +0000

JEP 534 makes compact object headers the default in JDK 27, shrinking every object from 12 to 8 bytes and handing you 10–20% heap savings without touching a line of code.

Spring AI in Depth - 4 - Prompt Engineering

Fri, 26 Jun 2026 00:00:00 +0000

Move from hardcoded prompt strings to maintainable PromptTemplates — with variables, few-shot examples, and externalized prompt files — in BrightCart's support system.

JEP 533 - Structured Concurrency Gets Sharper in JDK 27

Tue, 23 Jun 2026 00:00:00 +0000

If you’ve been following the evolution of Project Loom, you’ll know that Structured Concurrency has been on quite a journey. It started as an incubator module in JDK 19, became a preview API in JDK 21, and has now re-previewed five more times since — JDK 22, 23, 24, 25, and 26. JEP 533 is the seventh preview, targeting JDK 27, and this time the changes are meaningful enough that it’s worth taking a proper look.

Spring AI Series: 3-ChatClient

Fri, 19 Jun 2026 00:00:00 +0000

Learn the ChatClient fluent API inside out — prompts, defaults, model options, response metadata, and streaming — while building the first endpoint of a real support ticket system.

Java 27 - part 4: JEP 532 - Primitive Types in Patterns

Mon, 15 Jun 2026 00:00:00 +0000

Same Feature, Fifth Time Around

If you read my JEP 530 post at the tail end of the Java 26 series, this one is going to feel familiar. Very familiar.

JEP 532 is the fifth preview of “Primitive Types in Patterns, instanceof, and switch”, now targeting JDK 27. And here’s the honest headline: nothing has changed. No new syntax, no removed methods, no behavioural tweaks. The JDK team looked at JEP 530, decided it was in good shape, and re-proposed it as-is to bake for another release cycle.

Spring AI Series: 2-Setup Spring AI

Fri, 12 Jun 2026 00:00:00 +0000

Learn to setup a Spring AI project and understand how it works.

Spring AI Series: 1-Introduction to Spring AI

Sat, 06 Jun 2026 00:00:00 +0000

Learn what Spring AI is, how it fits into the Spring ecosystem, and get your first chat response in a handful of lines of Java.

Java 27 - part 3: JEP 531 - Lazy Constants, Round Three

Wed, 27 May 2026 00:00:00 +0000

Third Time’s the Charm: Lazy Constants Get a Trim and a New Trick

Back in the Java 26 series, I walked you through JEP 526 and the (then) second preview of the Lazy Constants API. If you missed it, the short version is this: Java finally got a clean way to do deferred immutability — fields that initialize on demand but, once set, are treated by the JVM as if they’d been hard-coded constants. No more double-checked locking. No more holder idioms. Just LazyConstant.of(...) and a .get().

Java 27 - part 1: JEP 523 - G1 Becomes the Default Everywhere

Fri, 22 May 2026 00:00:00 +0000

G1 Garbge Collector, Always.
If you’ve ever wondered which garbage collector the JVM actually picked for you when you didn’t tell it which one to use, the answer was always a little annoying: “well, it depends.”

That “it depends” is exactly what JEP 523, targeting JDK 27, gets rid of. From now on, when you don’t specify a collector on the command line, the JVM always picks G1. No exceptions, no hardware-dependent surprises. Let me walk you through what’s changing and — more importantly — whether you should care.

Java 27 - part 2: JEP 527-Post-Quantum Hybrid Key Exchange for TLS 1.3

Sun, 15 Mar 2026 00:00:00 +0000

Java 26 has just been released! (depending on your timezone), but work on Java 27 is already on the way. The first JEP of the new release is JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3.

JEP 527 (Post-Quantum Hybrid Key Exchange for TLS 1.3) is a Java enhancement designed to protect your internet communications from future quantum computers.

Here is the breakdown in easy terms:

1. The Problem: “Harvest Now, Decrypt Later”

Today, when you connect to a website (using HTTPS/TLS), the “key exchange” that secures your connection uses math (RSA or Elliptic Curve) that is very strong for current computers but could be cracked by a powerful quantum computer in the future.

Java 26 - part 10: JEP 530 - Pattern matching for primitives

Fri, 06 Mar 2026 00:00:00 +0000

Java Pattern Matching: The Missing Piece (JEP 530)

We have reached the 10th and final JEP of the Java 26 series.

If you’ve been following Java for the last few years, you know the language has been on a massive “glow-up” journey. It was Project Amber that brought us records, sealed classes, and pattern matching. And this last one has been the stars of the show. It started as a way to stop writing those annoying casts after an instanceof, and it’s grown into a powerful tool for data-driven code.

Java 26 - part 9: JEP 529 - Vector API

Thu, 05 Mar 2026 00:00:00 +0000

Java’s Vector API: The Marathon Continues (JEP 529)

The Vector API is a new addition to the Java standard library that allows you to perform vector operations on arrays in a single CPU cycle. If there were a Guinness World Record for the “Longest Incubating Feature in Java History,” the Vector API would be holding the trophy. With the arrival of JEP 529, the Vector API is entering its 11th round of incubation in JDK 26.

Java 26 - part 8: JEP 526 - Lazy Constants

Sun, 01 Mar 2026 00:00:00 +0000

Bye-Bye Boilerplate: Say Hello to Java’s New “Lazy Constants” If you’ve ever had to initialize a heavy object only when it’s actually needed, you know the drill. You probably reached for the “Double-Checked Locking” pattern (which is easy to mess up) or the “Initialization-on-demand Holder” idiom (which is verbose).

JEP 526 (Lazy Constants), coming as a second preview in JDK 26, is here to retire those old hacks. It introduces a first-class way to handle deferred initialization that is thread-safe, easy to read, and—best of all—lightning fast.

Java 26 - part 7: JEP 525 - Structured Concurrency

Thu, 26 Feb 2026 00:00:00 +0000

The “No More Thread Leaks” Update: Java’s Structured Concurrency (JEP 525) If you’ve ever written concurrent Java code using ExecutorService, you know it can feel like herding cats. If one task fails, the others just keep running in the background like zombies, eating up resources and making debugging a nightmare.

Structured Concurrency is here to fix that. It treats a group of related tasks as a single unit of work. If the main task is cancelled or fails, all its sub-tasks are automatically shut down. No leaks, no orphans, no headaches.

Java 26 - part 6: JEP 524 - PEM Encodings of Cryptographic Objects

Thu, 12 Feb 2026 00:00:00 +0000

If you have ever had to read a private key or a certificate from a file in Java, you know the pain. You probably wrote a utility method that manually stripped out the —–BEGIN… header, removed newlines, and performed a Base64 decode, only to feed it into a KeyFactory. It felt like hacky string manipulation for something that should be standard.

The Gist: This JEP, and its predecessor JEP 470 in Java 25, introduces a standardized, easy-to-use API for encoding and decoding PEM (Privacy-Enhanced Mail) files. Instead of using third-party libraries (like Bouncy Castle) or writing brittle string replacement code, you can now parse keys and certificates natively.

Java 26 - part 5: JEP-522 Turbocharging G1 with 'Double Buffering'

Mon, 02 Feb 2026 00:00:00 +0000

If you run Java in production, you are likely using the G1 (“Garbage First”) Garbage Collector (it’s the default, after all). In Java 26, G1 is getting a significant “free” performance boost—estimated at 5–15% better throughput—without you changing a single line of code.

This is one of those JEPs that does its work silently in the background (literally), but it’s implications are so significant that it deserves a blog post.

Java 26 - part 4: JEP 517 HTTP/3 is Finally Here (Natively)!

Thu, 29 Jan 2026 00:00:00 +0000

If you’ve been waiting for Java to catch up with the modern web, the wait is over. Java 26 updates the java.net.http.HttpClient (the one we’ve loved since JDK 11) to officially support HTTP/3.

Here is an example of how to use the API

1
2
3
4
5
6
7


var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder(URI.create("https://openjdk.org/"))
 .GET()
 .build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
assert response.statusCode() == 200;
String htmlText = response.body();

Why should you care? HTTP/3 isn’t just a version bump; it swaps out TCP for QUIC (built on UDP). This is a big deal for performance because it solves “head-of-line blocking”—where one lost packet holds up the entire line of data. It basically means faster handshakes and much more reliable connections, especially if your users are on flaky networks with high packet loss.

Java 26 - part 3: JEP 516 Ahead-Of-Time Object caching with any GC

Tue, 20 Jan 2026 00:00:00 +0000

JEP 516: Having Your Cake (Fast Startup) and Eating It Too (Low Latency)

I have become a greater fan of Project Leyden with every deliverable it produced. I admit, I was sceptical when Chief Language Architect Brian Goetz announced Project Leyden. It felt as if some answer was needed after the arrival of GraalVM and its native images, that had a blistering startup speed. But how could we ever increase the startup of the JVM? Turns out, there are quite of few possibilities.

Java 26 - part 2: JEP 504 Remove the Applet API

Sat, 17 Jan 2026 00:00:00 +0000

Goodbye, Applets! (For Real This Time)

If you’ve been doing Java for a while, you probably remember the “good old days” of running Java in the browser. One day, I was visiting London, from Amsterdam, and I bought my first Java book. This was in de the days before you buy anything at Amazon. The book introduced me to applets for the first time. Must have been around the time of Java 1.2, so we’re talking about 1998. Fast forward to a few years later and I had a girlfriend who was studying in IT. One of her assigments was to create a functioning chess application, running in a browser via an applet. Did we have fun writing that applet. Or least, I had fun. Well, those days of Applet-Chess are over, JEP 504 in Java 26 is finally cleaning house by permanently removing the Applet API.

Java 26 - part 1: JEP 500 Prepare Final Mean Final

Mon, 29 Dec 2025 00:00:00 +0000

When you have been writing Java for a while, you may have noticed that you are writing final a lot. You typically use it when defining class or instance variables. In those situations the compiler will ensure that you assigned a value to it before the class constructor completes. Or you could use it with parameters to indicate that the values of these parameters should not be tinkered with.

It is Java’s version of defining a constant. Or at least, that is what we have been thinking. But in real life, a final variable can be changed. Take a look at the following example:

Java 26

Thu, 25 Dec 2025 00:00:00 +0000

We’ve only just seen the release of Java 25, the latest LTS version of the popular language. But on March, 17st, the next iteration of the Java language, Java 26, will be launched.

What is in there?

Java 26 will be made up of 10 Java Enhancement Proposals. Here is a short summary. In the coming weeks, I will talk about each of these in more detail on this site.