Performance on JAVAPRO International

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.

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.

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.

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.

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.

Virtual Threads, Structured Concurrency and Scoped Values: Putting it all together

Thu, 19 Feb 2026 07:00:01 +0000

In this article we are going to discuss Virtual Threads, Structured Concurrency and Scoped Values, the three main features of Project Loom and see how we can put them all together, in a web application. We will create a Spring Boot application and then add these features one by one to see how these features fit together nicely enabling us to write readable concurrent programs.

What is Project Loom?

Project Loom is one of the most important projects at Open JDK. The purpose of Project Loom is to provide high throughput, lightweight concurrency, which is also easy to use. It does so by providing three features: virtual threads, structured concurrency and scoped values. Virtual threads are lightweight, high-throughput threads that scale effortlessly. Structured concurrency is a streamlined approach to managing concurrent tasks as a single unit of work and scoped values are a modern alternative to ThreadLocal, designed for virtual threads.

the runtime illusion: what Java really runs

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

Introduction

Java’s bytecode is made abstract to be portable and neutral from specific hardware. Yet in production, it performs with the precision of native code. How? The secret lies in the JIT compiler, a near magical blend of static analysis and real-time insights. It reinterprets, restructures and often reinvents the code based on the runtime behaviour. This article traces that silent transformation using the Semeru (OpenJ9) JIT, following a method from source to bytecode to intermediate representation and ultimately to highly optimised machine code. You will be amazed to see how your logic is optimized beyond recognition. What you write is not always what runs, and what runs is often much better version of what you imagined.

Mastering Memory Efficiency with Compact Object Headers in JDK 25

Tue, 10 Feb 2026 07:00:01 +0000

Compact Object Headers are introduced in JDK 25 through JEP 519, marking a significant step forward for memory optimization in the JVM. First introduced experimentally in JEP 450 with JDK 24, this feature, authored by Roman Kennke, reduces the per-object memory footprint without slowing down performance.

The payoff is especially clear in object-heavy workloads and memory-constrained environments, such as those found in containers and cloud-native deployments.

In JDK 25, Compact Object Headers graduate from experimental to standard. However, they’re not enabled by default. Developers must turn them on using JVM flags to see the benefits.

No Deadlocks in MongoDB: Atomic Documents and Retries with Spring Data MongoDB

Thu, 18 Dec 2025 07:00:01 +0000

Deadlocks are frequent in SQL databases, as normalization and two-phase locking (2PL) require locking multiple tables or rows during DML operations. Numerous use cases share them, and transactions might access data in a different order, resulting in circular waits and deadlocks. While databases can detect them, they can’t prevent or resolve deadlocks, as the application determines what is run and in what order. The best the database can do is cancel one statement or transaction, and let the application rollback and retry, which can reduce performance as systems wait several seconds before getting notified. As Oracle Database makes clear in the error log: “It is a deadlock due to user error in the design of an application or from issuing incorrect ad-hoc SQL.” Most RDBMS use pessimistic locking to avoid conflicts, but deadlocks are unavoidable, and locking can increase latency. For instance, by default, DB2 waits 10 seconds for deadlock detection, SQL Server waits 5 seconds, Oracle waits 3 seconds, and YugabyteDB and PostgreSQL wait 1 second. These delays impact latency, but deadlock prevention remains the application’s responsibility. The only way to entirely prevent deadlocks is by avoiding locks altogether, as in MongoDB, which provides lock-free ACID transactions.

JVM Iceberg – Modern Performance Edition

Thu, 31 Jul 2025 07:00:01 +0000

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.

Should we stop discussing about technical debt... with top management?

Wed, 18 Jun 2025 07:00:01 +0000

Cyclomatic complexity, coupling and cohesion, orthogonality, big O… are concepts that technical teams use when analyzing complex software systems and can establish why it is difficult to change them. Technical language refers to the technical aspects of those systems. But when we have to explain to non-technical people in the organization why an application has bugs, why a feature is not on time, or why we need a database expert to make a simple change to a service, we cannot use those concepts. To do that, we have to speak in a language that those non-technical people understand the intrinsic nature that exists in systems developed with software.

The Simplest Way to Build Resilient Applications

Thu, 08 May 2025 07:00:01 +0000

Restate is an open-source system that makes it easy to write resilient, consistent and scalable applications. Restate lets you write mission-critical applications, like payment workflows, user management, and AI agents, without worrying about resiliency.

Speed Up Existing Deployments with the Right JVM Features

Thu, 17 Apr 2025 09:33:21 +0000

In today’s tech landscape, Java applications face a critical challenge. Organizations need to meet growing performance demands while keeping infrastructure costs under control, without costly redevelopment efforts.

This challenge has intensified with cloud computing adoption. Every millisecond of latency and every megabyte of memory now directly impacts ongoing expenses. The numbers are striking: based on my experience, poorly configured JVMs typically can increase cloud costs by 30-50%. For large enterprises, this represents millions in avoidable expenses.

Hitchhiker's Guide to Java Performance

Mon, 07 Apr 2025 11:43:20 +0000

The Past, The Present and The Future

Over the last 30 years, Java has evolved from an exotic “write once, run anywhere” language to one of the dominant platforms for software development worldwide. In the early years, Java was justifiably considered slow compared to languages such as C/C++, which was mainly due to the initial interpreter approach. However, the last three decades have shown that the VM concept with HotSpot’s adaptive optimization is clearly the superior approach.
by Ingo Düppe

1BRC with AI - curious and curiouser said the LLM

Wed, 15 Jan 2025 11:48:56 +0000

Did you try turning it off and on first?

(I promise this is the last 1BRC-related post). Read on to discover how large language models (LLMs) performed in generating Java code, their strengths in context-aware development, and challenges such as hallucinations and nuanced errors. Learn what makes a good AI dev tool and what makes a great IDE integration.

A definition of insanity is repeating an action and expecting a different outcome. As developers, we’re used to doing that :-) It’s part of our operating manual.

My Top 10 Principles for getting the best from AI (for developers)

Mon, 02 Dec 2024 11:56:54 +0000

AI tools for developers: principles, insights, and the importance of clean code.

Every day, I encounter a new AI tool, whether a new capability is added to an existing tool or an entirely new offering. I actively use several AI tools, including ChatGPT, Grammarly, and Amazon Q Developer, each serving different purposes. I pay for pro access to ChatGPT and Grammarly, though I sometimes consider switching to Claude.ai, which occasionally proves invaluable. s a view of AI tools for developers: my principles, insights and ultimately the realisation that development practises such as clean code is more essential than ever

1 Billion RECORD CHallenge - AI Style

Thu, 07 Nov 2024 10:05:34 +0000

Previously …

I recently wrote about my experiences with getting AI coding tools to find bugs and write tests. I picked five different tools. The selection criteria were simple - free or trial with no credit card needed. I chose three tools designed to help developers and two general-purpose LLMs.

I gave them a 1000-line Java program and asked them to do three things.

Add Javadoc to explain what the code did
Analyse the code for bugs and design weaknesses
Create Junit testcases that would provide reasonable code coverage.

The results were disappointing but, in hindsight, predictable. Overall, the tools were better at creating documentation than finding bugs and, apart from one, were pretty poor at writing test cases.

Top 5 UI Web Libraries That Support Accessibility For Your Next Project

Fri, 18 Oct 2024 11:24:59 +0000

image thumbnail building

“Cultural Heritage and Barrier-free Accessibility Project”/ pdm 1.0

What Makes The Best UI Libraries?

When choosing a UI library, consider factors such as your project requirements, the skill set of your team, and the design principles you want to follow. For example, if your project requires some accessibility but lacks resources like budget or team, you can try to use a 3rd party component UI library that will save a lot of your resources. But, before we determine the top 5 best UI libraries for accessibility, it’s essential to establish clear criteria not only from the accessibility aspect. This ensures that our selection process is fair, objective, and accountable, instilling confidence in the validity of our list.

Building a better Mouse Trap - web crawling with Temporal

Thu, 03 Oct 2024 14:26:30 +0000

For various reasons, I’ve been looking at Temporal lately. It’s one of those open-source projects with some great users - think Netflix, Uber, etc.- yet has less visibility in the Java community than expected.

I hope to raise its profile here.

Before I talk about Temporal, I’ll cover my particular use case. Stay with me; this needs to be detailed.

Background

A side project I have is to create a Java API comparison tool that can be used to check if moving from version A to version B of a dependency will have issues. I’m looking beyond the simple class-to-class comparison, I intend to check for a more holistic view to find runtime and compile time problems that might occur within the dependency tree if you upgrade something.

Exploring Cost-Effective Solutions for Stateful Rest Services

Tue, 30 Jul 2024 12:30:00 +0000

A cost-effective approach to implementing stateful REST services using IBM Cloud Code Engine, EclipseStore, and IBM Cloud Object Storage, highlighting their integration and scalability benefits for enterprise applications.