Tagged “softwareengineering”

1. Java 26: Pattern Matching Finally Reaches Primitive Types

   felipestanzani@blog ~ ~ cat "Java 26: Pattern Matching Fi"~ cat post << 03-19-2026

   

   Java has been evolving pattern matching for a while now. We got it for instanceof, then for switch, then for records. Each release pushed the idea a bit further. But there was always an odd limitation:

   Pattern matching worked great — as long as you stayed in the world of objects.

   Primitive types? Not invited.

   With Java 23, that gap is finally gone (as the first preview of this feature). This isn’t a flashy feature. It won’t generate “Java is reinvented” thumbnails. But it fixes something that has felt slightly off for years. In Java 26 we have the fourth preview of this feature, and it something that worth talking about.

   Let’s take a look at what changed — and why it actually matters.

   The Awkward Gap in Pattern Matching

   Before Java 23, pattern matching was strictly tied to reference types.

   Object value = 10;
   
   if (value instanceof Integer i) {
       System.out.println(i + 1);
   }
   

   This works. But it comes with baggage:

   Continue reading...

2. Java 25 After the Hype: 5 Features That Actually Matter

   felipestanzani@blog ~ ~ cat "Java 25 After the Hype: 5 Fe"~ cat post << 03-04-2026

   

   When a new Java version drops, the internet goes through its usual cycle: launch posts, conference talks, YouTube thumbnails screaming “GAME CHANGER,” and LinkedIn hot takes about how everything has changed forever.

   Then reality settles in.

   A few months after the release of Java 25, most teams aren’t rewriting their systems. They’re shipping features, fixing bugs, and trying to keep production stable. That’s when we can finally answer a more interesting question:

   Which Java 25 features are still being discussed and actually used?

   This isn’t a launch recap. This is a “post-hype” filter. Here are five Java 25 features that have proven they’re more than marketing bullets.

   1. Structured Concurrency: Concurrency That Reads Like Logic (preview)

   For years, Java concurrency meant juggling ExecutorService, Future, timeouts, and cancellation semantics that were easy to get wrong.

   Structured Concurrency changes the mental model. Instead of spawning detached tasks and hoping everything is cleaned up properly, you treat concurrent tasks as a single logical unit.

   Before

   ExecutorService executor = Executors.newFixedThreadPool(2);
   
   Future<User> userFuture = executor.submit(() -> fetchUser());
   Future<Orders> ordersFuture = executor.submit(() -> fetchOrders());
   
   User user = userFuture.get();
   Orders orders = ordersFuture.get();
   

   Continue reading...

See all tags .