Lazy Constants

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

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

May 27, 2026 · 4 min
Structured Concurrency

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

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

May 22, 2026 · 5 min
Pattern Matching for primitives

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

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

March 15, 2026 · 4 min
Pattern Matching for primitives

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

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

March 6, 2026 · 4 min
Vector API

Java 26 - part 9: JEP 529 - Vector API

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

March 5, 2026 · 3 min
Lazy Constants

Java 26 - part 8: JEP 526 - Lazy Constants

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

March 1, 2026 · 4 min
Structured Concurrency

Java 26 - part 7: JEP 525 - Structured Concurrency

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

February 26, 2026 · 5 min
PEM Encodings of Cryptographic Objects

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

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

February 12, 2026 · 2 min
G1 GC Double Buffering Throughput Improvements

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

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

February 2, 2026 · 4 min
HTTP/3 support in Java HttpClient

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

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

January 29, 2026 · 2 min