Coder Legion - Recent posts tagged javadevelopment

The Bug That's Been Breaking Software for 40 Years Is Now Breaking Your AI Agents, Too

Tue, 25 Aug 2026 00:00:00 +0000

Picture a Java developer shipping an AI agent into production. The agent gets a prompt and starts working through a task, 50 steps, each one a call to a model like OpenAI or Anthropic, a database write, maybe a few dollars of compute. At step 49 of 50, something fails: a bug, a network blip, an AWS outage, a Kubernetes scale-down mid-run. What happens next, according to Yaron Schneider, CTO and co-founder of Diagrid, is the part nobody budgets for. "The agent is going to need to pick back up all the way from the beginning, and you're going to be paying for all of those LLM calls right from the very beginning," he said. "Which is a great way to go bankrupt."

That failure mode is what Diagrid's new integration, diagrid-spring-ai, is built to close. Announced this week, it brings durable execution to Spring AI, the framework Java developers already use to build agents, without asking them to rethink how they write one.

The same 40-year-old problem, with worse consequences

Schneider doesn't frame this as a new category of failure. It's the same reliability problem distributed systems have always had. "The exact same problems that made software unreliable for the past 40 years are still true for AI agents," he said. "Only with AI agents, the consequences are much bigger." A crashed script used to mean lost time. A crashed agent means lost time and a re-billed stack of model calls, at a cost that scales with however many steps the agent had already completed.

Schneider said the companies Diagrid works with see failures on roughly 30% of production agent runs, on average, not rare edge cases, but a routine cost of running agents at scale.

Zero code changes, by design

The integration's core pitch is unusually low-friction for infrastructure-level tooling. "With Spring AI, literally nothing," Schneider said, when asked what a developer has to change to adopt it. "All you need to do is pull in the package. There is zero code changes. You do not need to recompile your code." Underneath, the integration runs on Dapr Workflow, the open-source project Schneider originally built at Microsoft and later spun into Diagrid, now used by more than 30,000 companies, including over half the Fortune 500 and, notably, NASA.

How it actually avoids re-running side effects

The obvious follow-up question for anyone who's built distributed systems: how do you resume an interrupted agent without re-executing a step that already sent an email or wrote to a database? Diagrid's answer is an immutable ledger. "We keep an immutable record of everything that the agent did. We're essentially journaling," Schneider said. When an agent fails mid-run, the platform reads the journal, recovers the state, exactly what was completed, its inputs, outputs, and memory, and resumes from that point rather than replaying anything already finished.

Schneider was direct about the confidence customers should have in that recovery: "If they're using our technology, they know for 100%, for a fact, that we will always resume where they left off mid-run." He added that customers can and do test this themselves, running failure simulations in their own environments to verify the behavior before trusting it in production.

Why this isn't just a Spring AI feature

A natural question is why durable execution lives as a separate integration rather than something Spring AI ships with directly. Schneider's answer comes down to what a workflow engine actually requires. "Workflow engines are incredibly hard to get right. They require their own separate infrastructure, and Spring is just not that," he said. Bundling a database and deployment model into a lightweight developer framework would hurt adoption, not help it. Building that infrastructure in-house isn't a reasonable alternative either: Schneider pointed to Microsoft's own investment, a team of 15 engineers spending more than $10 million a year maintaining its workflow engine, as a sense of the actual cost most teams would take on trying to solve this themselves.

The claim Schneider thinks is overrated

Asked what's overstated in the broader AI agent conversation right now, Schneider didn't hesitate: model accuracy. "Models are going to continue getting better. They're going to continue being cheaper," he said. "I see a lot of emphasis being put on that instead of, you know, how do you orchestrate multiple agents needing to solve a task and all of them failing at the same time." In his view, the infrastructure problem, keeping agents reliable when things break, is a bigger and less-discussed risk than whatever incremental accuracy gain the next model release brings.

Beyond Spring

diagrid-spring-ai is one piece of a broader set of integrations Diagrid maintains across roughly ten agent frameworks spanning Python, C#, and Java, including LangChain, LangGraph, and CrewAI. Developers can try the platform directly at diagrid.io, where Schneider said quick-start guides let teams test the failure-recovery behavior themselves before committing to it in production.

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.

Oracle unveils Learn.java, simplified syntax, and strategic educational partnerships at JavaOne 2025.

Mon, 12 May 2025 19:04:14 +0000

Bridging the Gap: How Java Is Revolutionizing Developer Education in 2025

As Java approaches its 30th anniversary, Oracle is making significant investments in developer education and onboarding, addressing longstanding criticisms about the language's complexity for beginners. At JavaOne 2025, Oracle announced several initiatives aimed at making Java more accessible to new developers while maintaining the robust capabilities that have made it a cornerstone of enterprise development for decades.

Learn.java: A Dedicated Educational Hub

One of the most significant announcements from JavaOne was the launch of Learn.java, a dedicated website specifically designed for teachers and students. This new platform addresses a key challenge identified by Oracle's developer education team: Dev.java, while comprehensive, was too complex for beginners.

"We split it because we found that Dev.java is a little too complicated for new learners," explained Heather Stephens, Senior Director of Java Education at Oracle. "We want to make sure that we give content at the level that a new learner needs, and often teachers are new learners too, so they need that new learning content as well."

Learn.java offers simplified tutorials, classroom-ready materials, and educational resources that can be leveraged by instructors without being behind a membership wall. This open approach to educational content reflects Oracle's commitment to growing the Java ecosystem by supporting the next generation of developers from their first line of code.

Simplifying Java Syntax for Beginners

Perhaps the most practical change for new developers is the "paving the on-ramp" initiative, which drastically simplifies Java's syntax for entry-level programming. Mark Reinhold, Chief Architect of the Java Platform Group, demonstrated this evolution during the JavaOne keynote by comparing traditional and new approaches to the canonical "Hello World" program.

Traditional approach:

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

New approach with Java 24 features:
void main() {
    println("Hello World!");
}

This transformation eliminates multiple barriers to entry that have historically made Java intimidating to beginners, including:

Removing the need for class declarations
Eliminating public/static modifiers
Simplifying System.out.println() to just println()
Removing the requirement for command-line arguments

"To write your first Java program, you needed to understand 32 distinct principles of object-oriented programming," noted Georges Saab, Senior VP of Java at Oracle. "We just needed to find a way to make it easier."

These simplifications, available as preview features in Java 24, allow newcomers to focus on core programming concepts without being overwhelmed by Java's full object-oriented structure. Importantly, this creates a gradual learning path—students can start simple and incrementally adopt more advanced concepts as they progress.

Strategic Educational Partnerships

Oracle is reinforcing its commitment to education through a strengthened partnership with the College Board, which administers the Advanced Placement Computer Science A (AP CSA) course—a critical entry point for many young programmers in the United States.

At JavaOne, Edward Biederman, Executive Director of the AP Technology Board, discussed how this collaboration will modernize the AP CSA curriculum. While currently using Java 8, the College Board will be updating to newer versions in upcoming revisions, giving students access to more modern language features.

"AP Computer Science contributes 100,000 students to the pipeline of computer science college majors," Biederman noted. "But what if we could double those numbers and expand from 100,000 students, and also teachers and students connected to the latest version of Java?"

This partnership aims to address the need for relevant, engaging examples that connect with students' lives and interests. Heather Stephens emphasized this point: "Kids need examples that are relevant to them, problems they care about, solutions they care about. The code itself we do need to simplify, and if we don't show the relevant examples, they're lost."

Accessible Developer Tools

Beyond curriculum changes, Oracle is making Java more accessible through improved developer tools. The Java Playground (dev.java/playground) allows anyone to run Java code in a browser without downloading or installing anything—removing a significant barrier to entry.

"We found another barrier of entry was just downloading the JDK, getting it to work on your computer," explained Donald Smith, VP of Java Product Management. "So we took the primitives from the JShell API and created the Java playground. Go in, you get a dropdown box, you see different code that you can run, click run, and have it just in front of you."

This browser-based approach aligns with how today's young developers often begin their coding journey—through interactive online environments rather than complex local installations.

Inspiring Creation Through Relevance

A common theme throughout JavaOne's education-focused discussions was the importance of making Java relevant to young people's interests and aspirations. Chad Arimura, VP of Developer Relations, touched on this motivational aspect: "Why is that? For me and for a lot of other people, it's about inspiring them to create. I got into this business because I loved creating things."

Oracle recognized that showing real-world applications of Java in technologies that students already use—like Netflix, Uber, or popular games—can ignite interest and demonstrate the practical power of the language. In an age where AI and short-form content compete for attention, connecting Java to tangible outcomes becomes crucial for engagement.

"Your first question was, what is the biggest challenge? And I would say it's perception," Stephens noted. "Java is amazing, and if they don't know it, if we can't help them see that and make that relevant to them, then it's lost."

The Future of Java Education

Oracle's educational initiatives reflect a profound understanding that the future of Java depends on bringing new developers into the ecosystem. With enrollment in computer science programs reportedly declining at some institutions—partly due to AI-related concerns—Oracle's approach combines:

Simplified syntax for beginners
Accessible browser-based tools
Modernized educational curricula
Real-world examples that resonate with students
Strategic partnerships with educational institutions

These efforts balance Java's strengths as an enterprise-grade, production-proven platform with the need to welcome newcomers through a more intuitive, gradual learning experience. As Scott McNealy, co-founder of Sun Microsystems, reflected during the JavaOne keynote: "Java is still top three in the world 30 years later, and I think it's number one for people doing real work."

Through these educational initiatives, Oracle is ensuring Java remains relevant for generations to come, bridging the gap between the platform's enterprise heritage and the next wave of developers who will shape its future.