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.

Do You Still Write Code without Hexagon?

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

During our training in architecture, we often ask participants if they are familiar with Hexagonal architecture, and it’s surprising to see only a few hands raised initially. After a brief presentation, we see a few more hands go up, as participants realize they have been using Hexagonal architecture without realizing it.

As hands-on architects, we rely heavily on Hexagonal architecture in our daily work. However, we notice that many people are still unaware of the significant benefits it can bring to their projects.

When Product Owners Commit Code: Small Steps, Big Impact

Thu, 09 Jul 2026 10:01:52 +0000

Disclaimer: No Product Owners were harmed in the making of this story.
Spoiler: They survived. In fact… they thrived.

We never planned to tell this story.. and certainly not six years later. Back when it happened, it didn’t feel revolutionary. It felt… practical. A small fix to a small annoyance. The sort of thing teams do every day just to make life a bit easier.

But today, in a world where AI blurs boundaries and workflows become more fluid, the lesson behind this tiny experiment has become surprisingly relevant again. Because even before the age of “AI copilots”, our Product Owners had to leap across a much wider gap and yet what unfolded wasn’t about tools at all. It was about mindset. About curiosity. About empathy. And about what happens when teams stretch just a little bit beyond the edges of their roles.

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.

BoxLang’s First 11 Months: Explosive Growth, Developer Empowerment, and the Return of Dynamic Language!

Fri, 03 Jul 2026 12:00:01 +0000

11 months. 13 releases. Production workloads already running. If you haven’t evaluated BoxLang yet, now is the time.

https://www.ortussolutions.com/blog/boxlangs-first-11-months-explosive-growth-developer-empowerment-and-the-return-of-dynamic-languages

At Into the Box 2026, Ortus Solutions pulled back the curtain on something that deserves serious attention from every technical leader building on the JVM: BoxLang is not a hobbyist language experiment. It is a production-grade, actively evolving development platform with enterprise adoption already underway and a runtime footprint that now reaches places Java simply cannot go.

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!

BoxLang 1.14.0 : Query Transformers: Take Full Control of Your Query Results

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

BoxLang 1.14.0 ships a lot of exciting features – Dynamic Sets, Ranges, Inner Classes, JSONPath navigation – but one quietly powerful addition will change the way you think about every database call in your application: Query Transformers, and this is just the start, we have plans for a whole lot more cool query features.

If you have ever executed a query and then immediately written a loop to reshape the result into what you actually needed, this feature is for you.

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

API Development: Implementing an HTTP POST/SSE event in Jakarta REST

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

In this article, we’ll learn how to send messages to a client using Server-Sent Events (SSE) initiated by a client’s persistent HTTP POST connection.

1. What is Server-Sent Events (SSE)?

Server-Sent Events (SSE) is a web push technology, based on the HTTP protocol, that allows clients to subscribe to a stream of events, pushed by the servers over a persistent HTTP connection. The server sends chunks of data (as data event streams) asynchronously to the client, once the client connection is established.

BoxLang 1.14.0 : Introducing Inner Classes

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

BoxLang has always embraced a simple truth: the way you organize code shapes the way you think about problems. For a long time, if you needed a helper class, you needed a file. One class, one .bx file, no exceptions. This also stemmed from the CFML days. That’s clean and predictable, but it creates real friction when a class is tightly coupled to exactly one caller and has no business existing anywhere else.

BoxLang 1.14.0 : BoxSet is Here: BoxLang's New First-Class Set Type

Fri, 26 Jun 2026 12:00:01 +0000

BoxLang 1.14.0 ships with a new dynamic first-class Set type baked directly into the language. Not a wrapper you reach for manually, not a createObject( "java", "java.util.HashSet" ) incantation you paste from a Stack Overflow answer years ago. A real BoxSet with literal syntax, operator overloads, a full functional pipeline, change listeners, JSON serialization, and deep Java interop.

If you have ever deduplicated an array with a loop, compared two collections element by element, or modeled a permission system on top of a struct – Sets are the tool you were missing. Let’s dig in.

From Prototype to Production: Building Safe and Reliable AI Agents with Spring AI and MCP

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

The AI agent demo works perfectly in the development environment. Your prototype handles natural language queries, executes tool calls, and generates sensible responses. But when stakeholders ask ‘Can we deploy this?’, reality sets in. That question exposes the massive gap between a functional prototype and a Spring AI production system ready for real traffic, unexpected failures, and business-critical operations.

That question reveals the massive gap between a working prototype and a production system. The demo doesn’t handle failures gracefully. It has no guardrails against harmful outputs. There’s no visibility into what the agent is actually doing. Cost per request? Unknown. Error rates? No idea. Recovery strategy when the LLM provider goes down? Haven’t thought about it.

BoxLang 1.14.0 : Sets, Ranges, Inner Classes, and a Runtime That Talks Back

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

BoxLang has never stood still, but version 1.14.0 is something different. This is the release where the language stops filling gaps and starts defining what a modern dynamic JVM language looks like on its own terms. Sixty-five issues closed. Four innovative language features. A formatter that has grown up. And a companion module - bx-mcp - that fundamentally changes how you operate a running BoxLang application with AI.

This could have easily been a major release for the team. This has been a really amazing effort by everybody at Ortus, and we’ve received great feedback from our clients migrating to BoxLang and coming up with innovative ideas for this platform. We have only just begun!

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.

Introducing bx-jwt: Enterprise-Grade JSON Web Tokens for BoxLang

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

JWT authentication is everywhere. But rolling it correctly — with proper algorithm enforcement, key management, clock skew handling, JWE encryption, and zero security footguns — is anything but trivial. Today, we’re shipping bx-jwt, a production-ready JWT/JWE module for BoxLang that handles all of it out of the box, so you can focus on building, not fighting cryptography.

bx-jwt is part of the BoxLang+ and BoxLang++ subscription tiers — our enterprise-grade module collection built for teams that take security seriously.

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.

Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD

Wed, 17 Jun 2026 12:00:03 +0000

We believe the best way to learn a programming language is by writing code — real code, with real feedback, and real tests. That’s exactly why we built BoxLings.

Inspired by the beloved Rustlings project, BoxLings is an interactive CLI tool that teaches you BoxLang through hands-on exercises. You read failing tests, fix broken code, and level up — one exercise at a time.

Oh, and the whole thing is written in BoxLang itself. 🥊 Dogfooding at its finest.

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.

BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity

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

BoxLang 1.13.0 is a stability-first release with deep compatibility work and runtime hardening. This build closes 48 issues, with the majority focused on CFML compatibility edge cases, concurrency correctness, formatting parity, and miniserver/runtime reliability under real production loads.

While this release is bug-fix heavy, it still introduces several meaningful features and quality-of-life improvements: character-aware trimming, class metadata lookup by absolute path, process environment control in SystemExecute(), SOAP headers, new query column rename capabilities, and safer miniserver routing/security defaults.

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.

BoxLang Goes Serverless on Google Cloud

Wed, 10 Jun 2026 12:00:01 +0000

We just shipped the BoxLang Google Cloud Functions Runtime — and it brings the same write-once-run-anywhere serverless experience you already know from our AWS Lambda runtime, now running natively on Google Cloud Functions Gen2.

The big idea is simple: the same .bx handler file you deploy to AWS Lambda works on GCF without modification. One codebase. Two clouds. Zero rewrites.

The Architecture

The GCF experience is intentionally split into two projects:

Beyond UML: Clean Software Architecture in the Age of AI‑Generated Code

Wed, 10 Jun 2026 07:00:02 +0000

Abstract

Today we write more code in less time than ever before. AI systems act like permanently available junior programmers: They produce thousands of lines of code in minutes – but who takes responsibility for the software architecture?

The real problem is therefore often not “bad AI code,” but the growing difficulty for people to keep an overview and make sound architectural decisions.

This article discusses an idea for quickly building a mental model of existing code, spotting architectural problems early, and making targeted changes – without having to maintain static documentation in parallel.

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.

Build Cross-Platform Desktop Apps with BoxLang

Mon, 08 Jun 2026 12:00:00 +0000

Today we’re shipping the initial release of the BoxLang Desktop Runtime — powered by Electron, BoxLang, and Vite. With one starter, one npm run dev, and one packaging command, you can build and distribute professional desktop applications for macOS, Windows, and Linux using the BoxLang you already know. 🎯

This is BoxLang’s newest runtime joining a deliberately growing list — web servers, AWS Lambda, Google Cloud Functions, Android (in development), and now desktop. Same language, same idioms, same modules — different shell. Write once, deploy where your users are. 🚀

BoxLang AI 3.2.0 — Image Generation, Web Search, Fluent Audio, Agent Registry & MCP Observability

Fri, 05 Jun 2026 12:00:01 +0000

BoxLang AI 3.2.0 is here, and it’s a landmark release. We’re shipping five major features: image generation, web search, a fluent audio builder API, a centralized agent registry, and deep MCP observability along with a suite of analytics improvements and a critical bug fix. Let’s dig in. 🎉

🖼️ Image Generation — `aiImage()`

You can now generate images directly from BoxLang using any provider that supports text-to-image generation. The aiImage() BIF follows the same fluent, chainable philosophy as the rest of bx-ai then act on the result with expressive method calls.

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.

Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang & the Ortus World

Wed, 03 Jun 2026 12:00:03 +0000

Today we’re launching something we’ve been quietly building for months: skills.boxlang.io — a public, agent-agnostic directory for AI skills covering BoxLang, ColdBox, TestBox, CommandBox, and the entire Ortus ecosystem.

If you’ve ever pasted a 400-line system prompt into yet another AI agent, watched two of your bots drift onto subtly different versions of the same coding standard, or spent half a Friday afternoon trying to convince an LLM that BoxLang is not Java and is not CFML, or how to code for Modern CFML; this launch is for you. 🎯

The Gen AI Iceberg - Java Tooling Edition

Wed, 03 Jun 2026 07:00:03 +0000

From `@Autowired ChatClient` to Compiling GPU Kernels From Pure Java Bytecode: A Lovecraftian Descent Through Everything a JVM Developer Needs (or Fears) to Build AI-Powered Applications

The “Iceberg” meme is an internet phenomenon that humorously, and sometimes unsettlingly, illustrates levels of knowledge or initiation into a given topic – from simple, widely known facts at the tip of the iceberg to the dark, esoteric depths comprehensible only to the most battle-hardened veterans. Picture an iceberg floating on water: what’s visible on the surface is just the beginning, while the real magic (or nightmare) lurks beneath, in increasingly inaccessible layers.

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.

Announcing MatchBox Open Beta: BoxLang, Now Running in New Places

Mon, 01 Jun 2026 12:00:00 +0000

Ortus Solutions is excited to announce the open beta of MatchBox, a new open source project in the BoxLang ecosystem. MatchBox is a custom BoxLang virtual machine written in Rust. It is built for the places where a full JVM runtime is not the right fit: small native command-line tools, compact web services, browser applications, WebAssembly containers, and even embedded hardware like ESP32 devices.

The project started in early March and has been moving quickly - already at v0.5.0. That speed is part of why we are opening the beta now. MatchBox is already capable enough to build real experiments, prototypes, and early applications, but it is still beta software. APIs will change. Some language features are still being implemented. Some deployment targets are intentionally limited while we harden the runtime. We want developers to try it, break it, ask questions, and help shape where it goes next.

JCON EUROPE 2026: Why the Java Community Still Meets in Person

Mon, 01 Jun 2026 07:00:00 +0000

Every year, when we start planning JCON EUROPE, one question always guides us:

How do we create a conference that developers genuinely enjoy attending?

Not just another event with slides and sponsor booths. Not a place where people passively consume information and leave. We wanted to create an environment where developers actively connect, discuss, challenge ideas, and solve real-world problems together.

Looking back at JCON EUROPE 2026, I believe this spirit was visible everywhere.

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!

05-2026 | From AI as a Feature to AI as Infrastructure

Thu, 28 May 2026 10:41:04 +0000

DOWNLOAD

JCON
▪️JCON Europe 2026: Why the Java Community Still Meets in Person

CORE JAVA
▪️Java 26 Is Boring
▪️Structured Concurrency in Java 26 (JEP 525 Deep Dive)
▪️Are the Classic Design Patterns Still Valid with Modern Java?

API & FRAMEWORKS
▪️The Gen AI Iceberg – Java Tooling Edition
▪️Building AI-Driven Java Systems with Spring AI and Java 26
▪️LangChain4j Agentic Workflows: From AI Calls to Multi-Agent Systems in Java

Unlocking Developer Productivity with Java 25: Features You’ll Actually Use

Thu, 28 May 2026 07:00:02 +0000

Summary

Java 25 features for developers bring practical enhancements you can use daily. From improved switch expressions and record patterns to simplified error handling, these Java 25 features reduce boilerplate, improve clarity, and simplify your code. Discover practical, real-world examples you can drop directly into your codebase.

Introduction: A Java Release that makes a difference

For many developers, Java release cycles blur together. Each version arrives with a list of JEPs, often full of improvements that, while important for the platform, they don’t immediately translate into productivity gains for everyday coding.

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.

OpenJ9 GC Policies: How to Choose the Right Collector

Thu, 21 May 2026 07:00:02 +0000

For many OpenJ9 users, garbage collection tuning starts with the wrong question.

They ask, “Which collector is the fastest?” or “Which one is best for cloud?” In practice, the better question is: what does my application actually need from the heap?

That is the right starting point because OpenJ9 gives you several distinct GC policies, each designed around a different balance of throughput, pause time, heap geometry, and operational behavior. The default is gencon, and for a broad spectrum of Java applications that is still the right place to start. But once heaps grow, pause spikes become operationally expensive, or throughput becomes the dominant goal, a different policy may be the better fit.

Will AI Replace Me? Understanding Our Value in the AI Era

Wed, 20 May 2026 07:00:00 +0000

If you tried to keep up with all the content that’s flooding the internet on the topic of “Will AI replace software developers?”, you’d probably found a new full-time job. Social media posts, vlogs or entire channels, even CTO keynotes… not a day goes by without new content.

This article cannot predict the future. But it can offer some orientation in a messy debate by structuring it and making its implicit (and often false) assumptions visible. Because the biggest fallacy may not be overestimating AI - but underestimating what software engineering actually is about.