Performance on JAVAPRO International

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.

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.

Can GenAI Help Reduce Energy Used by Java Code?

Fri, 13 Feb 2026 07:00:02 +0000

Some recent studies show that IT is emitting more CO2 than civil aviation! As software developers, there is something we can do: optimising our code. Making our code run more efficiently should reduce the carbon footprint of IT. It will consume less CPU, RAM, disk, and network. Hardware being powered by electricity, these optimisations should reduce our electricity bills and lower emissions due to generation of that electricity. Optimised software also extends hardware lifespan by reducing the need for upgrades, diminishing the embodied carbon from manufacturing and avoiding raw material extraction (e.g., rare earths mining).

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.

Houston, we have problems with the queries

Thu, 29 Jan 2026 07:00:02 +0000

introduction

Most developers build queries to access a relational database, using some ORM in different ways to generate the query automatically or write the query manually. Everything could work in most cases in other environments, but at some point, the query becomes slow, or the application takes more time to execute the same task that it did in the past. At this point, the developers, QA, and many others waste a lot of time understanding the change that produced the problem in the last commits, but why not create a test that detects some issues with performance before they appear?

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.

Next Generation Caching & In-Memory Searching

Mon, 28 Jul 2025 07:00:01 +0000

When Traditional Databases Reach Their Limits

Enterprise applications frequently face performance bottlenecks that stem from the underlying persistence layer. Despite decades of database evolution, many core applications still struggle with latency, throughput, and architectural complexity. These issues are particularly evident in systems that depend on complex join operations across multiple tables, need to process unstructured data, or must execute cross-database queries spanning disparate systems to fulfill analytical workflows.

In such environments, it is common to see a combination of various technologies being deployed in tandem: a traditional relational database, a distributed cache, a NoSQL database, and sometimes a dedicated search server such as Elasticsearch. While each of these systems addresses a specific technical challenge, their co-existence leads to architectural fragmentation, high infrastructure costs, duplicated data models, and increased development and maintenance efforts. Moreover, the overall latency and resource usage often remain suboptimal due to inherent I/O-bound limitations and serialization overheads between systems.

EclipseStore: The Evolution of Java Persistence

Mon, 12 May 2025 11:24:29 +0000

Database development in Java has always been a challenge, often feeling like a battle against mismatched paradigms. From the start, developers wrestled with complex mappings and performance bottlenecks when integrating Java with databases. EclipseStore, an open-source project under the Eclipse Foundation, was created to change this. Its mission is to deliver a Java-native persistence layer that feels like an integral part of the language, not a workaround for database limitations. By storing Java objects directly, it aims to simplify and accelerate development, aligning persistence with Java’s core strengths.

IBM Architect Mark Stoodley Reveals JVM Optimization Techniques

Wed, 07 May 2025 10:17:14 +0000

Slow Java startups, repeated JIT compilations, high CPU load: these factors are not just performance issues — they also drive up infrastructure costs and increase the energy consumption of applications. At JCON EUROPE 2025, developers will have a rare opportunity: Mark Stoodley, Chief Architect for Java at IBM, travels from Canada to personally lead an exclusive workshop. The title: “Ultra Efficient Startup for Production Java Workloads” — a hands-on format demonstrating how to run JVM-based production applications more efficiently, faster, and with lower resource consumption.

Optimizing Java Performance: Caching with Core Java Instead of Complex Frameworks

Mon, 05 May 2025 07:00:02 +0000

Slow Java applications are a well-known problem in many projects: delays caused by ORM, complicated caching structures, and overloaded databases slow down performance. At JCON EUROPE 2025, the two-hour workshop “High-Performance Caching with Pure Java: Supercharge Your Sluggy Database Application” will show how to specifically solve these problems — exclusively with Core Java, without additional frameworks or cloud services.

Hands-on: Caching and Queries at Maximum Speed

Participants will learn how to develop a high-performance caching and query layer themselves — lean, memory-efficient, and directly in Java. The goal is to eliminate typical performance bottlenecks in database-based applications and increase system speed many times over.

Dynamic Caching for Massive Workloads: Pure Java Solutions First-Hand

Tue, 29 Apr 2025 08:54:00 +0000

Many Java developers encounter the limitations of traditional caching and database solutions when dealing with large amounts of data and dynamically growing workloads. Heavyweight systems often prevent flexible scaling or unnecessarily increase infrastructure costs.

The session "High-Performance Caching with Pure Java – Part 2: Managing Gigantic Workloads" at JCON EUROPE 2025 presents an approach that does things differently: Instead of complex architectures, this approach relies on pure Java – lean, scalable, and powerfull.

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.

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.