Old Dog, New Tricks: The Java 25 Reinvention

Modern Java has evolved into a powerful, expressive language by quietly adopting the best ideas from its peers without compromising its core principles of readability, safety, and performance. In this talk, we'll explore how Java 25 now competes head-to-head with languages like Kotlin, Scala, Rust, and Go.

- Pattern Matching that's as expressive as Scala and Rust
- Virtual Threads, Java's lightweight concurrency mode, inspired by goroutines
- Structured Concurrency for safer, more predictable parallel programming
- Records for concise and immutable data modelling, akin to Kotlin's data classes
- Foreign Function & Memory API as a modern, safer alternative to JNI, rivalling Rust’s FFI

If you’ve ever dismissed Java as too verbose or outdated, this session will change your mind. See how Java 25 isn’t just catching up; it’s redefining what modern Java can be.

Transcript

1. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Old Dog, New Tricks The Java 25 Reinvention
2. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Hallway Track Buzz Java's so verbose. A simple data class is 50 lines of boilerplate. We moved our I/O-heavy services to Go for the concurrency model. Java feels like it's always playing catch-up with languages like Kotlin. Why deal with JNI? We just use Rust when we need to call native code. 2
3. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman ? Is Javaʼs evolution a story of … Reaction? or Reinvention? 3
4. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman final class Person { private final String name; private final int age; Person(String name, int age) { ... } String name() { return name; } int age() { return age; } public boolean equals(Object o) { ... } public int hashCode() { ... } public String toString() { ... } } Closing the Expressiveness Gap THEN Ceremony over Intent 4 NOW records → data carriers without boilerplate sealed types → closed hierarchies you can reason about pattern matching → safer, clearer branching
5. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Universal Challenge: Modeling Data with Multiple States The Brittle instanceof Ladder The Weaknesses 5 double area(Object o) { if (o instanceof Circle) { Circle c = (Circle) o; if (c.radius() <= 0) { throw new IllegalStateException(); } return Math.PI * c.radius() * c.radius(); } else if (o instanceof Rectangle) { Rectangle r = (Rectangle) o; if (r.w() <= 0 || r.h() <= 0) { throw new IllegalStateException(); } return r.w() * r.h(); …… } ⚠No Compiler Guarantees: What if a new Shape is added? The compiler won’t tell you what to fix. 🧨Verbose & Error-Prone: Manual casting is required, risking ClassCastException. 🧩Unstructured Logic: Business logic is scattered and hard to follow. Key Takeaway: Modern languages solve this with a powerful, unified pattern: Algebraic Data Types (ADTs).
6. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Scalaʼs Approach: Expressiveness with Sealed Hierarchies Sum & Product Types Exhaustive Pattern Matching 6 sealed trait Shape case class Circle(radius: Double) extends Shape case class Square(side: Double) extends Shape sealed trait: A closed set of types, known at compile time. case class: A concise, immutable data carrier (product type). def getArea(s: Shape): Double = s match { case Circle(r) => math.Pi * r * r case Square(s) => s * s } case Circle(r): Matches the type and deconstructs the data in one step.
7. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Kotlinʼs Approach: Pragmatism with Sealed Classes Sum & Product Types Exhaustive Pattern Matching 7 sealed class Shape data class Circle(val radius: Double) extends Shape() data class Square(val side: Double) extends Shape() sealed class: Restricts inheritance, creating a known, finite hierarchy. data class: Auto-generates boilerplate for data-centric classes. fun getArea(s: Shape): Double = when (s) { is Circle -> Math.PI * s.radius * s.radius is Square -> side * side } is Circle: Type check with smart cast; no else needed due to exhaustiveness.
8. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Rustʼs Approach: Uncompromising Safety with Enums Sum & Product Types Exhaustive Pattern Matching 8 enum Shape { Circle { radius: f64 }, Square { side: f64 }, } enum: A true sum type where each variant can carry its own data. Variants can hold struct-like or tuple-like data. fn get_area(s: Shape) -> f64 { match s { Shape::Circle { radius } => std::f64::consts::PI * radius * radius, Shape::Square { side } => side * side, } } • Matches the variant and binds its fields to local variables. • Exhaustiveness is enforced at compile time.
9. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Javaʼs Solution: A Familiar Syntax for a Modern Pattern Sum & Product Types Exhaustive Pattern Matching 9 sealed interface Shape permits Circle, Square {} record Circle(double radius) implements Shape {} record Square(double side) implements Shape {} Defines a closed hierarchy with an explicit permits clause. An immutable, transparent carrier for data. double getArea(Shape s) { return switch (s) { case Circle(var r) -> Math.PI * r * r; case Square(var side) -> side * side; }; } • Type pattern deconstructs the record, binding its components. • Exhaustiveness is checked at compile time.
10. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Core Guarantee: Compiler-Enforced Completeness 10 Feature Scala Kotlin Rust Java Sealing Mechanism sealed keyword (same file) sealed class / sealed interface (same module) enum is inherently closed sealed with permits clause Missing Case (compile time) Warning (by default) Error (for when expressions) Error (non-negotiable) Error (for switch expressions) Add New Variant (runtime) MatchError exception NoWhenBranchMatch edException N/A (forces recompile) MatchException (fail-fast) Null Handling Throws MatchError Explicit null branch required Impossible (uses Option<T) Explicit case null → pattern The crucial outcome is the same: adding a new data variant turns a potential runtime bug into a compile-time check, making refactoring safe.
11. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Payoff: Readability and Fearless Refactoring 11 • When the data model evolves, the compiler becomes your guide. • Every switch expression that needs an update is flagged as a compile-time error, not a silent runtime bug. • This scales maintainability: you can change core data types with confidence.
12. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman DEMO 12
13. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman But what about performance and scale? Language expressiveness is one half of the story. The other half is how we run our code. 13
14. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Concurrency Dilemma We Lived With 14 Scalability Wall Complexity Trap Thread-per-Request Simple & Debuggable Async / Reactive Scalable & Efficient You were forced to choose: simple code that didnʼt scale, or scalable code that was hard to maintain.
15. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Solution: Lightweight Threads Managed by the JVM 15 Go Goroutines go myFunction() Java Virtual Thread Thread.startVirtualThread(this::myFunction); Virtual Threads OS Threads The programming model, the APIs, and the debugging tools you already know continue to work seamlessly. Executors.newVirtualThreadPerTaskExecutor()
16. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Scale Is Solved: But What About Safety 16 The “Orphaned Task” Problem FAIL t=0 t=1 t=2 t=3 Orphaned tasks. They continue running in the background, consuming resources, holding connections, and polluting logs, even though their results will never be used. // What happens if profile.get() throws an exception? Future<Profile> profile = executor.submit(this::fetchProfile); Future<Preference> prefs = executor.submit(this::fetchPrefs); // This keeps running... Future<Risk> risk = executor.submit(this::fetchRisk); // ...and so does this. Profile p = profile.get(); // 💥 Exception!
17. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Structured Concurrency: If the Parent Fails, the Children Die 17 Pattern # 1: All-or-Nothing Pattern # 2: First-Win Use Case: You need get result from multiple service to build a response Use Case: Racing multiple redundant services for the fastest response try (var scope = StructuredTaskScope.open()) { var profile = scope.fork(this::fetchProfile); var prefs = scope.fork(this::fetchPrefs); scope.join();//wait for all, or fail fast } try (var scope = StructuredTaskScope.open( Joiner.<String>anySuccessfulResultOrThrow())) { scope.fork(() -> fetchFromMirror("mirror-1")); scope.fork(() -> fetchFromMirror("mirror-2")); String fastest = scope.join(); //slowest tasks are automatically canceled } ❌ FAIL ⊗ CANCELLED ⊗ CANCELLED ✓SUCCESS ⊗ CANCELLED ⊗ CANCELLED
18. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman DEMO 18
19. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman JNI The Necessary Evil is No Longer Necessary 19 For decades, integrating Native C/C++ Libraries meant using JNI Complex Unsafe Brittle JNI was the single biggest pain point for Java applications needing high-performance or systems-level capabilities (e.g., AI/ML, low-level I/O.
20. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Native Interop: Reimagined 20 Project Panama provides a safe, pure Java alternative through the Foreign Function & Memory API. Linker linker = Linker.nativeLinker(); SymbolLookup libc = linker.defaultLookup(); MethodHandle strlen = linker.downcallHandle(...); try (Arena arena = Arena.ofConfined()) { MemorySegment str = arena.allocateFrom("Hello FFM"); long len = (long) strlen.invoke(str); } A first-class Java feature with strong safety guarantees and significantly improved ergonomics, approaching Rust’s FFI experience.
21. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman DEMO 21
22. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Java 25, The Best Ideas, Integrated 22 Kotlin-like Expressiveness (record) Go-like Concurrency (Virtual Threads) Scala-like Pattern Matching (sealed, switch) Rust-like Native Interop FFM API …all delivered within Javaʼs stable, mature, and unparalleled ecosystem.
23. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman But Wait, Thereʼs More in Java 23 96 bits 12 bytes) 64 bits 8 bytes) Compact Object Header Ahead-of-Time Class Loading & Linking ZGC: ZGC: Automatic Heap Scaling Stable Values
24. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Evolution, Governed By Principle Long-term bets, not short-term fixes. Readability & Maintainability: Code is read more than itʼs written. Backward Compatibility: Trillions of lines of code canʼt break. World-Class Tooling: IDEs, debuggers, and profilers must keep up. 24
25. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman A Deliberate Evolution, Not a Reaction 25 Modern Language Feature Lightweight Concurrency Native Interop Advance VM Optimization
26. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman The Old Dog Learned New Tricks 🧩 Expressiveness: Records & Pattern Matching match Kotlin and Scala. ⚡ Concurrency: Virtual Threads & Structured Concurrency match Goʼs scale with superior safety. 🌉 Interop: FFM makes native access practical and safe, ending the pain of JNI, match with Rust. 🚀 Performance: Faster startup and execution through constant, JVM-level improvements AOT profiling, compact headers, ZGC. 26
27. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman Java 25 Boringly Powerful 27 Question
28. https://bazlur.ca A N M Bazlur Rahman @bazlur_rahman A N M Bazlur Rahman 28 Java Champion · Sr. Staff Software Engineer · Author of Modern Concurrency in Java · InfoQ Editor https://x.com/bazlur_rahman rokon12 https://www.linkedin.com/in/bazlur/ https://bazlur.ca/ https://bsky.app/profile/bazlur.ca