Java on JAVAPRO International

Are Classic Design Patterns Still Valid With Modern Java?

Thu, 23 Jul 2026 07:00:03 +0000

The classic GoF design patterns helped developers build maintainable object-oriented software for a long time. In the past years the languages, like Java, have changed a lot; they evolved! What was a design pattern back then became a language feature today. This article analyses which patterns are still needed and which became obsolete.

Once upon a time…

Object-Oriented Programming

Object-oriented programming emerged with the invention of Simula 67. Ole-Johan Dahl and Kristen Nygaard invented Simula 67 while working at the Norwegian Computing Center in Oslo to run simulations. A few years later Alan Kay et al. invented Smalltalk as a purely object-oriented programming language. In the 80s, C++ brought the breakthrough in the mainstream for object-oriented programming. The first large-scale object-oriented systems were developed. In the 90s, object-oriented programming was the dominating programming paradigm.

Lazy Constants in Java 26: Deferred Immutability and JVM Trust

Wed, 22 Jul 2026 07:00:02 +0000

Java developers have long lived with an awkward trade-off. If you want the clarity and optimization benefits of final, you must initialize eagerly, in a constructor or static initializer. If you want to defer expensive setup until first use, you usually fall back to mutable lazy-initialization patterns, nullable fields, or double-checked locking. Those techniques work, but they also make code harder to reason about and harder for the JVM to optimize.

UNDERSTANDING AOT

Tue, 21 Jul 2026 07:00:01 +0000

What is AOT?

Ahead-of-Time (AOT) compilation in Java is a crucial technique that translates Java bytecode into native machine code before the application is executed. In traditional Java execution, source code is compiled into bytecode that the Java Virtual Machine (JVM) loads and runs. By performing the translation to native code beforehand, AOT allows direct execution by the operating system, which eliminates the initial need for the JVM to interpret bytecode or wait for standard compilation paths during runtime. This proactive process significantly optimizes resource utilization right from the start.

Solving Spring AI's UI Challenge with AG-UI's Java SDK

Thu, 16 Jul 2026 07:00:01 +0000

Introduction: The Missing Link in Java AI Development

Ask any Java developer who has tried to build an AI feature in a production application and they’ll tell you the same thing: the backend isn’t the hard part anymore. Spring AI makes it easy to invoke an LLM, define prompts, and create tools. But turning these interactions into a smooth, interactive user experience? That’s where the struggle begins.

Most developers solve this by inventing custom message formats, WebSocket events, and ad-hoc rules for how the UI should render tool calls. Each application reinvents the bridge between frontend interactions and agent intelligence. The result? A fragile, inconsistent layer that must be rebuilt for every project.

Serverless Functions Reimagined with Java 25

Wed, 15 Jul 2026 07:00:02 +0000

Serverless computing whether on AWS Lambda, Azure Functions, or Google Cloud Functions plays a vital role in modern distributed systems. By abstracting infrastructure away from application code, serverless platforms allow developers to focus on business logic. These functions scale automatically and can be highly cost-efficient when applied to the right use cases.

In serverless platforms, applications may be started many times a day and often run only for a few seconds. They are scaled up and down automatically and may be paused or frozen between requests. This behavior does not only affect performance; it also directly impacts cost, since billing is often based on execution time and allocated memory.

LangChain4j Agentic Workflows: From AI Calls to Multi-Agent Systems in Java

Wed, 08 Jul 2026 07:00:02 +0000

You have built AI features into your Java application. Your model is wrapped in a service, RAG is feeding it context, tools are wired, and calls are flowing. It works. Then requirements evolve. A single prompt-and-response is no longer enough. You need steps that follow each other, branches based on decisions, retries when things fail, and multiple actions running concurrently. The question shifts from “how do I call an LLM?” to “how do I orchestrate multiple LLM-driven tasks into a coherent system?”

From ‘Class Not Found’ to Calm: Practical Shading and Shadowing for Java Apps

Tue, 07 Jul 2026 07:07:12 +0000

Your pipeline is green, the app is deployed, and everything looks fine… until production says “nope”. A request fails and the logs show ClassNotFoundException, or worse, NoSuchMethodError. These are among the most confusing runtime errors because the code compiled successfully, but the JVM is acting differently than you would expect.

Let’s dive in and explore how the class loader works, what class shadowing is (when one class silently wins over another on the classpath) and what class shading is (when you deliberately relocate packages so multiple versions can coexist). We’ll also see how these two concepts can help solve mysterious production issues and make your app more stable and secure.

Paketo Buildpacks: ready for Java 26 & more!

Thu, 02 Jul 2026 07:00:02 +0000

Paketo Buildpacks, the default way to create container images with Spring Boot, will include support for Java 26 the same week it will be released in major OpenJDK distributions (Oracle, BellSoft Liberica, Azul Zulu, etc.)
Let’s take this as an opportunity to (re)discover what Paketo Buildpacks are and what they allow you to do!

Paketo Buildpacks: Not the Only Buildpacks Around!

A World of Buildpacks

My first memory of using buildpacks dates back to when I worked for a bank around 2020 (yes, that year!) and my team created and maintained a bunch of shell scripts that would copy a templated Dockerfile, add the public certificates from the corporate Certification Authority (CA), and then build the Dockerfile into an image (and even create a Helm chart!); but we soon learned that there were open-source buildpacks that supported most of our use cases!

The 5 Knights of the MCP Apocalypse

Wed, 01 Jul 2026 07:00:01 +0000

Let’s talk about that new MCP (Model Context Protocol) Server your team is using to connect to your real data services. It’s awesome, right? It’s the “magic box” that gives your AI Agent access to the real world—live databases, internal APIs, and all your tools.

But here’s the catch: you don’t own the code.

It’s a vendor product, an open-source project, or another team’s platform. You can’t just change its code when you find a security hole, unless you have the code and recompile it and deploy it.

Stay Updated with Every New Free PDF Edition!

Tue, 30 Jun 2026 08:50:00 +0000

Want to make sure you always receive the latest JAVAPRO magazine?
By subscribing to our news, you’ll automatically get notified and receive every new PDF — free and direct to your inbox, no extra steps required.

Enjoy exclusive content, special editions, and stay connected to everything new.

Subscribe now to all future PDF editions and be the first to know!

Download free PDF here: Edition 06/2026 | Autonomous Java

06-2026 | Autonomous Java

Tue, 30 Jun 2026 07:00:02 +0000

DOWNLOAD

CORE JAVA
▪️Learning Java Automation the SOLID Way: A Beginner’s Guide to Learn Page Object Model with Java SOLID Principles
▪️OpenJ9 GC Policies: How to Choose the Right Collector

API & FRAMEWORKS
▪️Elasticsearch Java SDK: No Magic, Just Solid Design Choices
▪️Java Developers, You’re Already Ready for Blockchain — You Just Don’t Know It Yet
▪️Connecting Java Reinforcement Learning to Python Gymnasium
▪️Beyond Text Search: A Smarter Way to Understand Your Code
▪️The 3 A.M. Deadlock

The Foundations of Data-Oriented Programming in Java

Wed, 24 Jun 2026 07:00:01 +0000

Introduction

Java has traditionally been an object-oriented language, urging developers to structure code around objects, encapsulate state and behavior, hide implementation details, and extend functionality through inheritance. This method has advanced modularity and reusability. However, with recent enhancements, Java has evolved, revolutionizing how systems are developed and offering powerful tools for developers.

Have you ever been in the midst of debugging a complex Java application, only to find that the mutable state across various objects left you tangled in a web of unexpected behaviors and racing conditions? These frustrations are common among Java developers accustomed to Object-Oriented Programming (OOP), where mutable objects often lead to more complex, less predictable systems. Fortunately, with recent language enhancements, Java developers now have capable tools to treat data as a first-class citizen.

1BRC - The First 80% of the Journey

Tue, 23 Jun 2026 07:00:02 +0000

The One Billion Row Challenge (1BRC) started as a way to kill time during the 2023/2024 holidays, asking a simple question: How fast can Java crunch temperature values from a text file and calculate the min, mean, and max per weather station? The catch is that the file contains one billion rows, totaling approximately 13.8 GB.

Thomas Wuerthinger, Quan Anh Mai, and Alfonso Peterssen achieved the best result of 1.5 seconds on 8 cores. That was insanely and unexpectedly fast. But when you take a closer look at the code, you will see that it is beyond your daily dose of Java. It is a complex, single-use-case-oriented implementation, skipping safety features, and most of the tunings applied cannot be easily reused.

Open J Proxy 0.5.0-beta — The Caching and Read/Write Splitting Release

Mon, 22 Jun 2026 12:00:02 +0000

When we shipped 0.4.0-beta, the core value of Open J Proxy was already clear: a database control plane for Java applications that lets you scale dozens of application instances without overwhelming your database, because the server — not the application — owns and controls the real connection pools. What 0.5.0-beta adds on top of that foundation is two features that take the pressure off the database even further. The first is query result caching: the ability to answer repeated SELECT queries directly from memory without touching the database at all. The second is read/write splitting: the ability to automatically route reads to replica databases and leave the primary free for writes. Together, they advance OJP’s role as a full database control plane — governing not just connections but query results, routing decisions, and admission under load.

2: The Jakarta Cliff: Why Modern Java Leaves Struts 1 Behind

Thu, 18 Jun 2026 07:00:02 +0000

This is the second in a series of articles exploring the realities of modernisation. In this article, you’ll learn about:

The Modern Java Breakpoint: Why the shift from javax to jakarta creates an unfixable compatibility break for Struts 1 on modern containers like Tomcat 10 and Jetty 11.
The External Pressure Cooker: How platform baselines, security policies, and cloud migrations force the issue, even if the application code itself hasn’t changed.
Why “Shims” Fail: A look at why attempting to patch compatibility with shims is not a viable long-term solution for production environments.
Safe Operation Strategies: What it practically means to run Struts securely on older containers without exposing the rest of your infrastructure to risk.
The Path to Modernisation: How to use incremental migration patterns and extended support to modernise on your own terms, avoiding risky “big-bang” rewrites.

Enterprise-grade AI for Java Developers: Behind the Bar of the AI Revolution

Wed, 17 Jun 2026 16:45:24 +0000

There is a moment many Java developers experience today. After years spent building reliable systems, modernizing monoliths, shaping APIs, orchestrating containers, and keeping distributed applications alive, someone suddenly asks whether you can “add a bit of AI.” At first it sounds innocent. You try a model endpoint, run a quick experiment in Quarkus, watch a few responses appear in your terminal, and feel the spark of possibility. It looks easy. Almost too easy.

1: Why Struts 1.3 Still Matters in 2026

Tue, 16 Jun 2026 16:41:08 +0000

What You’ll Learn

This article is the first in a series that explores why Struts 1 still shows up (quietly but persistently) in enterprise systems in 2026, and what that means for teams trying to keep the lights on.

We look at:

The Discovery Effect: How stable, forgotten Struts apps resurface during audits, migrations, and security scans.
Where the Friction Really Is: The talent shortage, the tooling disconnect, and the Jakarta EE shift: all colliding to make legacy upkeep harder than it should be.
Modernisation Without the Fantasy: Why the rewrite-or-risk framing misleads teams, and how approaches like embedding Struts in Spring Boot create workable transition paths.
Buying Breathing Room: How extended support gives organisations time to avoid crisis-driven decision-making.

Automating JVM Thread Dump Analysis with AI: Practical Observability for Java on Amazon ECS and EKS

Thu, 11 Jun 2026 07:00:01 +0000

Imagine the following scenario: a Java service that ran flawlessly yesterday suddenly starts consuming 90% CPU, barely responding to user requests. Users encounter timeouts, and the operations team is under immediate pressure to triage the incident. In these situations — whether the application appears stuck or CPU saturation has occurred — one of the most powerful diagnostic assets available is the thread dump. A thread dump captures the state of all JVM threads at a specific point in time, showing execution states, stack traces, and lock contention — the raw material needed to understand what the runtime is actually doing.

Structured Concurrency in Java 26 (JEP 525 Deep Dive)

Tue, 09 Jun 2026 07:00:01 +0000

The Java 26 Evolution of Safer, Predictable Multi-threading

Java has long provided powerful concurrency primitives. Threads, executors, futures, and more recently virtual threads allow applications to scale across cores and I/O boundaries. Yet many production failures are not caused by insufficient parallelism, but by insufficient structure.

Tasks outlive the operations that spawned them. Failures are detected but not propagated consistently. Interrupts are delivered but not observed in time. Thread dumps reveal activity, but not ownership or intent.

Comparing transitive dependency version resolution in Rust and Java

Thu, 04 Jun 2026 07:00:01 +0000

You learn by comparing to what you already know. I was recently bitten by assuming Rust worked as Java regarding transitive dependency version resolution. In this post, I want to compare the two.

Dependencies, transitivity, and version resolution

Before diving into the specifics of each stack, let’s describe the domain and the problems that come with it.

When developing any project above Hello World level, chances are you’ll face problems that others have faced before. If the problem is widespread, the probability is high that somebody was kind and civic-minded enough to have packaged the code that solves it, for others to re-use. Now you can use the package and focus on solving your core problem. It’s how industry builds most projects today, even if it brings other problems: you sit on the shoulders of giants.

Virtual Threads Meet AI: Java Concurrency in the Age of Intelligent Systems

Tue, 02 Jun 2026 07:00:00 +0000

AI workloads change how Java applications scale and behave. This article explains how Java 26 and virtual threads simplify concurrency in AI-heavy systems, replacing complex reactive setups with clearer and more efficient designs. It shows when virtual threads outperform traditional async models and how concurrency choices impact system architecture.

Introduction: Java, AI, and the New Concurrency

The rapid growth of AI-driven systems is reshaping how we design and scale Java APIs. RAG systems, LLM inference, and recommendation pipelines bring thousands of simultaneous requests with heavy network I/O, vector databases, and external services.

Always Up to Date - with Every New Free PDF Edition!

Thu, 28 May 2026 12:00:00 +0000

Don’t Want to Miss a Thing?
By subscribing to our news, you’ll get each new PDF edition automatically — no extra steps, just delivered straight to your inbox. Enjoy exclusive JAVAPRO content, special editions, and stay connected to everything new.

✔️ 100% free

Subscribe now and be the first to receive every future issue & updates.

‘From AI as a Feature to AI as Infrastructure’ – download free PDF here!

From Spaghetti to Hexagons: A Practical Guide to Clean Java Architecture

Wed, 27 May 2026 07:00:01 +0000

A Culinary Warning and the Dark Side of Code

Welcome, fellow architect and beloved developer, to our hexagonal city-state—a realm where pragmatism reigns supreme and flexibility is our greatest strength. This guide is not an ivory tower doctrine filled with theoretical perfection, but rather a versatile toolbox tempered in the forge of real-world challenges and countless production battlefields.

Before we can erect the citadel of clean architecture, we must first acknowledge the reality of our industry. We must navigate the “Dark Side of Code”. The software world is rife with culinary disasters that would make a chef weep. We are all too familiar with Spaghetti Code^(1), a tangled mess where program flow twists and turns like pasta, making maintenance a nightmare where references and dependencies jump all over the place. But the menu of disaster is extensive.

Destructoring is the future of Javas Encapsulation

Tue, 26 May 2026 07:00:00 +0000

Encapsulation in Java has been broken since the Java Development Kit (JDK) 5. Objects should guarantee that their inner state matches what we cast into code, but at runtime any private and final state can be set from the outside to any value — bypassing any checks and asserts. This is possible through the Reflection Api, which allows to setAccessible any private field and then set the value of any final field. This specific use of the Reflection Api to mutate an immutable final field is called deep reflection.

Open-Core with Core Java and Vaadin — Part 2

Sat, 23 May 2026 11:33:42 +0000

Editions, runtime, and quality assurance.

All source code presented here is published on GitHub and available at https://3g3.eu/naityh.

Recap of part one

The first part of this article developed the abstract mechanics of the open-core application. From two independent Maven projects with strictly asymmetric dependency direction, a deliberately slim extension API with the contribution types RouteContribution, MenuContribution, NavbarContribution, and CounterEventListener, a FeatureRegistry that discovers its contributions via the Java standard library’s ServiceLoader, and a Vaadin integration consisting of MainLayout and OpenCoreRouteInitializer, an apparatus is now in place that can accept arbitrary contributions in ordered form, without the core needing to know their identity.

Open-Core with Core Java and Vaadin — Part 1

Fri, 22 May 2026 11:33:04 +0000

Architecture, extension API, and Vaadin integration.

1. Introduction and motivation

The open-core model is often reduced in discussion to questions of licensing or commercial positioning. An open-source variant of a piece of software is complemented by a commercially distributed variant that brings additional features. Anyone who actually wants to implement such a separation in an existing codebase quickly discovers that the real difficulty lies neither in the licence text nor in the choice of repository, but in the code’s architecture.

Vaadin + Quarkus: The New Approach for Enterprise Apps

Tue, 19 May 2026 07:00:01 +0000

While Vaadin is commonly integrated with Spring, this article explores a powerful new full-stack solution: Vaadin with Quarkus. Quarkus provides a lightning-fast runtime and native images, complementing Vaadin’s Java-first UI, which eliminates JavaScript complexity. Readers will learn how to build scalable, reactive Vaadin Flow apps on Quarkus, covering simplified backend development, enhanced productivity with a unified Java stack, and superior deployment optimization compared to traditional approaches.

Introduction

Vaadin and Quarkus are both modern Java frameworks, each excelling in its domain: Vaadin for building rich web UIs in pure Java, and Quarkus for creating cloud-native, container-first Java applications. Together, they offer a compelling alternative to traditional full-stack Java development, especially for enterprise applications.

OpenFeature - one flag to rule them all!

Thu, 14 May 2026 07:00:01 +0000

Feature flags and where to find them

What are feature flags?

To keep it simple it’s a way to change the system behaviour at runtime without hassle.

Note: And if this “refresher” was the only theoretical thing you wanted to know or if you already use feature flags and want to jump straight to code/ OpenFeature demo, feel free to do so; otherwise, please bear with me for another couple of text pages.

Java Developers, You're Already Ready for Blockchain — You Just Don't Know It Yet

Fri, 08 May 2026 07:00:01 +0000

The Java ecosystem has a mature way of doing things. Pick your framework. Use Maven or Gradle. Write tests with JUnit. Run everything locally with Docker. These patterns have been stable for years exactly because they work.

But most blockchain ecosystems were not built with Java developers in mind. Instead, Rust, JavaScript, and Go dominate. Cardano – my blockchain of choice – historically leaned on Haskell.

At the end of the day, if you wanted to build on blockchain as a Java developer, you were largely on your own.

BloxBean was built to fix this.

No matter if you prefer Spring Boot, any other Java framework, or actually default to Maven, Gradle, and writing clean Java services, you already have everything you need to start building on Cardano.

Kotlin kontra Java - Part 3 - Language for Interop

Thu, 07 May 2026 07:00:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin? Why not both?

You can use any Java library you want in Kotlin, you can even co-write your software in both languages (e.g. one team I work with writes their JUnit tests in Kotlin, their main code in Java) and migrate to Kotlin or back to Java over time. Kotlin is designed with Java interoperability in mind, because JetBrains wanted to migrate their IDEs (IntelliJ IDEA, WebStorm, etc.) incrementally to the language. But how does that work? What does Kotlin do, so that interop to this degree becomes possible?

Java 26 in Practice: How the JVM Is Changing the Way We Write Code

Wed, 06 May 2026 07:00:02 +0000

Java 26 in practice shows a fundamental shift in how modern Java systems are built. Virtual threads, modern GC, AOT caching, and the Vector API are shifting long-standing responsibilities from the application into the JVM — forcing developers to rethink everyday design decisions.

Introduction

Java 26 in practice changes how we think about new Java features. When we think about new Java, we usually look first at syntax. Pattern matching, records, new JDK APIs grab attention. With Java 26 in practice, however, the most profound impact is different. It is not in language constructs.

Final Is No Longer a Hint in Java 26

Wed, 29 Apr 2026 07:00:02 +0000

Java 26 (JEP 500) warns when code mutates final fields via deep reflection and introduces explicit controls to scope or deny that behavior. This article breaks down what changes, why it matters for JIT optimizations, and a migration loop you can put into CI.

JEP 500 and the Performance Runway Behind Final Means Final

For years, Java has carried a quiet contradiction: the language treats final fields as immutable after initialization, but deep reflection could still mutate them. That single escape hatch forces the JVM to be conservative about both correctness and optimization, because a final value might not actually be final.

Stay Updated with Every New Free PDF Edition!

Tue, 28 Apr 2026 12:00:02 +0000

Enjoy exclusive content, special editions, and stay connected to everything new.

Subscribe now to all future PDF editions and be the first to know!

Download free PDF here: Edition 04/2026 | Java in the Age of AI

Kotlin kontra Java - Part 2 - MultiPlatform

Wed, 22 Apr 2026 07:45:01 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

You might have a preference based on the ecosystem — the tooling around it, who we can ask for help, and the libraries we can use — which we discussed in part 1 of this article series. Or you might have a preference based on the business modeling capabilities of Java or Kotlin, which we will show in part 3.

Building an AI-Powered RPG - to Learn Enterprise AI Integration

Tue, 21 Apr 2026 07:00:02 +0000

This article shares insights from my hackathon project “Runes of Reason” - an AI-powered RPG - and uses it to explain concepts for AI integration with Spring AI. Along the way, the game demonstrates how LLMs can fundamentally reshape our whole product design. The RPG is an entertaining project for learning, but many insights can be transferred to real-world enterprise software use cases (summarized in the “Lessons Learned” sections).

Note: The code examples use the Spring AI milestone release 2.0.0-M2 - the API might change. The article also assumes a basic understanding of LLMs and Spring. If it feels too fast-paced, JAVAPRO offers a Spring AI fundamentals tutorial as well as many other great articles that can help you getting started with the topic.

Java 26 Is Boring

Fri, 17 Apr 2026 07:00:03 +0000

Which Is Why It Is Brilliant

When people hear “boring tech”, they usually mean old, slow, or not innovative. But in production, boring implies something very different. Boring means predictable, with no surprises. Boring means your system still works at 3 a.m. when nobody wants to debug a memory leak. And boring also means that you can understand your system years after you wrote it.

Many platforms try to impress developers with significant changes, shiny rewrites, or breaking updates. Java took another path. Java optimizes for trust.

Kotlin kontra Java - Part 1 - Ecosystem

Thu, 16 Apr 2026 07:00:00 +0000

When you start a new project on the JVM, should you pick Java or Kotlin?

Kotlin is used by Amazon, Atlassian, Duolingo, Google, JetBrains, Meta, Netflix, Uber and many more. Java is used by, well, „more than 3 billion devices“. Which one provides the biggest benefit, which one can give us an edge, which one should we pick?

After 20 years of building systems in Java and 8 years of doing the same in Kotlin, I’ve seen Kotlin earn its reputation as a natural evolution of Java. Rightfully so. Much of what we need can be expressed very cleanly with little verbosity.

Modernizing Production Containers to Resist the Constant CVE Flow

Tue, 14 Apr 2026 07:00:03 +0000

Common Vulnerabilities and Exposures or CVEs is a catalog of publicly disclosed software security flaws that attackers can use to gain unauthorized access.

With 40,003 CVEs recorded in 2024, denoting a 39% increase as compared to 2023, container vulnerabilities are no longer a minor cleanup task. It is a river that floods Kubernetes clusters, drowning the teams in operational burden while real exposures slip through.

Chasing every single CVE is a road to nowhere as new vulnerabilities are discovered constantly. The solution is to build a centralized vulnerability management system that will serve as a dam resisting the CVE flood and enable controlled CVE identification and remediation.

Zero Migration Java - Staying Current Without Breaking Your App

Fri, 10 Apr 2026 07:00:01 +0000

Keeping enterprise Java applications secure and up-to-date is critical but traditional runtime upgrades often come with painful migrations, broken dependencies, and retesting cycles. What if developers could upgrade their runtime without touching their code? In this article, we explore the concept of zero migration — a runtime model that allows Java applications to stay current with the latest pat

Java Vector API: Faster vector computations for the JVM

Thu, 09 Apr 2026 07:00:02 +0000

Introduction

Modern CPUs contain vector registers. These vector registers hold multiple numerical values as the same time. They enable SIMD (Single Instruction Multiple Data) which allows same instruction to be applied to multiple pairs of data which is present in these vector registers. SIMD is a natural choice for parallel data processing which is needed for processing arrays, large binary files, statistical analysis etc.

Historically, Java developers relied on the HotSpot compiler to auto-vectorize simple loops. Auto-vectorization is an extremely fast choice when it applies, but it requires a lot of conditions to be met to be applied: many real-world loops are not transformed because the compiler cannot prove safety or profitability. Java’s Vector API was introduced to close this gap by providing a clear, explicit, platform-agnostic way to express vector computations so that they can be reliably compiled to the best available hardware instructions and still run correctly (with “graceful degradation”) when vector instructions are not available or not applicable.

A Big Screen Experience for Java Developers & Architects

Wed, 08 Apr 2026 12:00:02 +0000

JCON EUROPE 2026 | April 20–23, 2026 | Cinedom Cologne

Anyone talking about modern software development today can hardly avoid Java. Few technologies have shaped the enterprise world as sustainably, and few communities are as vibrant, diverse, and innovation-driven. This is exactly where JCON comes in: as a meeting point, a platform, and an experiential space for developers from all over the world. With participants from more than 70 countries, JCON has long since become an international gathering. Openness, knowledge sharing, and a strong sense of community remain at its core.

Java Performance Optimization with Agentic AI: Autonomous Diagnostics and Actionable Recommendations

Tue, 07 Apr 2026 07:00:01 +0000

Java performance diagnosis in production is manual, slow, and requires deep expertise. You get a Grafana alert, grab a thread dump, download a JFR recording, open it in JDK Mission Control, stare at flamegraphs, correlate with metrics — hours of work per incident. Most teams don’t have a dedicated performance engineer, so alerts get ignored or result in generic “add more replicas” responses.

We built a system that does this autonomously. When a monitoring alert fires, it collects profiling data and thread dumps, extracts runtime metrics, generates flamegraphs, and sends everything to an AI model that produces a structured performance report — including root cause analysis and concrete code fixes with file paths and line numbers from the actual source repository. The pipeline runs on Kubernetes, triggered by Grafana webhooks, with results stored in Amazon S3.

Talk to Your Data: Natural Language Data Access in Java

Fri, 03 Apr 2026 07:00:01 +0000

For decades, Java developers have relied on robust frameworks to manage the complexity of enterprise applications. At the heart of this ecosystem lies Hibernate ORM, the popular library for bridging the gap between object-oriented Java applications and relational databases. It allows developers to map complex domain models to database tables, and write type-safe, performant queries using the Hibernate Query Language (HQL).

Quarkus has emerged as a Java framework for building applications and services, focusing on incredibly fast startup times, efficient resource consumption and developer joy.

The FFM API: OpenJDK Changed the Game for Native Interactions and #JavaOnRaspberryPi

Wed, 01 Apr 2026 07:00:02 +0000

If you’re working with Pi4J, you’re essentially using a Java library that bridges the gap between your Java application and the GPIO hardware on a Raspberry Pi. The beauty of Pi4J lies in how it hides the complexity of native library integration and the Java Native Interface (JNI). It lets you focus on building great applications rather than dealing with low-level system calls.

My involvement with Pi4J started around 2020 while writing the book “Getting Started with Java on the Raspberry Pi”. Despite years of contributing to the project, the deeper layers of Pi4J’s codebase still challenge me. Take a look at this snippet and tell me if you understand what’s going on:

Agentic AI Patterns for Enterprise Software

Tue, 31 Mar 2026 07:00:01 +0000

It is no surprise that software development is increasingly shaped by the integration of AI. As the technology matures, we are moving beyond simple, monolithic AI models or single shot API calls. Modern enterprise architectures are rapidly adopting agentic AI systems, which orchestrate multiple independent reasoning agents to accomplish complex, real-world tasks. This article explores these powerful patterns, covering the core concepts of agents, their coordination, orchestration models, and crucially how to implement them effectively in enterprise Java applications.

Always Up to Date - with Every New Free PDF Edition!

Thu, 26 Mar 2026 12:05:02 +0000

✔️ 100% free

Subscribe now and be the first to receive every future issue & updates.

‘From Coder To System Designer’ – download free PDF here!

Semantic Versioning done automatically

Thu, 26 Mar 2026 07:00:02 +0000

Software evolves over time. Bugs are fixed, features are added, and occasionally design mistakes are corrected in ways that are incompatible with earlier releases. Version numbers exist to identify these distinct states of a software artifact and to allow consumers to reason about whether an upgrade is safe. Without versioning, it is impossible to distinguish between two builds of the same library or to express expectations about their compatibility.

Semantic Versioning

Software versions come in many forms, ranging from simple incrementing numbers to schemes based on release dates. One of the most widely adopted approaches is Semantic Versioning, commonly abbreviated as SemVer. SemVer defines a structured MAJOR.MINOR.PATCH version format with explicit rules about how version numbers must change in response to different kinds of software changes.

Effective Pattern Matching 2026 Edition

Tue, 24 Mar 2026 16:58:41 +0000

Since Java 14, the Java switch and instanceof statements have been enhanced, in multiple phases, to support pattern matching and a “data-oriented” programming style. In this article, I explore when this programming style is beneficial, and why. I describe the syntax of pattern matching, as it has evolved, and show how it will be further enhanced in upcoming versions of Java. I warn of corner cases of the switch syntax where modern usage clashes with legacy behavior. I conclude with a set of rules when to use pattern matching and “data orientation” now, how to prepare for future enhancements, and when to stay away.

A2A Building Interoperable AI Agents with Java

Wed, 18 Mar 2026 07:00:02 +0000

Why agents need friends?

We’ve recently seen a boom in AI “agents”. AI Agents are usually described as a service that talks to an AI model to perform some kind of goal-based operation using tools and context it assumes.

But most of these agents are still working in an isolated environment. You build an agent into your application and it offers some capabilities, but that’s it. You’re basically building a monolith with AI in it.

Open J Proxy 0.4.0-beta: Flexibility, Observability, and a Big Step Toward Production

Tue, 17 Mar 2026 12:00:01 +0000

By Rogerio Robetti – OJP Founder and Lead Developer

Every few releases a project crosses a threshold where the changes stop being incremental and start reshaping how the system can be used.
Open J Proxy 0.4.0-beta is one of those releases.

This version touches nearly every layer of OJP: integration with popular Java frameworks, observability, security, extensibility, and developer tooling. The result is a release that makes OJP easier to integrate, easier to operate, and far more flexible internally.