Java 26 Released: Native HTTP/3, AOT Caching, and More

Java 26 dropped two weeks ago and honestly the Applet API removal hit me with some nostalgia. That thing has been deprecated since JDK 17 in 2021 but seeing it officially gone feels like an era closing. The stuff that matters though: HTTP/3 support baked into the HTTP Client API, value classes from Project Valhalla finally landing, G1 GC getting faster by cutting sync overhead between app threads and GC threads, and ahead-of-time caching now works with any garbage collector including ZGC. If you're running Java in production this is a real startup and throughput upgrade, not just syntax sugar. Anyone already testing 26 in their stack? #Java #JDK26 #Programming #OpenJDK #TechUpdates

After 30 years, JDK 26 officially removes the Applet API. This isn't nostalgia—it's Java embracing its cloud-first, server-side identity and killing off security nightmares from the desktop era. What you'll learn: • Why applets made Java famous in 1995 but never succeeded beyond initial browser hype • Security risks of teams still running applets on JDK 6/7/8 without modern browser support • How browser plugin discontinuation in JDK 11 made applet support obsolete • What legacy code removal signals about Java's commitment to cloud-native and microservices architectures Guest: Simon Ritter, Deputy CTO, Azul "Applets are never going to get used in the cloud. It makes perfect sense to remove the Applet API because nobody in their right mind is going to try to write an applet using JDK 26. There are still plenty of people running applets on older versions of the JDK, but you're really running on a very old system, which you should be looking to move away from because there are issues of security and potential vulnerabilities." In this clip, Simon explains why applet removal reflects Java's evolution from desktop-focused origins to its current server-side, cloud-native dominance. Check out the discussion on our YouTube page: https://lnkd.in/gVsztTCw #AppletAPI #JDK26 #JavaEvolution #CloudNative #ServerSideJava #LegacyCode #Security #EnterpriseJava #Microservices #Azul

Looking for an on-ramp into an open-source JVM project? I've just tagged a batch of issues in #Hardwood, a minimal-dependency Parquet parser for Java, as good first issue and help wanted. Everything from small CLI polish to adding INTERVAL support to documentation improvements. GitHub Discussions is now open too--a good place to ask questions, sanity-check an approach, or share ideas. 👉 https://lnkd.in/e5fjx3XW

Okay Java 26 is actually pretty interesting 👀 I always assumed these releases were just minor patches but the `final` field change alone made me stop and think. How many times have we used reflection to mutate something we shouldn’t have? Java is basically saying, no more. Also HTTP/3 being built in is huge. No more workarounds. It’s not a glamorous release but it feels like the kind of update you thank yourself for 6 months later in production. What’s the one change here you’ll actually use? 👇 #Java #Java26 #SoftwareEngineering

🔮Java is evolving… but not in the way most developers think JDK 26 doesn’t introduce "Attractive" features It fixes some of Java’s oldest problems 👇 🧵 Thread management → Structured Concurrency 🧠 ThreadLocal → Scoped Values ⚡ Heavy threads → Virtual Threads This is not just improvement… This is a shift in how we write Java code. Rather than "what’s new", its important to understand what's improved!!! So, the real question should be: 👉 What actually changed from JDK 21 → 25 → 26? 👉 What problems are being solved? 👉 And how does it impact real-world code? In this blog, I broke it down with: ✔ Clear timelines (when features were introduced) ✔ Before vs After comparisons ✔ Impact of the change 👉 Read the full breakdown here: https://lnkd.in/dhqZ2ziy #Java #JDK26 #JavaDevelopment #BackendDevelopment #Concurrency #SoftwareEngineering #JavaLoom #Programming #Developers

Am I the only one feeling more and more.... idk, lured by Java, those days? Claude takes care of the annoying bits, you get to enjoy the incredible ecosystem it has built over the years... I just saw that Google released "ADK for Java 1.0" last week (Agent Development Kit, basically an SDK to run agents and use all the Google services/models easily), and, uh... idk, one of the major downsides of Java has always been its verbosity... which Claude now takes care of. Java, here I shyly come-ish? I don't wanna admit this to myself.

While building a recent Spring Boot application, I realized... The Hook: Stop defaulting to .parallelStream() to make your Java code "faster." 🛑 The Insight: It’s a common misconception that parallel streams always improve performance. Under the hood, parallelStream() uses the common ForkJoinPool. If you are executing CPU-intensive tasks on a massive dataset, it’s great. But if you are doing I/O operations (like database calls or network requests) inside that stream, you will exhaust the thread pool and bottleneck your entire application. The Pro Tip: Always benchmark. For I/O bound tasks, look into asynchronous programming (like CompletableFuture) or Java 21's Virtual Threads instead of parallel streams. #Java #PerformanceOptimization #SoftwareEngineering #CleanCode

Java just quietly changed how servers handle millions of requests. And most developers haven't noticed yet. I'm talking about Virtual Threads — introduced in Java 21 (LTS). 🧵 Before Virtual Threads: → 1 request = 1 OS thread → OS threads are expensive (~1MB stack each) → 10,000 requests = system struggling → The only fix was reactive programming (complex, hard to debug) After Virtual Threads: → Millions of virtual threads, managed by the JVM → Blocking a virtual thread doesn't block an OS thread → Write simple, readable blocking code — JVM handles the rest → No reactive spaghetti needed How easy is it to use? Thread.ofVirtual().start(() -> handleRequest(req)); Spring Boot 3.2+ supports it out of the box. Set spring.threads.virtual.enabled=true and you're done. This is Project Loom — years in the making. Production-ready right now. If your team is still on Java 8 or 11 — it's time to have that upgrade conversation. Have you tried Virtual Threads yet? Drop your experience below 👇 #Java #Java21 #VirtualThreads #ProjectLoom #BackendDevelopment #SpringBoot

🚀 Think Java Garbage Collection is just “automatic memory cleanup”? Think again. Behind the scenes, Java offers multiple Garbage Collectors, each designed for different performance needs. Here’s a quick breakdown 👇 🔹 Serial GC – Simple, single-threaded (good for small apps) 🔹 Parallel GC – Multi-threaded, high throughput (default in many cases) 🔹 CMS (Concurrent Mark-Sweep) – Low pause times, but now deprecated 🔹 G1 GC (Garbage First) – Balanced performance, predictable pauses (widely used) 🔹 ZGC – Ultra-low latency (pause times in milliseconds) 🔹 Shenandoah GC – Concurrent GC with minimal pause times 💥 Each GC is a trade-off between: 👉 Throughput 👉 Latency (pause time) 👉 Memory footprint ⚡ Quick Tip: Don’t just stick with the default GC. For most modern backend systems, G1 GC or ZGC can significantly improve performance depending on your latency needs. Java isn’t slow… it’s all about how well you tune it. #Java #GarbageCollection #Performance #BackendEngineering #JVM

Over reliance on exceptions is a big performance drain! Easy to overlook. Check out Jonathan Vogel ‘s post for the full list of anti-patterns.