Coder Legion - Recent posts tagged java25

Oracle reveals why Python notebooks won't run your enterprise AI - and what will.

Tue, 14 Oct 2025 22:22:19 +0000

Java's Real AI Strategy: Beyond the Hype at Oracle AI World

At Oracle AI World, the Java team delivered a message that cuts through the AI hype: 95% of enterprise AI integration projects fail. The reason? Organizations are trying to build production systems on technologies designed for experimentation.

The Python Reality Check

Rod Johnson, creator of the Spring Framework, asked a DevOps Week audience a pointed question: "How many of you think enterprises will run on Jupiter notebooks in the future?" Silence. "How many enterprise Python applications do you have?" Zero. "What's the right number?" Also zero.

This isn't anti-Python sentiment. It's acknowledging what Python excels at, data science experimentation, versus what enterprises actually need for production AI systems: maintainability, security, and scalability at enterprise scale.

Why AI Integration Projects Fail

Paul Sandoz's keynote on Java and AI identified the core problem: AI has succeeded primarily as a personal assistant, not as discrete services handling specific intelligent functions within enterprise applications.

The solution isn't trying to boil the ocean. It's building small, discrete AI components with clear areas of responsibility; probably using smaller models, possibly local models. This aligns perfectly with Java's architectural strengths.

Microsoft's agentic AI teams are saying the same thing: identify specific business problems and solve them with focused agents, rather than attempting comprehensive AI transformations.

Structured Concurrency: The Real Story

Structured Concurrency is in its fifth preview, and developers want to know why. The answer reveals Oracle's approach to platform stability.

Virtual threads introduced edge cases that needed addressing. Java 25, as the first LTS release with broad virtual thread adoption, provides the testing ground for real-world usage patterns. The team expects significant production deployment as organizations migrate workloads to the LTS version.

The complexity they're solving isn't trivial: when you have hundreds of thousands of virtual threads and one throws an error, how do you propagate that error correctly? How do you ensure clean shutdown without thread leaks?

Bernard Traversat, Vice President, Software Development - Java Platform, emphasized the conservative approach: "Once those APIs are in the platform, you have to support them for the next 30 years. If we make mistakes, that's inefficient."

Foreign Function Memory: The Game Changer

The feature seeing real production adoption for AI workloads is Foreign Function & Memory (FFM) from Project Panama. Available since Java 22, FFM makes the integration trick that previously required Python significantly easier - and more maintainable and secure.

Library developers are moving swiftly to adopt FFM. This enables Java applications to interact with native AI libraries without the brittleness of JNI or the overhead of spawning Python processes.

Performance Without Code Changes

The team revealed impressive real-world results: applications moving from Java 21 to 25 are seeing 10-40% performance improvements in memory footprint alone. Over five years, Java runtime performance has essentially doubled - without changing or recompiling code.

Compact Object Headers (JEP 519) compresses object metadata from 96 bits to 64 bits, delivering 30-40% memory reduction in realistic workloads. This isn't theoretical - it's measurable improvement on production applications.

The team describes it as "Java runtime Moore's Law" - continuous performance improvement with zero code changes.

The Compact Source Files Philosophy

The decision to introduce compact source files sparked debate about whether Java should prioritize beginner accessibility over explicit verbosity. Georges Saab's, Senior Vice President, Software Development, Java Platform Group at Oracle, response clarifies the design philosophy: "We're not forcing anyone to do anything."

Like the var keyword, compact source files provide options. Some developers embrace them, others don't. The key is giving developers choice without mandating style.

The value extends beyond education. Advanced developers are discovering that "programming in the small" - writing quick utilities and scripts - benefits from reduced ceremony. Chad Arimura noted that even experienced developers appreciate simpler syntax for throwaway code that might grow into something substantial.

The Python Generation Problem

Java developers are aging, but the College Board partnership only addresses students. What about the 25-40 year olds who learned Python first?

The team sees a pattern: developers start with Python because it's cool, then hit scalability and collaboration walls. They discover Java has solved these problems for years. As James Governor famously said: "When web shops grow up, they become Java shops."

The team heard from developers who built systems in Python, struggled with scale, and found Java's mature ecosystem provided solutions they thought were universal problems. The combination of Java's proven reliability and modern features creates a compelling migration path.

Post-Quantum Crypto: Methodical Progress

Donald Smith, Vice President of Product Management at Oracle, outlined Oracle's PQC strategy, drawing parallels to TLS 1.3 introduction. Between 2013-2014, hash collisions and rainbow tables exposed cryptographic weaknesses. TLS 1.3 emerged, but Java 8 (released 2014) needed backward compatibility.

Oracle built robust TLS 1.3 implementation, tested extensively, then backported when standards finalized. They're following the same playbook for PQC: build quantum-resistant foundations from the bottom up, follow standards bodies closely, and deliver when specifications are solid.

Java 26 or 27 will likely include post-quantum TLS implementation - possibly without requiring preview status because it'll integrate as normal TLS configuration. This approach protects enterprise investments while preparing for quantum threats.

Valhalla: Past the Peak of Complexity

Project Valhalla has frustrated developers waiting years for value types. Bernard Traversat acknowledged the timeline but provided concrete progress: the team reached what Brian Goetz calls "the peak of complexity" and found a simpler path.

Early implementations delivered desired capabilities but with massive complexity. Over the past 18 months, the team has been simplifying, moving complexity from the VM into the upper stack.

Expect early access builds in the next couple of months covering all preliminary features. The team wants these features integrated early in the release cycle to maximize stabilization time before finalization.

Integrity by Default: The Unsexy but Critical Work

Georges Saab highlighted "Integrity by Default" - an initiative that won't generate excitement but provides tremendous enterprise value.

As systems grow larger and more complex, reliability becomes non-negotiable. Java's approach: eliminate unsafe APIs, strengthen encapsulation through the module system, restrict deep reflection, and make final actually final.

Bernard emphasized that Java provides security capabilities no other runtime in the industry offers. You can protect cryptographic libraries by controlling which code can call specific APIs - runtime enforcement of security boundaries.

AI Coding Assistants and Java Design

When asked if AI coding assistants influence language design, the team noted that Java's fundamental design principles align well with AI-generated code. Strong typing, clear structure, and readable syntax make Java ideal for both AI generation and human comprehension.

The resurgence of Java in the AI era might seem counterintuitive, but it reflects a reality: AI removes complexity barriers that once scared developers away from Java. Combined with modern features, Java becomes the logical choice for production AI systems.

The Bottom Line

Oracle's AI World message: Java isn't just surviving the AI revolution - it's positioned to thrive. While Python dominates experimentation, Java dominates production. The gap between prototype and production-ready AI systems is where Java's 30 years of enterprise experience becomes invaluable.

The team's methodical approach - conservative API design, extensive testing, thoughtful evolution - might seem slow compared to the AI hype cycle. But enterprises building systems expected to run for decades need exactly this approach.

Java 25's LTS status, combined with real performance improvements and AI-focused features, positions the platform for the next wave of enterprise AI adoption. Not the flashy demos, but the unglamorous work of running reliable AI systems at scale.

Oracle delivers 18 features to eliminate frustrations and streamline everyday coding tasks.

Tue, 16 Sep 2025 19:42:00 +0000

Java 25: Proof the Development Team Actually Listens to Developers

Java 25 represents a masterclass in listening to developer feedback. After analyzing years of community requests, Oracle has delivered 18 JDK Enhancement Proposals that directly address the pain points developers face daily.

The "Finally!" Moments

No More Boilerplate Hell

JEP 512: Compact Source Files eliminates the ceremony that's frustrated beginners and annoyed experienced developers writing small utilities:

Before:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

After:

void main() {
    IO.println("Hello World!");
}

This isn't just about beginners. Senior developers constantly write small scripts, command-line tools, and proof-of-concept code. The old ceremony was pure friction.

Import Sanity at Last

JEP 511: Module Import Declarations solves the "where the hell is that class?" problem:

Before:

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;
// ... 15 more imports

After:

import module java.base;
// Done. Everything you need is available.

This is particularly valuable when prototyping with AI libraries or integrating multiple frameworks.

Primitive Types Finally Work Everywhere

JEP 507: Primitive Types in Patterns (Third Preview) eliminates the arbitrary restrictions that made pattern matching feel incomplete:

switch (value) {
    case int i when i > 1000 -> handleLargeInt(i);
    case double d when d < 0.01 -> handleSmallDouble(d);
    case String s when s.length() > 100 -> handleLongString(s);
    default -> handleDefault(value);
}

AI inference code becomes dramatically cleaner. No more boxing primitives just to use pattern matching.

Performance Wins That Actually Matter

Memory Footprint Reduction

JEP 519: Compact Object Headers reduces object headers from 128 bits to 64 bits on 64-bit systems. This isn't theoretical - it's a measurable reduction in memory usage for real applications.

Chad Arimura showed a Helidon upgrade from Java 21 to 25 that delivered 70% performance improvement with zero code changes. That's the JVM doing heavy lifting so you don't have to.

Startup Speed Improvements

JEP 514 & 515: Ahead-of-Time Optimizations tackle the cold start problem that's plagued Java in cloud environments:

JEP 514: Simplifies AOT cache creation
JEP 515: Shifts profiling from production to training runs

Your containers start faster. Your serverless functions respond quicker. Your CI/CD pipelines run shorter.

AI Development Made Practical

Structured Concurrency That Actually Works

JEP 505: Structured Concurrency (Fifth Preview) addresses the "thread soup" problem in AI applications:

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    var modelInference = scope.fork(() -> runModel(input));
    var dataPreprocessing = scope.fork(() -> preprocessData(rawData));
    var validation = scope.fork(() -> validateInput(input));
    
    scope.join();           // Wait for all
    scope.throwIfFailed();  // Clean error handling
    
    return combineResults(
        modelInference.resultNow(),
        dataPreprocessing.resultNow(),
        validation.resultNow()
    );
}

If any task fails, all tasks are cancelled cleanly. No thread leaks. No hanging operations.

High-Performance Vector Operations

JEP 508: Vector API (Tenth Incubator) provides SIMD operations that actually work:

var a = FloatVector.fromArray(SPECIES, array1, 0);
var b = FloatVector.fromArray(SPECIES, array2, 0);
var result = a.mul(b).add(bias).toArray();

This compiles to optimal vector instructions on supported hardware. Essential for any serious AI work.

JEP 506: Scoped Values replaces ThreadLocal with something that actually works with virtual threads:

static final ScopedValue<UserContext> USER_CONTEXT = ScopedValue.newInstance();

// Set once, use everywhere in the scope
ScopedValue.where(USER_CONTEXT, currentUser)
    .run(() -> processRequest());

Lower memory overhead, better performance, and it actually works correctly with millions of virtual threads.

Security That Doesn't Get in Your Way

Post-Quantum Cryptography Building Blocks

Oracle's PQC strategy is methodical and practical:

JEP 510: Key Derivation Function API - Now final, provides quantum-resistant foundations
JEP 470: PEM Encodings - Preview API for modern authentication systems

The approach mirrors how Oracle introduced TLS 1.3 - build it right at the tip, then backport when standards are final.

Better Monitoring Without Overhead

JEP 509, 518, 520: Enhanced JFR provides production-ready monitoring:

More accurate CPU profiling on Linux
Cooperative sampling that doesn't impact performance
Method timing and tracing for finding bottlenecks

You can finally profile production systems without fear.

The Ecosystem Responds

The Java ecosystem has noticed. Major frameworks are embracing Java 25 features:

Langchain4j: Hit 1.0 GA with virtual threads and agentic mode
Spring AI: 1.0 GA with enhanced model integration
Embabel: New agentic framework designed for modern Java

These aren't toy projects - they're production-ready frameworks built by teams who understand how developers actually work.

Developer Tooling That Works

VS Code Extension Excellence

Oracle's Java extension for VS Code has 3.8 million downloads and a perfect 5.0 rating. It supports:

Early access builds
Preview features with explanations
Immediate support for new JDK features
Integration with AI coding assistants

The tight integration between language designers and tooling teams shows. You get support for new features the day they're available.

Interactive Learning

The Java Playground at Dev.java lets you:

Test features without installation
Share code snippets via links
Experiment with early access builds
Learn interactively

Teachers can create exercises and distribute them instantly. No more "works on my machine" problems in computer science courses.

Real-World Impact

College Board Partnership

The AP Computer Science A exam now uses modern Java. Students learn current syntax, not legacy patterns. This matters because it means new developers enter the workforce with modern Java skills.

Enterprise Adoption Patterns

Oracle's "tip and tail" release model lets enterprises:

Tip users: Get new features immediately
Tail users: Stay on LTS with stability

Java 25 is the next LTS release with 8 years of support. Enterprises can upgrade on their timeline while developers get immediate access to new features.

The Developer Experience Difference

Java 25 eliminates friction at every level:

Beginners: Can write useful programs without understanding complex concepts
Scripters: Can write command-line tools without ceremony
AI developers: Get first-class support for parallel processing and vector operations
Enterprise developers: Get better performance and monitoring without code changes

Looking Forward

The draft JEP for Post-Quantum Hybrid Key Exchange in TLS 1.3 shows Oracle's forward-thinking approach. They're building quantum-resistant capabilities now, before the standards are final. When quantum computers become a threat, Java applications will be ready.

Why This Matters

Java 25 proves that the development team actually listens. Every major feature addresses real developer pain points:

Verbose syntax? Fixed with compact source files
Import complexity? Solved with module imports
Pattern matching limitations? Eliminated with primitive type support
Memory overhead? Reduced with compact object headers
Cold start problems? Addressed with AOT optimizations
AI development challenges? Handled with structured concurrency and vector APIs

This isn't feature bloat. It's surgical improvement of the developer experience.

The Java team has demonstrated something rare in enterprise software: they understand how developers actually work and they're willing to make substantial changes to improve the experience.

Java 25 drops September 16th. The improvements are real, measurable, and immediately useful. After 30 years, Java is still evolving to meet developer needs.