Performance on foojay.io - Friends of OpenJDK

Toward a Durable Spring PetClinic

Sun, 19 Jul 2026 18:06:06 +0000

Overview

Durable Execution is a way of running code so that its progress survives failure. A normal program keeps its state in memory: if the process crashes, the machine reboots, or a network call times out halfway through a multi-step operation, that state is gone and the work is left half-done.

Temporal, the Durable Execution platform, persists every step of a process to its Event History — a durable, append-only log of Events — so that after any failure the work resumes exactly where it left off, as if the crash never happened.

BoxLang 1.15.0 Released: Blazing Fast Strings, Runtime Portability, and much more

Tue, 14 Jul 2026 17:57:10 +0000

BoxLang 1.15.0 is a high-impact release with two big headlines and a long tail of hardening. The first headline is a massive performance upgrade to string handling : a new first-class BoxStringBuilder type, compile-time literal folding, smarter &= semantics, and a runtime concat strategy that automatically switches to builder-backed accumulation once your expression gets big enough. Your existing string-heavy code just got faster. No rewrites required.

The second headline is architectural. Every class loader in the BoxLang runtime and module system has been fully abstracted behind a pluggable IClassLoaderFactory interface. That single seam is what unlocks the Android runtime and Ahead-of-Time (AOT) compiled runtimes such as GraalVM Native Image that we have on the roadmap. The default behavior is unchanged, but the ceiling just got a lot higher.

Temporal Is to Your Code What a Database Is to Your Data

Sat, 11 Jul 2026 10:31:54 +0000

Once upon a time, applications managed their own data files. Every program hand-rolled its own locking, its own crash recovery, its own consistency guarantees. Every program did it badly, in its own unique way.

Then the relational database arrived and made a deal with application developers: you declare what you want, and I guarantee it survives. Atomicity, durability, crash recovery: all of it moved out of application code and into a dedicated platform. Nobody writes their own file-based transaction log anymore.

"This Can't Possibly Work": What I Learned at a Temporal.io Workshop

Fri, 10 Jul 2026 08:41:22 +0000

When developers first hear about Temporal , they tend to move through a predictable sequence of emotions. First comes disbelief — the claim that your application can crash mid-execution and simply pick up where it left off, variables intact, sounds like nonsense. Then comes irritation that anyone would even say such a thing is possible. Then they try it, discover it actually works, and get very excited. And finally they ask the only question that matters: how?

Nulling Out References Won't Help Your Garbage Collector

Thu, 09 Jul 2026 13:49:39 +0000

One of the misconceptions that I continuously run into is that nulling out references in Java helps garbage collection.

This attitude is particularly prevalent from those developers used to C/C++ where delete ptr becomes ref = null. To be fair, it’s a reasonable thing to believe.

It’s also wrong, and the way it’s wrong tells you most of what’s worth knowing about how a tracing collector actually works.

That is, the vast majority of data allocated in a tracing garbage collected runtime becomes collectable as soon as a variable falls out of scope.

Jurassic JDK: Migrate or Extinct

Fri, 26 Jun 2026 07:28:00 +0000

65 million years ago, dinosaurs didn’t adapt. They’re gone. Your JDK 7 app is giving the same energy. 🫠

I spent a year and a half migrating more than 15 projects in production. Full time. Real teams, real deadlines, real 2am breakage. This is everything I wish someone had written before I started.

Why Are We Still Here? 👀

Walk into any company with a codebase older than 5 years and you’ll hear the same thing:

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Your TLS Stack Is Lying to You About Zero-Copy

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

The “No Waste Compute” Constraint

When I started designing the Exeris Kernel, I set one non-negotiable rule very early: no waste compute. That rule sounds like a performance slogan until it starts killing otherwise normal design decisions.

I had already banned ThreadLocal, moved context propagation to Scoped Values, and pushed more of the runtime into explicit off-heap ownership. The idea was simple: if the hot path is supposed to stay outside GC pressure, then memory shape and lifetime cannot be treated as incidental details.

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

Tue, 19 May 2026 12:11:19 +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.

AWS Nitro and CPU Graviton Meets Unikernels

Fri, 10 Apr 2026 16:26:25 +0000

AWS Nitro and CPU Graviton Meets Unikernels: Java and Quarkus on ARM64 AWS Graviton with Nanos Unikernel

Java and Jakarta EE Truly Meet Unikernels

The key message of this article is simple and strong:

any Java or Jakarta EE application is already ready to benefit from the advantages of unikernels.

Java and Jakarta EE, including modern frameworks such as Quarkus, can immediately take advantage of the unikernel model without waiting for new languages, new runtimes, or radical rewrites.

Thread Safe Native Memory in Java

Tue, 07 Apr 2026 10:00:43 +0000

What is Memory Order and Why Does It Matter for Native Memory?

The Foreign Function and Memory (FFM) API is Java’s way of interacting with native code and memory. In the previous post, you learned how to do so using Java’s built-in Arena types. The Arena provides temporal safety and bounds checks, but what about thread safety? MemorySegments created by .ofShared(), .auto(), and .global() can be used by multiple threads at the same time. Using a VarHandle with just get/set can backfire if you don’t use something like locking. The downside is that locks are slow and heavy. So let us take a look at a more granular, hardware-aware approach: using VarHandle access modes.

TestBox 7: Real-Time Feedback, a Browser-Based IDE, and Modern Testing Workflows on the JVM

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

TestBox 7.x focuses on improving testing workflows for BoxLang and CFML applications. This release introduces improvements to the BoxLang CLI runner , real-time streaming test execution via SSE , dry run capabilities, a browser-based TestBox RUN interface, and several developer experience enhancements.

Check out the what’s new here: https://testbox.ortusbooks.com/readme/release-history/whats-new-with-7.0.0

TestBox RUN: A Browser IDE for Your Tests

The centerpiece of TestBox 7 is TestBox RUN : a self-hosted, single-page web app (bx/tests/index.bxm) that you drop into any BoxLang project and open in a browser. No build toolchain. No external service. Just BoxLang.

Native Memory in Java: Arenas, Malloc, and Pools

Fri, 20 Mar 2026 10:20:04 +0000

What is the Memory API

The Foreign Function & Memory (FFM) API is Java’s new way of interacting with native code and memory. It is mostly useful when storing data off-heap or passing arguments to a native method. Handling this native memory comes down to balancing how much control you need against the risk of memory leaks. You can rely on the provided Arenas to bind memory to safe scopes, or you do it yourself using malloc and free for absolute control, or implement custom pools and slices to optimize allocations for your use case.

How is Leyden improving Java Performance? Part 3 of 3

Thu, 19 Mar 2026 12:10:22 +0000

In part 1 of this series of 3 blog posts we introduced the specific performance challenges OpenJDK faces lowering application ‘startup’, ‘warmup’ and ‘initial footprint’ costs and provided an overview of what Leyden is doing to address those challenges.

Part 2 described how to use the new capabilities offered by Leyden and presented test results which show that very significant progress has already been made and is set to continue.

How is Leyden improving Java Performance? Part 2 of

Wed, 18 Mar 2026 12:05:34 +0000

Part 2 describes how to use the new AOT capabilities offered by Leyden and presents test results which show that very significant progress has already been made and is set to continue.

How is Leyden improving Java Performance? Part 1 of 3

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

In this series of 3 blog posts we will explain how OpenJDK project Leyden is helping to improve a specific area of performance where Java has notably lagged behind other languages i.e. application ‘startup’, ‘warmup’, and ‘initial footprint’.

Part 1 explains what those terms mean and why Java faces challenges in matching the behaviour of other languages. It then provides an overview of what Leyden has done to improve startup and warmup in existing JDK releases and what is planned for upcoming releases.

BoxLang 1.11.0 Release

Tue, 17 Mar 2026 09:40:04 +0000

We’re proud to announce BoxLang 1.11.0, a highly focused performance and stability release that delivers measurable speed improvements across every BoxLang application, with zero code changes required. The team invested deeply in bytecode generation, class loading, lock management, and type casting to produce one of the most impactful runtime optimization releases to date. Alongside the performance wave, this release resolves critical concurrency bugs, hardens DateTime handling, and ships powerful new developer tooling.

I Benchmarked Java on Single-Board Computers: Orange Pi 5 Ultra and Raspberry Pi 5 Lead the Pack

Wed, 04 Mar 2026 06:52:00 +0000

In my “Java on Single Board Computers” series, I already published several posts and videos in which I unpack the board, connect it for the first time, and try to install and run some simple Java code. In this post, I want to share some benchmarks of Java on these boards to get a better idea of the performance we can expect from Java on these platforms.

Already published in this series:

JC-AI Newsletter #14

Tue, 03 Mar 2026 15:11:53 +0000

Two weeks have passed and a lot have been happening on the field of artificial-intelligence.

Two weeks have passed and a lot has been silently yet visibly happening in the field of artificial intelligence. This newsletter brings interesting developments, including Dario Amodei’s (Anthropic) view on the progress achieved in the LLM field and his response to the utilization of these models for specific kinds of military purposes, as well as OpenAI’s response to it. Aside from the fact that development may follow more sigmoids instead of exponential progress, it is important to have awareness of utilization across branches. Does prompting and clarifying the goal influence agent responses, and if so, how? How far are we from reliable robotics applications? How much bias is introduced when clinical data is being analyzed?

Runtime Code Analysis in the Age of Vibe Coding

Tue, 17 Feb 2026 14:00:00 +0000

In the era of vibe coding—where large amounts of code are introduced or refactored in short bursts, often with the help of LLMs—you need immediate feedback on how new logic actually executes. Not comprehensive analysis. Not nanosecond-precise timing. Just a quick confirmation that your loops aren’t spinning 10,000x more than they should.

However, traditional profilers can feel like overkill for quick validation. In addition, they present results at method/stack granularity and require context-switching to interpret. They also introduce overhead, ranging from negligible (e.g., JFR/sampling) to noticeable (call tracing/instrumentation). As a result, they are less convenient as always-on feedback during rapid iteration.

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Wed, 11 Feb 2026 13:50:41 +0000

Profiling a Java Application Running Inside an Unikernel with JProfiler

Unikernels are often associated with minimalism and tight resource control.

But can we profile a Java application running inside a unikernel using a standard JVM profiler?

The answer is yes.

In this guide, we will walk step by step through profiling a Quarkus

application running inside a Nanos unikernel using JProfiler and
IBM Semeru JRE 25 (OpenJ9).

No special hacks. Just standard JVM tooling.

Webinar: "Moving Applications From JDK 21 to JDK 25: What You Need to Know"

Mon, 26 Jan 2026 14:14:32 +0000

JDK 25 has arrived as the latest long-term support (LTS) release for Java, bringing performance improvements and enhanced stability for modern applications. If your organization is running JDK 21, now is the time to start planning your migration path.

Why Upgrade?

Each new LTS release represents years of refinements, optimizations, and new capabilities. JDK 25 builds on the foundation of JDK 21 while delivering the reliability that enterprise applications demand. But understanding what’s changed—and what might break—is essential for a smooth transition.

Get high performance Java applications with IBM Semeru Runtimes

Tue, 20 Jan 2026 13:53:00 +0000

Originally published at developer.ibm.com .

By Vijay Sundaresan, Mark Stoodley, Marius Pirvu, Grace Robinson, Laura Cowen

Explore real‑world benchmarks, tuning options, and best‑practice strategies to optimize latency, throughput, and memory on modern hardware with Semeru Runtimes, an OpenJDK distribution.

When running applications in the cloud, performance matters. An application that handles more requests with less CPU and memory is cheaper to run. Java and its associated frameworks are widely appreciated for stability, throughput performance, and portability but not typically recognized for starting quickly, ramping up quickly, or consuming resources frugally. These limitations can pose significant challenges, especially when migrating Java applications to the cloud or developing new cloud-native Java solutions where more resources immediately make deployments more expensive.

JC-AI Newsletter #12

Wed, 14 Jan 2026 07:15:44 +0000

F irst of all, Happy New Year 2026! This year is designated in the Chinese Calendar as the Year of the Fire Horse (starting on February 17.). The year 2026 brings not only tremendous energy to AI development but also, in my humble opinion, many breakthroughs in the field.

Although there have been many small steps toward the field’s evolution, it often feels that development is stagnating, applying known or slightly tweaked strategies to non-deterministic problems while expecting deterministic results. This includes the often misleading benchmarking strategies (deterministic) performed on synthetic datasets.

Java Warmup and the Scaling Loop Problem

Wed, 07 Jan 2026 06:50:00 +0000

In cloud environments with auto-scaling, a “scaling loop” can make Java application warmup even worse. It can cause you to run unnecessary instances. Even worse, Java warmup might never end. Fortunately, there are four reliable fixes for this issue.

In this post you will learn:

High CPU during startup triggers auto-scaling and spins up more instances
One solution is to give the compiler more resources
A second solution is to lower the compilation threshold
A third solution is to use the ReadyNow feature in Azul Platform Prime to start fast every time
In a fourth solution, we add Azul’s Optimizer Hub to offload compilations to dedicated hardware

You’ve probably noticed it: You start a Java application and the CPU usage spikes. It remains high for a while, then gradually settles. That’s the warmup phase, and it’s completely normal. But in cloud environments with auto-scaling, it creates a nasty problem. High CPU during startup triggers auto-scaling. More instances spin up. Those new instances also undergo this warmup phase with high CPU utilization. More scaling gets triggered. You see where this is going? Let’s call it the “scaling loop problem,” and it’s both expensive and frustrating.

Optimizing Java for the Cloud-Native Era with Quarkus

Tue, 06 Jan 2026 21:09:00 +0000

This article explores how Quarkus can help organizations reduce costs, streamline development, and modernize their Java applications for today’s cloud-native environments. It outlines the real-world benefits of adopting Quarkus and highlights how its core features address the performance and scalability challenges commonly associated with traditional Java frameworks.

Quarkus is already being adopted across industries. One example is Orange, a global telecom provider that selected Quarkus to support its 5G API initiative, and benefited from fast startup times, a lightweight footprint, and seamless integration with Kubernetes.

Java and Jakarta EE and the Evolution of the Cloud with Nanos Unikernel

Tue, 06 Jan 2026 20:51:09 +0000

The evolution of the Java and Jakarta Enterprise ecosystem is converging toward an increasingly simple, efficient, and scalable architecture that improves security, delivers higher performance, and reduces hardware and infrastructure costs.

For years, Kubernetes has been considered the de‑facto standard for modernizing Java applications in a cloud‑native direction. However, Kubernetes is not the only way to achieve scalability, continuous upgrades, and isolation. An alternative approach — often underestimated — is to leverage the hypervisors already included and fully managed by major cloud providers , using Unikernel images based on Nanos .

Make Java Fleets Warm Up Faster on AWS With Azul Optimizer Hub

Thu, 18 Dec 2025 08:35:52 +0000

Traditional Java executes code in slower interpreted mode, known as Java warmup, until it can build an optimized profile. This means it can only start optimizing once the application takes traffic and touches the critical code paths. Just when you are scaling out for a large bump in traffic, your machines are running at their slowest and are splitting their available CPU power between handling requests and performing expensive JIT optimizations

More Java From Azul!

Wed, 10 Dec 2025 17:14:23 +0000

Azul is a company focused purely on Java through builds of OpenJDK, in the form of Platform Core, and our high-performance Java platform (including JVM), Platform Prime. We build on these with Intelligence Cloud to deliver precise information about security vulnerabilities in running code, unused code and an inventory of all JVMs in use.

When looking at expanding the company through acquisition, we obviously wanted to maintain that dedication to all things Java, so what better company than Payara?

The Art of Performance Tuning: Why Saving 30% in the Cloud Means Nothing if Your Code Wastes 1000× More

Tue, 25 Nov 2025 06:46:00 +0000

The Hidden Cost of “Good Enough” Code

A few weeks ago, Kirk Pepperdine published a fascinating performance challenge — a small Java code snippet that appeared trivial but produced puzzling runtime behavior.

He invited readers to take a shot at solving it. If you haven’t seen it yet, stop here for a moment and try it yourself — and when you’re done, check his Kirk’s official solution

When I saw it, I thought it would be a fun exercise to revisit some fundamentals — but the deeper I went, the more I realized it wasn’t just about performance. It was about how we think.

Java Security Starts with the JVM

Mon, 10 Nov 2025 12:37:20 +0000

When it comes to Java security, the first thing that comes to mind should be the JVM. If you’re relying on outdated, unpatched, or unsupported Java runtimes, you’re taking unnecessary risks.

In this article, you will learn:

Timely, predictable updates are critical for Java security
Long-term security hinges on long-term support
If your Java runtime is compromised, every application that runs on it could be compromised too
As environments become cluttered with multiple JDK versions and unpatched workloads, organizations lose visibility into what’s deployed

When it comes to securing your Java applications, the JVM might not be the first thing that comes to mind—but it should be. Your JDK isn’t just a runtime; it’s part of your software supply chain. If you’re relying on outdated, unpatched, or unsupported Java runtimes, you’re taking unnecessary risks.

JC-AI Newsletter: Easy Access to Expanding Challenges

Tue, 04 Nov 2025 18:13:33 +0000

A few months ago, I launched the AI Newsletter to provide a minimally biased perspective on the growing challenges surrounding artificial intelligence.

My primary motivation was and remains to be serving the community not only by showing how to use and access specific services for utilizing Large Language Models, but also by support a deeper understanding of the broader artificial intelligence landscape.

Many of the core challenges that have emerged around LLMs have not been and still not properly addressed, often omitted due to their uncomfortable implications.

What Happens When 10,000 JVMs Collaborate

Mon, 13 Oct 2025 07:03:51 +0000

A large global enterprise achieved a performance and efficiency milestone, running 10,000 Java Virtual Machines (JVMs) that collaborate and share optimizations with one another, using Azul Platform Prime’s Optimizer Hub. The enterprise improved application responsiveness and stability at scale while reducing infrastructure costs, which has resulted in better user experiences and greater business efficiency.

In this post you will learn: how…

A global enterprise sustained rising cloud costs to support the company’s ongoing success
Azul Platform Prime with Optimizer Hub is delivering cloud cost savings of more than 20%
Optimizer Hub is improving cloud-centric Java application startup, warmup and runtime performance by offloading optimization tasks from JVMs to a centralized set of services

Earlier this year, an Azul Platform Prime enterprise customer achieved something no other organization has ever accomplished: seamless collaboration between more than 10,000 JVMs across hundreds of applications using a single instance of Platform Prime’s Optimizer Hub. In case you’re wondering, here’s why that’s big news.

Take the State of Java 2025 Survey

Mon, 06 Oct 2025 12:23:17 +0000

Do you want to know which Java JDK distribution is used where for what and when? The time has come again to take the State of Java Survey and share insights while gaining Java ecosystem knowledge.

All those participating will get the complete research, which can be of great benefit in your technology choices in the Java ecosystem.

Click the image below to get started:

Or simply click this link:

Azul’s High-Performance Java Platform Achieves Historic First

Wed, 17 Sep 2025 16:49:56 +0000

Azul Platform Prime Achieves Historic First with 10,000+ JVMs Collaborating and Sharing Performance Optimizations, Cutting Cloud Costs by More than 20%

Fleet-level advantages achieved for cloud-native Java applications with faster warm-up, smoother scaling and reduced cost

SUNNYVALE, Calif. — September 17, 2025 — Azul , the only company 100% focused on Java, today announced a breakthrough in cloud deployment at scale with Azul Platform Prime , its high-performance Java platform. A leading global enterprise has deployed hundreds of applications and micro-services across more than 10,000 Java Virtual Machines (JVMs) using Platform Prime’s Optimizer Hub, a unique capability that allows JVMs to collaborate and share performance optimizations.

JetBrains and Azul Collaborate on Kotlin Performance in Various JVMs

Wed, 10 Sep 2025 07:11:44 +0000

JetBrains and Azul are collaborating on a shared vision of running Kotlin-generated bytecode on a high-performance Java platform to find new ways to enhance runtime performance. Benchmarks of Kotlin performance on Azul Platform Prime have yielded some eye-opening results.

In this article you will learn:

Kotlin is a high-level programming language designed to interoperate fully with the JVM
Runtime performance and scalability are derived predominantly from the JVM
JetBrains and Azul benchmarked Kotlin on both standard OpenJDK and on Azul Platform Prime, a high-performance Java platform
Platform Prime reduced latencies by 23.9% and improved throughput by as much as 30.5%

As modern JVMs combine language features and runtime optimizations, they unlock new levels of performance.

Boosting Kafka Latency Performance by 3x with Zing JVM and AutoMQ

Fri, 29 Aug 2025 12:57:48 +0000

Why is Latency so Important to Kafka?

The importance of low latency in Kafka stems from the use cases it enables. Many applications that rely on Kafka are time-sensitive.

Real-time applications, such as financial trading platforms, fraud detection systems, and real-time monitoring services, depend on obtaining the most current information available. A delay of even a few seconds could mean the difference between a successful trade and a missed opportunity, or a prevented fraudulent transaction and a financial loss.
User experience is another area where latency plays a significant role. Think about in-app notifications, live-updating dashboards, or multiplayer games. A snappy, responsive system feels good to use. Sluggishness, on the other hand, can be a significant turn-off for users.
From an operational perspective, latency is a key indicator of health for your Kafka cluster. A spike in latency can be an early warning sign of a problem, such as a network bottleneck or a slow consumer, which can lead to message backlogs and system instability if left unaddressed.

Maintaining low latency in the cloud with traditional Kafka is challenging. Its architecture couples compute and storage, making scaling slow and expensive due to data rebalancing. This creates a complex trade-off between high costs from overprovisioning and poor performance during traffic spikes. To solve this, new cloud-native streaming systems have emerged with a different architectural approach.

Preparing for Spring Boot 4 and Spring Framework 7: What’s New?

Mon, 11 Aug 2025 14:42:40 +0000

I’m a passionate Spring Framework and Spring Boot enthusiast, and I always look forward to exploring and experimenting with the latest features and improvements they introduce. With Spring Boot 4 and Spring Boot Framework 7 right around the corner, now’s the perfect time to dive into the key enhancements that will shape the future of modern Java and enterprise application development.

In this blog post, we will discuss some key features enhanced as part of Spring Framework 7 and Spring Boot 4.

Sustainability Starts with Your Runtime: Meet a Green JVM

Tue, 15 Jul 2025 14:20:00 +0000

Reducing spend in the cloud is a top priority for many organizations, and a high-performance Java platform can help cloud cost reduction efforts. These same optimizations can help organizations achieve sustainability goals, including achieving carbon net-zero. And pursuing sustainability goals can also lead to financial advantages.

Cloud costs are under the microscope, and reducing spend in the cloud is a top priority for many organizations. We’ve been helping customers on that journey with Azul Platform Prime, a high-performance Java platform that runs code faster, uses fewer compute resources, and helps cut your cloud bill .

Prime Time: The High Performance Java Event

Tue, 08 Jul 2025 07:05:00 +0000

Java is the engine behind mission-critical applications and end user experiences. From faster response times to consistent performance, Java can have a significant impact on business results and cloud costs.

Join Azul and leading voices from the Java community for Prime Time, a dynamic virtual event dedicated to innovations, strategies, and real-world insights that power high-performance Java estates. No matter where you’re running your apps – on-prem or in the cloud, or if you’re looking to modernize legacy Java workloads – when performance, elasticity, scale and cloud cost matter, Make It Prime.

When ReadyNow Can Only Compile on Traffic Loads

Fri, 04 Jul 2025 19:36:00 +0000

This is the fifth and final blog post in a series on faster Java application warmup with ReadyNow. If you haven’t been following the series, go back to the first blog post, Faster Java Warmup: CRaC versus ReadyNow , and catch up. This post examines how to resolve a situation when traffic loads and gets redirected to an application before ReadyNow has completed compiling and optimizing bytecode.

ReadyNow enables applications to handle load optimally by compiling bytecode to native code shortly after startup. It also optimizes the compiled code by removing unused pathways, inlining, etc. But this compiling and optimizing can’t be fully executed in specific situations before traffic gets redirected to the application.

Improve Your Java Applications’ Startup and Compilation Speed with Optimizer Hub

Fri, 27 Jun 2025 09:35:31 +0000

This is the fourth blog post in a series on faster Java application warmup with ReadyNow. If you haven’t been following the series, go back to the first blog post, Faster Java Warmup: CRaC versus ReadyNow , and catch up. This post examines Optimizer Hub, a set of services external to the JVM within Azul Platform Prime that you can run in your cloud or on-premises environment to improve your applications’ startup and compilation speed*.*

Benchmark and profiling Java with JMH

Tue, 24 Jun 2025 21:49:25 +0000

Introduction: Why JMH?

Performance matters in Java applications, but measuring it accurately is harder than you might think. I’ve seen countless developers try to measure performance by wrapping code in System.currentTimeMillis() calls or using simple timing loops, only to get misleading results due to JVM optimizations, garbage collection, or just mistakes during measurement.

The JVM is incredibly good at optimizing code, sometimes so good that it optimizes away the very code you’re trying to benchmark. Dead code elimination, constant folding, and just-in-time compilation can all skew your measurements in ways that don’t reflect real-world performance.

How to Train ReadyNow to Achieve Optimal Java Performance

Fri, 20 Jun 2025 19:31:00 +0000

This is the third blog post in a series on faster Java application warmup with ReadyNow. If you haven’t been following the series, go back to the first blog post, Faster Java Warmup: CRaC versus ReadyNow , and catch up. This post explains how you can train the ReadyNow feature in Azul Platform Prime to achieve optimal Java performance.

Using a profile log made from a single run is only a first step in Java warmup. ReadyNow learns from previous executions and incrementally improves the warmup time at every new invocation. By using several training runs, you can improve your application’s performance even further. ReadyNow gathers data from training runs and stores it in a profile log, which ensures better performance after the first and subsequent runs.

Your Complete Guide to Diagnose Slow Queries in MongoDB

Tue, 17 Jun 2025 04:06:04 +0000

MongoDB is built to be fast. The real win comes from knowing how to keep it that way, even as your app grows and your data gets more complex.

This tutorial is for those developers and engineers who want to understand how MongoDB behaves when queries or writes slow down. We’re not here to hand you indexing tips or premature advice about schema design. We’re here to walk through the actual tools MongoDB gives you to observe, measure, and reason about query performance, before you start optimizing anything.

How ReadyNow Improves Java Warmup Time

Fri, 13 Jun 2025 07:55:38 +0000

This is the second article in a series on faster Java application warmup. The first blog post, Faster Java Warmup: CRaC versus ReadyNow , explained how CRaC and ReadyNow use different methods to achieve faster Java warmup. This post takes a deeper look into how ReadyNow improves Java warmup time and reduces latency.

ReadyNow in Azul Zing Builds of OpenJDK (Zing) helps Java applications reach their optimal performance much faster after the startup of the JVM. Using a text file containing the history of compiler decisions from a previous run, it can reduce the application’s total Java warmup time.

Faster Java Warmup: CRaC versus ReadyNow

Fri, 06 Jun 2025 17:23:00 +0000

This is the first blog post in a series on faster Java application warmup with ReadyNow.
Azul has developed different solutions to help achieve faster Java application warmup, including Coordinated Restore at Checkpoint (CRaC) and ReadyNow. While CRaC and ReadyNow aim to solve the same challenge, they take different approaches. This post explains the differences.

One of the challenges in a Java system is application warmup.

Java is the beating heart of many applications. It powers countless applications, from small business processes on a single machine to massive clusters handling vast amounts of data and transactions. Azul optimizes performance, especially Java warmup in complex setups and time-sensitive use cases.

10 Best Practises For Jakarta EE Performance Optimization

Thu, 29 May 2025 13:44:01 +0000

With this article, we start a series where we compiled 10 best practices for performance optimizations and suggestions how to implement them using Jakarta EE & Eclipse GlassFish .

Enjoy reading this initial overview and watching the video about performance tuning Java applications, and stay tuned for upcoming articles from our OmniFish team that will go into details about each best practice.

To make your Jakarta EE applications faster and more efficient, here are 10 proven best practices you can easily implement:

Optimizing the Garbage Collector when Migrating Cloud Workloads

Wed, 16 Apr 2025 10:27:49 +0000

You might associate Arm primarily with smartphones and the Java-based Android runtime. However, OpenJDK has supported AArch64 on Linux since 2014— before Arm-based cloud instances were widely available. Fast forward a decade and major cloud providers have their own Arm-based instances like AWS Graviton, Microsoft Azure Cobalt, and others, prompting many organizations to migrate Java workloads from x86 to multi-architecture environments.

A multi-architecture deployment shift allows an organization to be adaptable and choose the architecture with the ideal price to performance ratio. Large independent software vendors, such as Uber, are already making this transition .

Building JavaFX Native Images

Tue, 15 Apr 2025 09:57:48 +0000

Combining JavaFX-based applications with GraalVM Native Image will enable you to create platform-specific executables that don’t require the JVM to run.

In this article, we will look into two ways of turning JavaFX applications into native images: manually and with the Maven plugin. We will also learn to integrate this process into the CI/CD pipeline with GitHub Actions.

This article was originally published here .

The code for the project I use in this article is available on GitHub . It was built using Liberica JDK Full that includes an OpenJFX bundle. It facilitates developing and building JavaFX applications as there’s no need to add separate dependencies for JavaFX.

A Glance into JFR Class and Method Tagging

Mon, 17 Feb 2025 09:26:02 +0000

Ever wonder how the JDK Flight Recorder (JFR) keeps track of the classes and methods it has collected for stack traces and more?

In this short article, I’ll explore JFR tagging and how it works in the OpenJDK.

Warp: the new CRaC engine

Wed, 18 Dec 2024 16:04:48 +0000

Many regular Foojay readers are already familiar with project CRaC - a technology that can checkpoint (suspend) running Java application into a snapshot image and later restore it to the already warmed-up state. The most common motivation for this is significantly faster startup than if the application (and JVM) started normally. Traditionally this was supported by CRIU (Checkpoint and Restore in Userspace), coming with the burden of root privileges required for execution. Since Azul Zulu October 2024 release, this pain-point can be gone: meet Warp.

Speed up your Spring Batch with Native Image and GraalVM

Tue, 10 Dec 2024 15:47:53 +0000

Spring Batch is often used for data processing jobs that don’t run continuously. Instead, they start, process, and stop,which makes them a perfect candidate for GraalVM Native Image. Unlike traditional Java applications that require a long JVM startup time, Native Images execute almost instantly, giving a significant performance boost.

In this article, you’ll learn how to build a Spring Batch application that reads a CSV file, logs its content, and writes it to a PostgreSQL database.We’ll see how to compile it into a Native Image using GraalVM , and most importantly**, we’ll benchmark the difference between** running it as a traditional JAR and as a native binary.

How Organizations Became Stuck on Outdated Java Versions

Wed, 27 Nov 2024 15:46:16 +0000

My recent article “Why Java 8 is a Ticking Time Bomb Hiding Within Your Organization” triggered quit some reactions… and so I went a step further and asked on social media: “Why is your company still on Java 8 (or older)? And why did you never move to 9, 10,… and got stuck on this outdated version?”

Here is a summary of what I learned from the reactions!

Reasons to Stick to 8

Of course, there are many reasons why some projects deliberately are kept on Java 8 or don’t succeed on moving to a newer version.

Why Java 8 is a Ticking Time Bomb Hiding Within Your Organization

Fri, 15 Nov 2024 11:16:00 +0000

When I spoke to developers at Devoxx in Belgium in October, I was surprised to learn how many of them are maintaining systems that are still running on Java 8 (released in 2014). One of them even still has a Java 5 application in production, with a runtime of 20 years old!

I know I’m biased, as I experiment extensively with the latest Java versions to learn what improvements they bring. But it hurts my heart to think of all those developers maintaining old systems, missing out on all the coding and performance improvements that newer versions offer. In this post, I want to highlight some of the many reasons why staying on Java 8 is a ticking time bomb…

Book Review: Mastering the Java Virtual Machine

Fri, 18 Oct 2024 13:54:49 +0000

Otávio Santana’s “Mastering the Java Virtual Machine” takes readers on an insightful journey through the inner workings of the JVM. As I read this book, I found myself reconnecting with the fundamentals of Java programming while also discovering new depths of understanding.

The book strikes a perfect balance between nostalgia and innovation. It reminded me of my early programming days, while also introducing cutting-edge concepts that are crucial for modern Java development. Santana uses clever technical metaphors to make complex JVM internals more accessible, bridging the gap between theory and practical application.

How to profile a performance issue using Spring Boot profiling tools

Mon, 02 Sep 2024 09:56:13 +0000

In today’s fast-paced development environment, ensuring the performance and reliability of your services is critical. Imagine you are part of a team responsible for several services essential to both internal teams and external customers. These services are the backbone of various business operations, and any downtime or performance degradation can have significant repercussions.{#c79c}

Now, picture this scenario: your team has not yet implemented a robust monitoring and observability system. One day, you start receiving emails and messages from frustrated clients reporting that your service is down. Panic sets in as your team tries to figure out what went wrong. Without proper monitoring tools, finding the root cause of issues in production is challenging. Persistent downtime increases pressure, affecting business operations and customer satisfaction.{#acf3}

Unsupported OpenJDK Distributions are at Risk of Non-Compliance with DORA

Mon, 26 Aug 2024 12:24:05 +0000

For the EU Digital Operations Resilience Act (DORA) to have any meaning at all in the context of OpenJDK (and surely it must have application there since it is explicitly focused on “ICT Assets”, which it defines as broadly as possible as “a software or hardware asset in the network and information systems used by a financial entity”), it can only be interpreted to, at the very least, very strongly encourage the usage of supported OpenJDK distributions.

Running JavaFX applications on ARM with Azul Zulu

Thu, 22 Aug 2024 08:51:57 +0000

Since the April release of Azul Zulu Builds of OpenJDK, packages with JavaFX support for ARM 64-bit systems have been available.

As ARM processors are the “core” of most embedded systems, these runtimes provide the additional benefit of bringing user interface development into the Java space. Having your full code base, from server to end device, based on the same Java code and dependencies, brings many improvements in total cost, development approach, and test and deployment strategies.

Connecting Resilience to Performance in Relation to OpenJDK

Thu, 22 Aug 2024 08:22:37 +0000

When considering the connection between performance and resilience in Java, especially in the context of OpenJDK distributions, specific distributions—like Azul Platform Prime , which includes Azul Zing, an enhanced build of OpenJDK for superior performance, consistency, and efficiency—offer unique features that can significantly influence how these two aspects are managed.

The Digital Operational Resilience Act (DORA) by the European Union adds another layer of importance to these considerations, particularly for financial institutions operating within the EU, regardless of whether they are themselves EU-based institutions .

The Impact of the EU DORA Act on Non-EU Financial Organizations

Wed, 14 Aug 2024 05:33:09 +0000

The EU Digital Operational Resilience Act (DORA) is a significant regulatory framework designed to strengthen the digital resilience of financial institutions within the European Union.

While the primary focus of DORA is on EU-based entities, its impact extends beyond the EU’s borders, particularly to financial organizations outside the EU that have business ties with the region.

Here’s how DORA impacts financial organizations outside the EU.

1. Third-Party Service Providers

Scope of Regulation. DORA covers not just financial entities within the EU but also third-party service providers, including Cloud services, software providers, and IT services. If these providers serve EU financial institutions, they must comply with DORA’s requirements, even if they are based outside the EU.
Increased Compliance Costs. Non-EU service providers might need to invest in compliance infrastructure to meet DORA standards, which include stringent cybersecurity measures, operational resilience requirements, and incident reporting protocols.
Operational Changes. These providers may need to adapt their operations to comply with DORA’s requirements, potentially impacting service delivery, pricing, and contractual arrangements with their EU clients.

2. Cross-Border Operations

EU Subsidiaries. Non-EU financial organizations with subsidiaries or branches in the EU must ensure that these entities comply with DORA. This might require significant changes in internal processes, governance structures, and IT systems.
Data Protection and Transfer. DORA’s focus on operational resilience and cybersecurity intersects with data protection regulations. Non-EU organizations must ensure that data transfers and processing are compliant with EU standards, which could involve changes in data management practices.

3. Competitive Pressure

Market Access. To maintain or gain access to the EU market, non-EU financial organizations must align with DORA’s requirements. Failure to comply might restrict their ability to operate within the EU or provide services to EU-based clients.
Reputation and Trust. Organizations that proactively comply with DORA may gain a competitive edge by being seen as trustworthy and secure partners. Conversely, those that lag may face reputational risks, especially in a market increasingly focused on cybersecurity and operational resilience.

4. Indirect Impact Through Business Relationships

Supply Chain Scrutiny. DORA requires EU financial entities to ensure that their supply chain, including non-EU entities, adheres to operational resilience standards. Non-EU organizations in these supply chains may face increased scrutiny and pressure to comply with DORA, indirectly impacting their operations and costs.
Contractual Obligations. Financial institutions in the EU may impose new contractual obligations on non-EU partners to ensure DORA compliance. This could lead to renegotiation of contracts and increased legal and operational overheads for non-EU entities.

5. Global Regulatory Influence

Precedent for Other Jurisdictions. DORA could set a precedent, encouraging other jurisdictions to adopt similar regulatory frameworks. Non-EU financial organizations may find themselves needing to adapt to a broader wave of operational resilience regulations globally, beyond just the EU.

6. Impact on Financial Services Market

Barrier to Entry. DORA’s stringent requirements might act as a barrier to entry for smaller or less-resourced non-EU financial firms seeking to enter the EU market, potentially limiting competition.
Innovation and Fintech. While aiming to enhance security, DORA may also slow down innovation, as non-EU fintech firms might find the compliance burden heavy, possibly leading to a more cautious approach in launching new products or services in the EU.

Summary

The EU DORA Act significantly impacts financial organizations outside the EU, especially those providing services to or operating within the EU.

Consequences of DORA on Java and OpenJDK with Azul

Fri, 02 Aug 2024 13:49:44 +0000

The EU’s Digital Operational Resilience Act (DORA) is a regulatory framework aimed at enhancing the digital operational resilience of financial institutions within the European Union.

Its primary goal is to ensure that financial entities can withstand, respond to, and recover from all types of ICT-related disruptions and threats, such as cyberattacks.

DORA establishes a uniform set of requirements for managing ICT risks across the financial sector, promoting a harmonized approach to digital resilience.

The Impact of the Digital Operational Resilience Act (DORA) on Java Investment with Azul

Sun, 14 Jul 2024 13:26:13 +0000

The Digital Operational Resilience Act (DORA) , Regulation (EU) 2022/2554 ,is a key piece of European Union legislation focused on strengthening the resilience of the financial sector against digital operational risks, such as cyber attacks and other ICT-related disruptions.

DORA is part of the broader Digital Finance Package introduced by the European Commission to enable innovation and competition in the financial sector while ensuring its security and resilience.

It is focused on enhancing ICT risk management, strengthening cybersecurity, ensuring continuity and recovery, managing risks arising from dependencies on third-party ICT service providers, and incident reporting.

A Beginner's Guide to IntelliJ Profiler

Thu, 04 Jul 2024 06:26:35 +0000

Read in other languages: 中文 Español Português

Sometimes your app works, but you want to increase performance by boosting its throughput or reducing latency. Other times, you just want to know how code behaves at runtime, determine where the hot spots are, or figure out how a framework operates under the hood.

This is a perfect use case for profilers. They offer a bird’s eye view of arbitrarily large execution chunks, which helps you see problems at scale.

Exploring New Features in JDK 23: Simplifying Java with Module Import Declarations with JEP 476

Thu, 20 Jun 2024 16:14:08 +0000

As Java evolves, simplifying code and improving developer productivity remain priorities.

JEP 476 introduces a new feature in JDK 23: Module Import Declarations.

This feature aims to streamline the process of importing multiple packages from a module, enhancing code readability and reducing boilerplate.

What is JEP 476?

JEP 476 proposes the ability to import all packages exported by a module with a single declaration. This is particularly useful for developers who frequently use multiple packages from the same module, as it eliminates the need for numerous individual import statements.

Five Java Developer Must-Haves For Ultra-Fast Startup Solutions

Wed, 29 May 2024 20:15:45 +0000

Faster Java startup must not compromise developer experience, throughput performance, or security. We discuss how we achieved this with Liberty InstantOn.

By Vijay Sundaresan, Thomas Watson, Laura Cowen

Many solutions that promise ultra-fast startup times for serverless Java apps force you to compromise on developer experience, throughput performance, or security. We’ll show you how to get ultra-fast startup of your Java apps without these compromises.

Say, for example, you’re writing a Java web service that provides a catalog of items that your business sells. At quiet times, your application needs to stop all unneeded instances of the catalog service so that your business is not paying unnecessary cloud bills; at busy times, your application needs to rapidly spin up more instances so that your customers get instantaneous response times on your website. This is “scale-to-zero,” and your application needs to do it fast.

Indexing all of Wikipedia, on a laptop

Wed, 29 May 2024 15:54:32 +0000

In November, Cohere released a dataset containing all of Wikipedia , chunked and embedded to vectors with their multilingual-v3 model .

Computing this many embeddings yourself would cost in the neighborhood of $5000, so the public release of this dataset makes creating a semantic, vector-based index of Wikipedia practical for an individual for the first time.

Here’s what we’re building:

You can try searching the completed index on a public demo instance here .

Exploring Cost-Effective Solutions for Stateful Rest Services

Mon, 27 May 2024 13:13:02 +0000

A Case Study with IBM Cloud Code Engine, EclipseStore, and IBM Cloud Object Storage

In the dynamic realm of cloud computing, finding cost-effective solutions for stateful rest services that don’t necessarily require scaling can be a nuanced challenge.

In this article, we’ll take a pragmatic look at a use case leveraging IBM Cloud Code Engine , EclipseStore , and IBM Cloud Object Storage (COS) . The goal is to shed light on how this can be a practical and economical alternative, particularly when scalability is not a primary concern.

Improve DevOps Productivity with Azul Intelligence Cloud for Any JVM

Fri, 24 May 2024 09:46:34 +0000

For decades DevOps teams have been under pressure to do four things: make software faster, make it cheaper, keep it secure, and accelerate time to market.

But with fewer engineering resources, enterprises that use Java must find a way to speed up application innovation and fortify application security across their entire Java estate more efficiently.

The rewards (and costs of not doing so) are high – companies in the top quartile of McKinsey’s Developer Velocity Index (DVI) perform significantly higher than bottom-quartile companies:

Oracle Alternatives Survey & Report

Mon, 13 May 2024 19:27:51 +0000

Azul is planning to issue an Oracle Java “alternatives” Report in late July, and would like your help to complete the survey.

The focus of this report is to explore the following themes:

highlight the frictions created by Oracle with their pricing policies and tactics
show whether customers are in fact moving off of Oracle Java to OpenJDK alternatives
prove the extent to which customers are willing to pay for commercial support and application migration expertise

Below is the link to the survey.

How to improve your spring boot skills

Wed, 20 Mar 2024 15:10:29 +0000

Does anyone else ever feel overwhelmed by Spring Boot? With a rich set of options and eco-system libraries on the one hand, and a very opinionated framework on the other, I often spend considerable time deciphering the “Spring Way” of doing things. I’ve been working with Spring Boot for over three years, yet there are moments when I sense I’m not fully harnessing the capabilities of this remarkable framework and that I need to improve my Spring Boot skills.

foojay – 12 Lessons Learned From Doing The 1BRC Challenge

Thu, 22 Feb 2024 10:44:56 +0000

The One Billion Row Challenge or 1BRC or 1️⃣🐝🏎 was a challenge to read a CSV file of one billion rows with “station name;temperature” data and compute the min/average/max temperature per weather station as fast as possible.

If you want to know what is the fastest algorithm, you can go the the 1BRC page . But the real answer is “it depends”.

It depends:

The machine you’re running it on
How far are you ready to use hacks in your code
The JVM
The data in the file

It works on my machine

or to be more precise, it’s faster on my machine.

Cloud Cost Optimization Is Hard, Java Can Help

Wed, 21 Feb 2024 12:07:37 +0000

In my recent conversation with William Fellows, Research Director at S&P Global Market Research, we discussed ways to reduce cloud waste specifically for Java workloads. After all, cloud cost optimization is hard.

A large delta is growing between budgeted and actual spending. Top areas for spending are cloud integration and modernization services, security and compliance monitoring, and application modernization – specifically applications written in Java.

Minimize costs utilizing the cloud with Spring-Data-Eclipse-Store

Tue, 13 Feb 2024 15:26:37 +0000

Sooner or later any Spring application needs to store data. And of course, the first and easiest move is to utilize Spring Data JPA . You can set up your data storage without knowing which relational database you will use in production and simply start coding without worrying about that.

It is the easiest and most convenient way to store data (in a relational database like PostgreSQL), yet in the cloud environment it is also an expensive way. Pricing at AWS RDS starts at 30$/month with tiny-Instances and always have fixed monthly costs regardless of its usage.

Profiling Maven Projects with my IntelliJ Profiler Plugin

Thu, 14 Dec 2023 10:41:34 +0000

Or: I just released version 0.0.11 with a cool new feature that I can’t wait to tell you about…

According to the recent JetBrains survey , most people use Maven as their build system and build Spring Boot applications with Java. Yet my profiling plugin for IntelliJ only supports profiling pure Java run configurations. Configurations where the JVM gets passed the main class to run. This is great for tiny examples where you directly right-click on the main method and profile the whole application using the context menu:

Chopping the monolith in a smarter way

Thu, 07 Dec 2023 07:40:55 +0000

In my previous post Chopping the Monolith , I explained that some parts of a monolith are pretty stable and only the fast-changing parts are worth being “chopped.”

I turned the post into a talk and presented it at several conferences. I think it’s pretty well received; I believe it’s because most developers understand, or have direct experience, that microservices are not a good fit for traditional organizations, as per Conway’s Law .

Custom Events in the Blocky World: Using JFR in Minecraft

Tue, 28 Nov 2023 19:12:50 +0000

I was searching for some JFR-related settings on the internet when I stumbled upon the /jfr command that exists in Minecraft :

This, of course, intrigued me, especially as Minecraft apparently adds some custom JFR events:

So I had to check it out. I downloaded and started the Java server , got a demo account, and connected to my local instance. This works with a demo account when you launch the demo world, enable the cheat mode in the settings, kick yourself via “/kick @p,” and then select your own server. I found this via this bug report .

Custom JFR Events: A Short Introduction

Sun, 26 Nov 2023 21:08:03 +0000

JDK Flight Recorder (JFR) is one of the two prominent open-source profilers for the OpenJDK (besides async-profiler ).

It offers many features (see Profiling Talks ) and the ability to observe lots of information by recording over one hundred different events.

If you want to know more about the existing events, visit my JFR Event Collection website (related blog post ):

Besides these built-in events, JFR allows you to implement your events to record custom information directly in your profiling file.

Putting JFR into Context

Thu, 02 Nov 2023 14:03:25 +0000

Have you ever wanted to bring your JFR events into context? Adding information on sessions, user IDs, and more can improve your ability to make sense of all the events in your profile.

Currently, we can only add context by creating custom JFR events, as I presented in my Profiling Talks :

More here: https://mostlynerdless.de/profiling-talks/

We can use these custom events to store away the information and later relate them to all the other events by using the event’s time, duration, and thread. This works out-of-the-box but has one major problem: Relating events is quite fuzzy, as time stamps are not as accurate (see JFR Timestamps and System.nanoTime), and we do all of this in post-processing.

Controlling JIT Compiler Overhead to Avoid CPU Autoscaling

Wed, 01 Nov 2023 07:54:33 +0000

Today’s modern, containerized, elastically scaling Java clusters often rely on CPU utilization as the main trigger for scaling out new instances. Imperfect as this metric may be, it is ubiquitous to scale out new instances based on CPU utilization going over some limit. Often that limit is surprisingly low, somewhere around 40 to 50%.

Azul Platform Prime replaces OpenJDK’s HotSpot C2 compiler with the Falcon JIT compiler. Falcon generates much faster code than OpenJDK, allowing you to handle more transactions in a container before hitting your CPU utilization limit. And, Prime’s smoother and more consistent execution allows you to safely raise your CPU utilization to 60-70%, resulting in massive gains in carrying capacity for each container and lower overall cloud costs to handle your total Java workload.

Resizing images on-the-fly

Mon, 23 Oct 2023 18:01:05 +0000

As a web architect, one of the many issues is asset management. And the most significant issue in assets is images. A naive approach would be to set an image and let the browser resize the image via CSS:

img {
 height: 100%;
 width: 100%;
 object-fit: contain;
}

However, it means that you download the original image. It entails two problems: the size of the original image and the suboptimal browser-based resizing.

Changes Included in the Stable release 23.08 of Azul Zulu Prime Builds of OpenJDK

Wed, 11 Oct 2023 07:03:09 +0000

The latest Long Term Support (LTS) version of OpenJDK was released on September 19, 2023. Below is an overview of all the combined improvements in the latest Azul Prime Builds of OpenJDK, stable release, 23.08.01.0.

Azul Platform Prime is a modern, TCK-compliant Java platform based on OpenJDK. It provides consistently low response latency of your Java workloads, higher total throughput and carrying capacity, faster warmup, and infrastructure savings, achieved thanks to the C4 pauseless garbage collector , Falcon JIT compiler , and other technologies created by Azul. Prime Builds are available in two versions, either for evaluation or production use:

Web Crawling in Java: Classical Threads and Virtual Threads

Fri, 29 Sep 2023 12:23:48 +0000

In today’s fast-paced digital world, web crawling is a cornerstone technology behind search engines, data analysis tools, and various other applications.

Java, a language known for its robustness and scalability, offers intriguing ways to implement web crawling.

Yet, the thread model you choose can make a world of difference.

This article unfolds a compelling narrative around web crawling in Java, contrasting classical threads with their newer counterpart: virtual threads.

Environment Setup

Before diving into the code and its intricate comparisons, ensure you have JDK 21 installed on your system. If you’re using a Unix-based system, SDKMAN! It makes this simple. Just open your terminal and run curl -s "https://get.sdkman.io" | bash to install SDKMAN!, followed by source "$HOME/.sdkman/bin/sdkman-init.sh" to initialize it. Finally, install JDK 21 with sdk install java 21.0.0-<vendor>, replacing <vendor> with your preferred vendor (e.g., zulu, adopt).

C2 Might Be Slowing Down Your Builds

Thu, 28 Sep 2023 09:55:13 +0000

At the JavaForumNord two weeks ago, I had a friendly chat with Karl Heinz Marbaise (Chairman of the Apache Maven Project), where he mentioned that he wanted to start profiling Maven. This sounded interesting, so I started looking into the performance and bottlenecks of Maven. I began by using the Maven build of maven itself as a starting point (excluding the tests). The following is my first observation related to Maven builds in CIs.

Memory Management in Java: An Introduction

Wed, 27 Sep 2023 13:47:28 +0000

Understanding memory management in Java, and particularly the role of object allocation is essential when optimising system performance.

In Java, memory management is an automatic process that is managed by the Java Virtual Machine (JVM), and one that does not need explicit intervention. Java, being a block-structured language, uses a model where its memory is divided into two main types: stack and heap.

Local variables and method parameters use memory based on a ‘stack’. This area of memory grows and shrinks automatically when a code block or method is entered or exited, respectively. In situations where a request is made to the system for an amount of memory, whose size is only known at runtime, or when creating an object, these requests are usually satisfied by an area of the process’ memory known as ‘dynamic memory’ or the ‘heap’. Strictly speaking – there is an occasion when an object that may be destined for the heap is instead written to the stack, however we will leave this discussion for a later document.

Building Real-Time Applications to Process Wikimedia Streams

Fri, 15 Sep 2023 14:33:16 +0000

In this tutorial, developers, solution architects, and data engineers can learn how to build high-performance, scalable, and fault-tolerant applications that react to real-time data using Kafka and Hazelcast.

We will be using Wikimedia as a real-time data source. Wikimedia provides various streams and APIs (Application Programming Interfaces) to access real-time data about edits and changes made to their projects.

For example, this source provides a continuous stream of updates on recent changes, such as new edits or additions to Wikipedia articles. Developers and solution architects often use such streams to monitor and analyze the activity on Wikimedia projects in real-time or to build applications that rely on this data, like this tutorial.

Chronicle Services: Building Fast Microservices with Java

Wed, 13 Sep 2023 13:47:47 +0000

Low Latency?

In computing, latency is defined as the length of time to perform some task. This could be the time it takes to respond to an interrupt from hardware or the time it takes for a message sent by one component to be available to its recipient.

In many cases, latency is not seen as a primary non-functional concern when designing an application, even when considering performance. Most of the time, after all, computers seem to do their work at speeds that are well beyond human perception, typically using scales of milliseconds, microseconds, or even nanoseconds.

Load testing - shoot your application with Gatling

Wed, 06 Sep 2023 09:32:29 +0000

What is load testing?

Load testing entails testing how our application performs under a significant load so we can be certain it behaves as expected when there’s an influx of users.

Or at least so we know what it can cope it, and at what point we might potentially need to take action.

After all, it might not (only) be the code that’s the issue.

This is a process that requires quite a bit of cooperation between testers, developers, and those using it to properly determine the scenarios, and a smooth & swift feedback loop is important to make sure our solutions work properly. And it will likely be some of the most expensive tests given both the people involved and the need for a testing environment that’s representative of the production configuration.

Azul Enhances ReadyNow to Solve Java’s Warmup & Cloud Costs

Wed, 30 Aug 2023 21:30:14 +0000

Azul Platform Prime’s ReadyNow technology continuously learns from application usage across fleets of Java Virtual Machines (JVMs) and automatically selects the best warmup optimization patterns.
ReadyNow Orchestrator delivers the highest possible optimized code speed at warmup while making deployment easier for containerized Java workloads and CI/CD pipelines, and requires no changes to Java applications.
The combination of ReadyNow and ReadyNow Orchestrator allow Azul Platform Prime customers to optimize cloud costs by improving utilization levels, reducing compute instances needed while maintaining throughput and response SLAs, and more efficiently leverage cloud elasticity.

SUNNYVALE, Calif. — August 30, 2023 — Azul , the only company 100% focused on Java, today announced ReadyNow Orchestrator(RNO), a new feature of Azul Platform Prime powered by ReadyNow technology that slashes warmup time for Java applications, enabling significant improvements to operational efficiencies and optimization of cloud costs. Available now, ReadyNow Orchestrator requires no changes to Java applications and is included at no additional charge for Azul Platform Prime customers.

Thread-Safe Counter in Java: A Comprehensive Guide

Thu, 17 Aug 2023 06:59:29 +0000

In this tutorial, we will explore the concept of thread safety in Java, specifically focusing on a simple counter.

We will start by understanding why a basic counter is not safe for multiple threads; then, we will progressively enhance its thread safety using different techniques such as synchronization, locks, Unsafe, VarHandle, and finally, AtomicInteger.

We will be referencing the code from this repository throughout the tutorial.

Before we dive into the different implementations, let’s define a Counter interface that all our counter classes will implement.

AsyncGetCallTrace Reworked: Frame by Frame Iterative Touch!

Thu, 10 Aug 2023 09:43:33 +0000

AsyncGetCallTrace is an API to obtain the top n Java frames of a thread asynchronously in a signal handler.

This API is widely used but has its problems, see JEP 435 and my various articles on Foojay.io .

My original approach with my JEP proposal was to build a replacement of the API, which could be used as a drop-in for AsyncGetCallTrace. Still a single method that populates a preallocated frame list:

Book Review: "OpenJDK Migration for Dummies"

Fri, 04 Aug 2023 09:02:46 +0000

The subject of Java licensing and OpenJDK migration is complex and vital to many software engineers. I am no different. It’s a topic often shrouded in legal jargon and technicalities, making it difficult to approach.

“OpenJDK Migration for Dummies” bySimon Ritter offers a fresh perspective, breaking down these challenges into digestible segments. (Get it for free here. )

[

](https://www.azul.com/openjdk-migration-for-dummies/ )

The book directly speaks to my core expertise in Java, providing clarity and guidance.

The IKEA Effect

Wed, 26 Jul 2023 13:00:04 +0000

The IKEA effect is a fascinating phenomenon whereby consumers place a (sometimes disproportionately) higher value on things that they have either made themselves, or to which they’ve contributed towards making.

This can have a significant influence on perceived value – to the extent that people might value imperfect things they’ve helped create, more than they would value the equivalent, perfect, but ready-made, product. Those who have pained memories of tussling with Allan keys and occasionally incomprehensible schematics for self-assembly furniture will no doubt have raised eyebrows. Of course, the effect only applies to items that are successfully assembled, of course. If people fail to build an item using the instructions provided, or it takes too long or is too difficult, due either to the complexity of the instructions or the inexperience of the user, then they do not ascribe the same value to the item.

Real-time Stream Processing with Hazelcast and Redpanda

Tue, 25 Jul 2023 09:33:27 +0000

In this tutorial, we explore the powerful combination of Hazelcast and Redpanda to build high-performance, scalable, and fault-tolerant applications that react to real-time data.

Redpanda is a streaming data platform designed to handle high-throughput, real-time data streams. Compatible with Kafka APIs, Redpanda provides a highly performant and scalable alternative to Apache Kafka. Redpanda’s unique architecture enables it to handle millions of messages per second while ensuring low latency, fault tolerance, and seamless scalability.

How we developed the Eclipse OpenJ9 CRIU Support for fast Java start-up

Wed, 19 Jul 2023 15:33:39 +0000

Checkpointing and restoring the JVM makes applications run faster because all the startup work is done before deployment. This means that in serverless cloud applications, the end-user of the application perceives no delay when the application starts. You can try it out now with your own apps on Open Liberty with Eclipse OpenJ9. But if you want to know more, here’s how we tackled the technical challenges of developing the Eclipse OpenJ9 CRIU Support.

A Dissection of Java JDBC to PostgreSQL, Part 2: Batching

Tue, 04 Jul 2023 13:56:41 +0000

This is the second part of a series where I look into how Java JDBC connections to PostgreSQL are working, to understand how to optimally implement them.

If you’ve landed on this article, it might be a good idea to read my first article as well, which gives an introduction and shares how JDBC communicates with PostgreSQL using simple and extended protocols.

This new article specifically explores batching. Batching for PostgreSQL JDBC is a property of the extended protocol. It uniquely allows you to send multiple statements in a single request.

The Curious Case of Different Runtimes

Fri, 30 Jun 2023 08:12:09 +0000

While running some final tests, we noticed extremely erratic runtime behavior. It was hard to reproduce but very annoying because it means that the application runtime goes up from 5 to almost 14 min. This article tries to show how we diagnosed it and condensed it down to a few test cases. These might hopefully help us to provide some answers. Maybe, but only maybe, we discovered a defect or at least strange edge-case in the JVM.

Optimise CPU Performance Through Isolation and System Tuning

Thu, 29 Jun 2023 06:36:39 +0000

What are the challenges of tuning your CPU and system for optimal performance with Linux, and how does Chronicle Tune address them?

CPU isolation and efficient system management are critical for any application which requires low-latency and high-performance computing. These measures are especially important for high-frequency trading systems, where split-second decisions on buying and selling stocks must be made.

To achieve this level of performance, such systems require dedicated CPU cores that are free from interruptions by other processes, together with wider system tuning.

The Anatomy of a JVM

Fri, 16 Jun 2023 07:57:44 +0000

Java is not only a programming language.

It’s an “umbrella” that covers tools, runtimes, and even a whole community.

In this article, we want to look at one part under the umbrella: the Java Virtual Machine.

What is it exactly, and how does it work?

Java is consistently in the top of most popular languages. The real reason for this is not the language itself but the JVM. And the power that it gives to the developer.

Simon Ritter, Deputy CTO, Azul

Unique Identifiers Based on Timestamps in Distributed Applications

Wed, 14 Jun 2023 11:22:03 +0000

At Chronicle we build applications that must process very high numbers of events with minimum latency. Generating unique IDs for these events using the traditional method of UUIDs introduces an unacceptable time overhead into our applications, so an alternative approach is needed.

I recently wrote an article on how timestamps can be used as unique identifiers, as they are much cheaper to generate than other methods of generating unique identifiers, taking a fraction of a microsecond.

Breaking the Code: How Chris Newland is Changing the Game in JVM Performance!

Mon, 12 Jun 2023 08:44:27 +0000

We’re excited to introduce you to Chris Newland, an industry veteran and dedicated JVM performance specialist.

Chris has a long-standing history of contributing to the Java community with open-source tools aimed at enhancing Java and JVM understanding.

Among his well-known tools is JITWatch, which has gained significant recognition and use in the JVM community.

In this conversation, we delve into Chris’s journey, his motivations, and his thoughts on JVM performance, Java ecosystem changes, and the role of AI in software development.

State of Java Survey

Tue, 23 May 2023 05:47:41 +0000

Do you ever wonder what OpenJDK distributions and what Java versions your peers are using? Java-based infrastructures and languages? How many are running Java applications in public clouds?

THE SURVEY DESCRIBED BELOW IS NOW COMPLETE, NO MORE RESPONSES CAN BE ACCEPTED.

Azul has been gathering all that data from a survey of Java users, running until 6:30pm CT on June 15, 2023. If you want to participate, the survey takes about 10 minutes, and we’ll hook you up with the report after the survey is complete. Plus you’ll be helping to add to our collective knowledge. Plus you’ll be entered into a drawing to win prizes like an Apple MacBook Pro laptop or a set of AirPods.

Foojay Podcast #23: Java Profiling and Performance

Mon, 22 May 2023 10:23:52 +0000

How do you get the maximum performance out of your Java application?

And how to use profiling to find the bottlenecks?

Let’s learn all about it in this podcast, with Heinz Kabutz, Marcus Lagergren, Chris Newland, and Frank Delporte!

Java profiling is a crucial technique for measuring and improving the performance of applications.

It helps identify bottlenecks, memory leaks, and other application performance issues.

There are various challenges with using Java profiling, and the need for profiling depends on the complexity of the application and the performance requirements.

Unlocking Reproducible Profiler Tests

Fri, 19 May 2023 09:02:33 +0000

In my last article, Using Async-Profiler and Jattach Programmatically with AP-Loader , I hinted that I’m currently working on a test library for writing better profiling API tests.

The library is still work-in-progress, but it already allows you to write profiling API tests in plain Java:

private int innerASGCT2() {
 new Tracer().runASGCT().assertTrue(
 Frame.hasMethod(0, "innerASGCT2", "()I"), 
 Frame.hasMethod(1, "testRunASGCT2"));
 return 0;
}

@Test
public void testRunASGCT2() {
 innerASGCT2();
}

This test case checks that calling AsyncGetCallTrace gives the correct result in this specific example. The test library allows you to write tests comparing the returns of multiple GetStackTrace, AsyncGetCallTrace, and AsyncGetStackTrace invocations in different modes and settings. The library can be found as trace-tester on GitHub; I aim to bring it into the OpenJDK later with my JEP.

Enriching Kafka Applications with Contextual Data

Thu, 18 May 2023 15:11:22 +0000

Developing high-performance large-stream processing applications is a challenging task.

Choosing the right tool(s) is crucial to get the job done; as developers, we tend to focus on performance, simplicity, and cost.

However, the cost becomes relatively high if we end up with two or more tools to do the same task.

Simply put, you need to multiply development time, deployment time, and maintenance costs by the number of tools.

Kafka

Kafka is great for event streaming architectures, continuous data integration (ETL), and messaging systems of record (database).

Using Pausers in Event Loops

Wed, 17 May 2023 09:25:23 +0000

Typically in low-latency development, a trade-off must be made between minimising latency and avoiding excessive CPU utilisation.

This article explores how Chronicle’s Pausers can be used to automatically apply a back-off strategy when there is no data to be processed, providing an excellent balance between resource usage and responsive, low-latency, low-jitter applications.

Description of the Problem

In a typical application stack multiple threads are used for servicing events, processing data, pipelining etc.

Reduce Java Application Startup and Warmup Times with CRaC

Tue, 16 May 2023 11:21:12 +0000

When a Java application runs, the JVM goes through the process of loading, initializing, and optimizing the code used by the application, including libraries, frameworks, and other components to reach the optimal performance level.

Each time the application restarts, it has no record or memory of previous times it has run and the work it performed.

As a result, it has to restart, extending valuable startup and warmup times and using precious resources.

TornadoVM: Code Interoperability Mode

Thu, 11 May 2023 07:54:04 +0000

TornadoVM is a programming framework for accelerating Java applications on heterogeneous devices, like multi-core CPUs, GPUs and FPGAs.

Java developers can use the TornadoVM API to prototype Java methods within their code bases for hardware acceleration.

TornadoVM is hardware-agnostic, but the generated code (i.e., kernels) for acceleration can be executed only through the TornadoVM runtime.

This blog outlines the key changes in TornadoVM to enable code interoperability of kernels with other programming languages beyond Java.

Tuning Java Applications for Low Latency on Linux

Wed, 10 May 2023 13:34:13 +0000

Introduction

I have lost count of the number of times I have been told that Java is not a suitable language in which to develop applications where performance is a major consideration. My first response is usually to ask for clarification on what is actually meant by “performance” as two of the most common measures – throughput and latency, sometimes conflict with each other, and approaches to optimise for one may have a detrimental effect on the other.

A Comprehensive Guide to Java Virtual Threads (Part 1)

Tue, 09 May 2023 08:33:12 +0000

Introduction

Java Virtual Threads, also known as lightweight threads, is an exciting new feature introduced in Project Loom.

Virtual threads aim to simplify concurrent programming in Java by providing an efficient and easy-to-use concurrency model.

In this article, we’ll cover the basics of Java Virtual Threads, how they work, why they are beneficial for developers, and how they overcome the limitations of traditional Java threads.

What are Virtual Threads?

Java is made of threads. When we run a Java program, its main method is invoked as the first call frame of the main thread created by the Java launcher. It gives us many things: sequential control flow, local variables, exception handling, single-step debugging, and profiling.

Using Async-Profiler and Jattach Programmatically with AP-Loader

Thu, 04 May 2023 11:45:20 +0000

Using async-profiler and jattach can be quite a hassle. First, you have to download the proper archive from GitHub for your OS and architecture; then, you have to unpack it and place it somewhere.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves, or worse, they depend on a preinstalled version which they do not control.

The Unix Philosophy for Low Latency

Thu, 04 May 2023 08:03:40 +0000

Unix has been around for more than 50 years, and the original design principles must be good enough for it (and its derivative, Linux) to be the most widely used Operating System on the planet – 80% of servers , most supercomputers , and the most deployed OS (Android ). It is also the most popular OS on Mars!

Much of Unix’s success can be attributed to the “Unix Philosophy ” which can be very briefly summarised as:

The Basis of Virtual Threads: Continuations

Fri, 28 Apr 2023 13:38:05 +0000

Virtual threads are lightweight implementations of java.lang.Thread and they promise to write highly scalable concurrent applications. This article turns the spotlight on the Continuations that are the basis of Virtual threads.

Project Loom has been the focus of attention in the Java community since the day it was announced. Java developers were excited by Loom’s promise that, with virtual threads, they could write highly scalable applications that may utilize the hardware optimally, without changing their habits.

Couldn’t we just Use AsyncGetCallTrace in a Separate Thread?

Tue, 25 Apr 2023 05:31:36 +0000

I’m keenly interested in everything related to profiling on the JVM, especially if it is related to AsyncGetCallTrace, this tiny unofficial API that powers most profilers out there, heck, I’m even in the process of adding an improved version to the OpenJDK , AsyncGetStackTrace.

During the discussions on the related JDK enhancement proposal and PRs fixing AsyncGetCallTrace bugs, one thing often arises: Why is AsyncGetCallTrace always called in the signal handler on top of the stack that we want to walk (like in my Writing a Profiler from Scratch series)?
Interaction between the wall-clock sampler thread and the different signal handlers, as currently implemented in async-profiler.

Chronicle FIX: Much More Than a Quick Fix

Wed, 12 Apr 2023 13:55:24 +0000

Many of our customers have upgraded from QuickFIX/J to Chronicle FIX and this article provides some background as to why.

Introduction

QuickFIX/J is free, accessible, supports the FIX standard and is therefore often chosen by the IT team for a first FIX engine.

However, when the business grows, its limitations become clear. The reasons most commonly given to us are:

Throughput and latency
HA/DR functionality
Advanced features e.g. routing and message translation
Global commercial support

Also, some customers engage with us because they already use our open source products e.g. Chronicle Queue, or our enterprise products e.g., Chronicle Queue Enterprise replication, or Chronicle Services EDA/Microservices accelerator.

Analyzing & Tuning Warm-up: Azul Zulu Prime Builds of OpenJDK

Sat, 01 Apr 2023 16:35:31 +0000

Warm-up is the time taken for the Java application to reach the optimum compiled code performance.

It is the task of the Just-in-Time (JIT) compiler to deliver optimal performance by producing optimized compiled code from application bytecode. This article will give you a basic understanding of how JIT compilation works and how to optimize warm-up using Azul Zulu Prime Builds of OpenJDK (Azul Zulu Prime JDK).

This post has been reviewed and extended on July 20th of 2023 thanks to the contributions of Matt Van Order.

Writing a Profiler in 240 Lines of Pure Java

Thu, 30 Mar 2023 07:14:46 +0000

A few months back, I started writing a profiler from scratch, and the code since became the base of my profiler validation tools.

The only problem with this project: I wanted to write a proper non-safepoint-biased profiler from scratch.

This is a noble effort, but it requires lots C/C++/Unix programming which is finicky, and not everyone can read C/C++ code.

For people unfamiliar with safepoint bias: A safepoint is a point in time where the JVM has a known defined state, and all threads have stopped. The JVM itself needs safepoints to do major garbage collections, Class definitions, method deoptimizations, and more. Threads are regularly checking whether they should get into a safepoint, for example, at method entry, exit, or loop backjumps. A profiler that only profiles at a safepoint have an inherent bias because it only includes frames from the locations inside methods where Threads check for a safepoint. The only advantage is that the stack-walking at safepoints is slightly less error-prone, as there are fewer mutations of heap and stack. For more information, consider reading the excellent article Java Safepoint and Async Profiling by Seetha Wenner, the more technical one by JP Bempel , or the classic article Safepoints: Meaning, Side Effects and Overheads by Nitsan Wakart. To conclude: Safepoint-biased profilers don’t give you a holistic view of your application, but can still be helpful to analyze major performance issues where you look at the bigger picture.

Chronicle Wire: Object Marshalling

Wed, 29 Mar 2023 13:35:43 +0000

At Chronicle , we know that efficient code doesn’t just run faster; if it’s using less compute-resource, it may also be cheaper to run.

In particular, distributed cloud applications can benefit from fast, lightweight serialisation.

In this article, we will demonstrate the efficiencies of using Chronicle Wire to encode small Strings into long primitives, with a few step-by-step examples of object marshalling, and show how this can improve the performance of your application’s serialisation.

Foojay Podcast #17: Execute Java Code with TornadoVM

Mon, 27 Mar 2023 08:45:20 +0000

TornadoVM is a programming and execution framework for offloading and running JVM applications on multi-core CPUs, GPUs, and FPGAs.

With the same code, some of your existing program code can be executed hundreds of times faster!

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Failover Client with the Hazelcast Viridian Serverless

Fri, 24 Mar 2023 14:55:42 +0000

Failover is an important feature of systems that rely on near-constant availability.

In Hazelcast, a failover client automatically redirects its traffic to a secondary cluster when the client cannot connect to the primary cluster.

Consider using a failover client with WAN replication as part of your disaster recovery strategy.

In this tutorial, you’ll update the code in a Java client to automatically connect to a secondary, failover cluster if it cannot connect to its original, primary cluster.

Validating Java Profiling APIs

Thu, 16 Mar 2023 14:43:48 +0000

In my last article , I covered a correctness bug in the fundamental Java profiling API AsyncGetCallTrace that I found just by chance.

Now the question is: could we find such bugs automatically?

Potentially uncovering more bugs or being more confident in the absence of errors.

I already wrote code to test the stability of the profiling APIs, testing for the lack of fatal errors, in my jdk-profiling-tester project.

Such tools are invaluable when modifying the API implementation or adding a new API.

Comparing Map.of() and new HashMap() in Java

Thu, 16 Mar 2023 08:16:32 +0000

Java is a popular programming language used for developing a wide range of applications, including web, mobile, and desktop applications.

It provides many useful data structures for developers to use in their programs, one of which is the Map interface.

The Map interface is used to store data in key-value pairs, making it an essential data structure for many applications.

In this article, we will discuss the use of Map.of() and new HashMap<>() in Java, the difference between them, and the benefits of using Map.of().

Efficient Memory Mapping for Terabyte Sparse Files in Java

Wed, 15 Mar 2023 11:50:41 +0000

On Linux, you can create sparse files , where only the pages (of 4 KiB) that are touched utilise either memory or disk space.

This allows you to memory map large virtual regions without worrying about wasted memory or disk

In this program, you can see it reserves 8 TiB (8,192 GiB)

Figure 1. Test 1: Sparse file

Tip: x << y means x × 2y therefore:

1L << 10 = 1 KiB (1024 bytes),
1L << 20 = 1 MiB (10242 bytes),
1L << 30 = 1 GiB (10243 bytes),
1L << 40 = 1 TiB etc

Using multiples of 10 for the shift makes them easier to read.

Java Performance: Ahead-Of-Time versus Just-In-Time

Thu, 09 Mar 2023 08:00:18 +0000

Recently the Azul team attended Devoxx Belgium, one of the biggest Java conferences with over 3,200 visitors.

We talked with many developers and DevOps engineers, and one of the recurring questions was about the difference between Just-In-Time (JIT) and Ahead-Of-Time (AOT) execution of applications.

More specifically, about better JIT performance compared to a native compiled AOT application.

In this post, I give a quick update on both strategies to clarify why you will get different performance results.

Migrating Applications to TornadoVM v0.15 (Part 2)

Sat, 04 Mar 2023 18:38:41 +0000

In the previous blog , we discussed the TornadoVM programming model and showed how programmers can define the parts of their Java applications to be offloaded for hardware acceleration via the TornadoVM API (v0.15).

In this article, we will spotlight all the TornadoVM configurations/operations that regard the execution on the hardware device.

In particular, this blog has the following objectives:

Provide guidelines regarding how programmers can trigger TornadoVM-specific configurations that regard the execution on hardware accelerators.
Provide examples on how to exploit the new operations that are exposed by the new TornadoVM API.

Prerequisites {#h2-0-1-prerequisites}

This blog begins with a prerequisite that a snapshot of a user-defined TaskGraph is captured to an immutable state. This was the final point of the previous blog .

Do you trust profilers? I once did too!

Wed, 01 Mar 2023 13:14:06 +0000

Profilers are great tools in your toolbox, like debuggers, when solving problems with your Java application (I’ve been on a podcast on this topic recently).

I’ll tell you some of their problems and a technique to cope with them in this article.

There are many open-source profilers, most notably JFR/JMC, and async-profiler, that help you to find and fix performance problems.

But they are just software themselves, interwoven with a reasonably large project, the OpenJDK (or OpenJ9, for that matter), and thus suffer from the same problems as the typical problems of the applications they are used to profile:

Web App Startup in 3ms with RIFE2 and GraalVM

Tue, 21 Feb 2023 09:12:55 +0000

RIFE2 applications already launch quickly with a regular JVM thanks merely calling Java methods, lambdas and doing object instantiations at startup. There are no annotations to scan for, nor any declarations or config files to parse and resolve.

The RIFE2 v1.3.0 release introduced experimental support for GraalVM Ahead-Of-Time compilation with native-image, reducing the startup time of the bootstrap project from 177ms to an incredible 3ms.

Try it out yourself

In order to try this out, you can download the latest GraalVM JDK 19 distribution, and follow the steps to install native-image on your machine.

JFR Timestamps and System.nanoTime Foojay.io

Wed, 08 Feb 2023 15:33:34 +0000

Did you ever wonder whether JFR timestamps use the same time source as System.nanoTime?

This is important when you have miscellaneous logging besides JFR events; otherwise, you would not be able to match JFR events and your logging properly.

We assume here that you use System.nanoTime and not less-suited timing information from System.currentTimeMillis().

The journey into this started with a question on the JDK Mission Control slack channel, which led me into a rabbit hole:

Which is the Fastest JVM: OpenJDK or GraalVM?

Wed, 08 Feb 2023 10:51:58 +0000

How is a high-performance, low-latency Java application affected by the JVM version used?

Every nanosecond counts for trading and other applications where messages between two different threads are exchanged in about 250ns!

Read this article and find out which JDK variant comes out at the top!

Benchmarks

This article will use open-source Chronicle Queue to exchange 256-byte messages between two threads whereby all messages are also stored in shared memory (/dev/shm is used to minimise the impact of the disk subsystem).

Using Firefox Profiler beyond the web

Fri, 03 Feb 2023 15:28:55 +0000

This blog post is the base for the second half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

I detailed in my last blog post how the Firefox Profiler can be used to view Java profiling data:

But I’m of course not the only one who uses Firefox Profiler beyond the web because using it has many advantages: You’re essentially getting a prototypical visualization for your data in an afternoon.

Memory Allocation Pacing in Azul Zulu Prime builds of OpenJDK

Fri, 03 Feb 2023 13:29:09 +0000

The Java Virtual Machine (JVM) that runs your Java applications has a Garbage Collector (GC) responsible for recycling memory objects that are no longer needed.

The GC operates by cycles, and running a cycle takes some time.

Azul Zulu Prime uses the C4 Garbage Collector , which runs concurrently with your Java application.

During the GC cycle, the application may outrun the GC and exhaust the memory before the GC completes.

What to Know About Garbage Collection as a Java Developer!

Fri, 03 Feb 2023 13:20:28 +0000

The Garbage Collector is a crucial part of the Java Virtual Machine (JVM) that has an impact on the performance and reliability of your application.

But what is it exactly, and why is it important to understand how it works? If you’re a Java developer, you might ask, “What should I know about Garbage Collection?”

Since I joined Azul as technical writer, it was a real discovery to talk to the engineers who develop such GCs and help companies get the most out of their Java systems.

Firefox Profiler Beyond the Web: IntelliJ plugin for JFR

Thu, 02 Feb 2023 13:13:17 +0000

This blog post is the base of the first half of my upcoming talk at FOSDEM 2023 on the topic “Firefox Profiler beyond the web: Using Firefox Profiler to view Java profiling data .”

For the impatient: Take a look at my Java JFR Profiler IntelliJ plugin to easily profile your application and view JFR files directly in your IDE.

I got involved in the Firefox Profiler development, spending significant portions of my time at SAP in the last half year on it. It has been an exciting ride. I learned a lot and contributed a few features. So I was essentially developing React code when I wasn’t working on ASGST or other OpenJDK-related tools.

Why Core-to-Core Latency Matters

Thu, 02 Feb 2023 11:16:43 +0000

A few years ago we had a global shortage of microchips; now, I feel there is a worldwide shortage of software developers.

Like many other software companies, Chronicle Software is rapidly expanding and interviewing candidates. We usually ask candidates to demonstrate a good knowledge of core Java, then we cover slightly more advanced concepts, such as the use of volatile memory, memory barriers and fences.

While it is important to have a high-level understanding of these concepts when writing concurrent code, it’s surprising how few Java developers with 10+ years of experience have a deep knowledge of the underlying hardware. An initial goal of Java was to “write once, run anywhere”, but does that mean we should not be sympathetic to the hardware?

How to Run a Java Application with CRaC in a Docker Container

Wed, 01 Feb 2023 09:41:11 +0000

CRaC (Coordinated Restore at Checkpoint) is an OpenJDK project that was developed by Azul to solve the problem of “slow” startup times of the Java Virtual Machine in a microservice environment.

The most up-to-date guidelines can be found on “Coordinated Restore at Checkpoint Usage Guidelines ” in the Azul Docs.

When the JVM runs your application code, it does things like interpreting, compiling and optimizing code to make your application run as fast as possible under the given workload. This is great but can take some time and especially when you run short lived microservices you don’t want to wait until the JVM has produced the most optimized code.

AsyncGetStackTrace: A better Stack Trace API for the JVM

Thu, 26 Jan 2023 09:16:06 +0000

This article is the basis for my upcoming talk at FOSDEM 2023, “AsyncGetStackTrace: The Improved Version Of AsyncGetCallTrace (JEP 435),” and is based on JEP Candidate 435.

Consider you want to write a profiler to profile Java applications. Why? Because you think that the existing ones "[…] Are Fucking Terrible" or "[…] Broken" . Or you want to start a blog series on writing a profiler from scratch to learn their inner workings (hi there,**regular readers).

How Does Kafka Perform When You Need Low Latency?

Wed, 18 Jan 2023 10:12:24 +0000

Most Apache Kafka benchmarks appear to test high throughput but not low latency.

Kafka was traditionally used for high throughput rather than latency-sensitive messaging, but it does have a low-latency configuration. (Mostly setting linger.ms=0 and reducing buffer sizes).

In this configuration, you can get below 1-millisecond latency a good percentage of the time for modest throughputs.

Benchmarks tend to focus on clustering Kafka, in a high-throughput configuration.

While this is perhaps the most common use case, how does it perform if you need lower latencies?

Writing a Profiler from Scratch: The Profiling Loop

Thu, 12 Jan 2023 15:26:34 +0000

This is the second post in the series, building a profiler from scratch using AsyncGetCallTrace. Today, we’re covering wall-clock profiling and how to collect the obtain stack traces. If you’re unfamiliar with AsyncGetCallTrace, please check out my previous article in the series here .

Our goal today is to essentially write the primary loop of a profiler and do the following every n milliseconds (where n is our chosen profiling interval):

Why Your Choice of JVM Matters More Than Ever

Wed, 11 Jan 2023 17:36:35 +0000

In my recent interview with Software Daily , I discussed that there are many companies looking for better customer experience, faster execution, and lower infrastructure costs… and that they have discovered a better use of Java to help them with just that.

The interview describes that when you use hyper-optimized Java runtimes instead of vanilla OpenJDK – you do less tuning and debugging. This means you can build applications, data architectures or anything that needs better performance using an optimized JVM – with little or no code changes.

How to Reduce Cloud Cost by 99% for EDA Kafka Applications

Wed, 11 Jan 2023 13:35:41 +0000

While the Cloud offers great convenience and flexibility, the operational cost for applications deployed in it can sometimes be significant.

In this article, we show a way to substantially reduce operating costs in latency-sensitive Event-Driven Architecture (EDA) Java applications by migrating from Kafka to Chronicle Queue open-source, which is a more resource-efficient andlower-latency queue implementation.

What is EDA?

An EDA (Event-Driven Architecture) application is a distributed application where events (in the form of messages or DTOs) are produced, detected, consumed, and reacted to.

How to Leverage Method Chaining to Add Smart Message Routing

Wed, 04 Jan 2023 08:33:43 +0000

This article explores how to use method chaining to add routing information to serialised data structures in a lightweight fashion, where the routing information can be read separately by an intelligent message router.

We are going to use the open-source serialisation library Chronicle Wire . Let’s assume we have some data that we want to send to a particular destination; we don’t want to pollute our business data structures with the routing information. In the future, the routing information could be removed or changed based on external factors such as system failover or horizontal scaling.

Writing a Profiler from Scratch: Introduction

Wed, 21 Dec 2022 15:26:44 +0000

Async-profiler is undoubtedly one of the most used open-source Java profilers out there.

Its most commonly used feature is sampling a given Java program’s stack traces and visualizing them as a flame graph. I would recommend reading the excellent async-profiler manual by Krzysztof Ślusarski or taking a look at my profiling playlist on YouTube if you’re new to this tool.

After using the async-profiler for a while, you might wonder: How does this tool work? And, of course, if you’re someone like me: Could I write a stripped-down versionto learn how it really works?

Azul Provides the CRaC in AWS SnapStart Builds

Tue, 20 Dec 2022 07:45:54 +0000

At Azul, we are very excited about the Amazon Web Services launch of SnapStart for Lambdas .

SnapStart is based on the CRaC (Coordinated Restore at Checkpoint) API developed in OpenJDK, which was originated and led by Azul.

What is the CRaC API?

The CRaC API provides a common way for Java applications to coordinate with underlying checkpoint/restore mechanisms, allowing Java code to work seamlessly and portably across various checkpoint/restore mechanisms as they become available.

Web resource caching: Server-side

Fri, 09 Dec 2022 15:32:42 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server side.

In the previous post , I explained the former; this post focuses on the latter.

While client-side caching works well, it has one central issue: to serve the resource locally, it must first have it in the cache. Thus, each client needs its cached resource. If the requested resource is intensive to compute, it doesn’t scale.

Web resource caching: Client-side

Fri, 09 Dec 2022 15:27:44 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server-side.

This article is dedicated to the former; the next article will focus on the latter.

Caching 101

The idea behind caching is simple: if a resource is a time- or resource-consuming to compute, do it once and store the result.

JFR Event Collection

Thu, 08 Dec 2022 10:08:52 +0000

Ever wondered what all the JDK Flight Recorder events are, in which JDK versions they are supported, and what examples of an event looks like?

Wonder no more, I created the JFR Event Collection website which contains all this and more.

This site gives you an up-to-date collection of all OpenJDK JFR events for every JDK since 11, giving you the following additional information:

configuration properties
fields with their types and description
examples from a renaissance benchmark run
with which GC this event appears
additional descriptions collected by JFR users

The idea for this website came during the development of my prototypical JFR UI:

Learn How to Develop Event-Driven Architectures

Wed, 07 Dec 2022 15:25:16 +0000

Previously, I wrote an article on Open source Chronicle Wire , that discusses how we could serialise an application’s state into different message formats.

Now in this article, I’m going to look at how we can use Open source Chronicle Queue and Chronicle Wire to structure applications to use Event-Driven Architecture (EDA).

EDA is a design pattern in which decoupled components (often microservices) can asynchronously publish and subscribe to events.

Kafka vs. Chronicle for Microservices: Which is 750 Times Faster?

Wed, 30 Nov 2022 08:15:40 +0000

Apache Kafka is a common choice for inter-service communication.

Kafka facilitates the parallel processing of messages and is a good choice for log aggregation. Kafka claims to be low latency, high throughput . However, is Kafka fast enough for many microservices applications in the cloud?

When I wrote Open Source Chronicle Queue , my aim was to develop a messaging framework with microsecond latencies, and banks around the world have adopted it for use in their latency-sensitive trading systems and real-time streaming applications.

AP-Loader: A New Way to Use and Embed async-profiler

Tue, 22 Nov 2022 14:54:35 +0000

Using async-profiler can be quite a hassle.

First, you have to download the right archive from GitHub for your OS and architecture, then you have to unpack it and place it somewhere.

Or you get it from your OS distribution, hoping that it is the current version.

It gets worse if you want to embed it into your library, agent, or application. Library developers cannot just use a Maven dependency but have to create wrapper code and build scripts that deal with packaging the binaries themselves. Or, worse, they depend on a preinstalled version which they do not control.

How Object Reuse Can Reduce Latency and Improve Performance

Wed, 16 Nov 2022 15:33:41 +0000

Become familiar with the art of object reuse by reading this article and learn the pros and cons of different reuse strategies in a multi-threaded Java application. This allows you to write more performant code with less latency.

While the use of objects in object-oriented languages such as Java provides an excellent way of abstracting away complexity, frequent object creation can come with downsides in terms of increased memory pressure and garbage collection which will have an adverse effect on applications’ latency and performance.

Java Profiling Overview

Mon, 14 Nov 2022 09:14:25 +0000

When I ask Java developers whether they do profile, the answer is usually “no”.

The few that profiled before usually used VisualVM as a student and maybe JProfiler or YourKit years ago at work.

One of the reasons for this is a lack of available information and thus knowledge for everyday Java developers.

This is a pity as profiling should be a part of the tool belt for every experienced developer (not just for Java). The problem is that most of the open-source profilers are targeted to the OpenJDK developers (or their colleagues), even if they won’t admit it. This can be seen in the lack of entry-level material on this topic and even the little that is out there is distributed across multiple conference websites, blogs, YouTube channels, and Twitter accounts.

Creating Terabyte Sized Queues with Low-Latency

Wed, 02 Nov 2022 10:45:07 +0000

Queues are often fundamental components in software design patterns.

But, what if there are millions of messages received every second and multi-process consumers need to be able to read the complete ledger of all messages?

Java can only hold so much information before the heap becomes a limiting factor with high-impacting garbage collections as a result, potentially preventing us from fulfilling targeted SLAs or even halting the JVM for seconds or even minutes.

Why the Fastest Way of Serializing a Java Field is not Serializing it at All

Tue, 25 Oct 2022 12:54:49 +0000

This article elaborates on different ways of serializing Java objects and benchmarks performance for the variants. Read this article and become aware of different ways to improve Java serialization performance.

In a previous article about open-source Chronicle Queue , there was some benchmarking and method profiling indicating that the speed of serialization had a significant impact on execution performance. After all, this is only to be expected as Chronicle Queue (and other persisted queue libraries) must convert Java objects located on the heap to binary data, which is subsequently stored in files. Even for the most internally efficient libraries, this inevitable serialization procedure will largely dictate performance.

High-Performance Java Serialisation to Different Formats

Wed, 12 Oct 2022 14:15:06 +0000

Java serialisation is a popular mechanism where you are able to serialise and deserialise complex object graphs; for example where object A can contain a reference to object B, which in turn has a reference back to object A.

The problem is that this rich functionality comes at a performance cost.

However, if you do not need to serialise these types of recursive graphs, you can instead use an open source solution called Chronicle Wire.

Comparative Evaluation Azul Zulu Prime vs. OpenJDK

Fri, 07 Oct 2022 08:51:00 +0000

In today’s Java ecosystem, you have a wide range of possible runtimes. Choosing between them can have a huge impact on the capabilities or performance of your environments and applications.

In this article, you will learn about best practices for comparative evaluations between JDK setups , whether they be different configurations in a single JDK or comparing Azul Zulu Prime Builds of OpenJDK (Azul Zulu Prime) to OpenJDK itself.

By following this guide, you will be able to establish credible evidence that Azul Zulu Prime improves aspects of application behavior to a degree that justifies using it within your organization.

Let's Create Mappers Without Creating Underlying Objects in Java

Tue, 20 Sep 2022 09:16:35 +0000

As most Java developers know, putting values in a Java Map (like a HashMap) involves creating a large number of auxiliary objects under the covers.

For example, a HashMap with int keys and long values might, for each entry, create a wrapped Integer, a wrapped Long object and a Node that holds the former values together with a hash value and a link to other potential Node objects sharing the same hash bucket.

The Story of a Java 17 Native Memory Leak

Tue, 13 Sep 2022 08:15:53 +0000

Context

When Java 17 was released, we (the platform team at Auto Trader where I was working at the time) were fairly quick to provide a new Docker base image to allow our developers to gain the benefits of the new goodness in the JDK available since Java 11, the previous LTS version.

Over the course of a few years, we’ve standardised the way the JVM is configured out of the box for any new applications that make use of the base image. In general, this provides product teams with a good default starting point from which to get up & running quickly with any new service they plan to deploy.

What the Heck Is Project Loom for Java?

Tue, 30 Aug 2022 15:13:55 +0000

Java has had good multi-threading and concurrency capabilities from early on in its evolution and can effectively utilize multi-threaded and multi-core CPUs.

Java Development Kit (JDK) 1.1 had basic support for platform threads (or Operating System (OS) threads), and JDK 1.5 had more utilities and updates to improve concurrency and multi-threading.

JDK 8 brought asynchronous programming support and more concurrency improvements.

While things have continued to improve over multiple versions, there has been nothing groundbreaking in Java for the last three decades, apart from support for concurrency and multi-threading using OS threads.

Cassandra: Throughput, Responsiveness, Capacity and Cost

Wed, 24 Aug 2022 10:43:51 +0000

For scalable data workloads like Apache Cassandra, performance and capacity are simply a matter of cost. JVM choice and configuration can dramatically impact that cost. The Azul Platform Prime JVM significantly improves Cassandra performance and reduces the cost of Cassandra clusters.

Background

We set off to characterize the impact of JVM choice and configuration on Cassandra load carrying capacity: the capacity of a Cassandra cluster of a certain size to handle traffic while meeting specified service levels.

Faster Integration Tests with Reusable Testcontainers

Wed, 17 Aug 2022 11:05:05 +0000

In my job, I often need integration tests against a Neo4j database. My software is written in Java, and so is Neo4j. Neo4j is embeddable, too. So, in theory, I could just depend on the embedded version, open a connection, test my stuff and call it a day. It would not be a different engine, it would be - at least from a query-engine and planer perspective - the same thing, in contrast to using an embedded SQL database as a drop-in for PostgresQL for example.

A Flavour of TornadoVM on Apple M1 Pro

Tue, 02 Aug 2022 08:21:12 +0000

This article aims to describe the main steps required to install and run TornadoVM on Apple M1 Pro.

Steps

Install Prerequisites
Run TornadoVM Installer
Execute Unit Tests
Performance Evaluation: Running Matrix-Multiplication on Apple M1 GPU

1. Install Prerequisites

To install TornadoVM, it is necessary to have some packages installed. For instance, you will have to install Maven and wget in order to enable the TornadoVM installer to be functional.

Assuming that Homebrew is installed in your system, you can open a terminal and execute the following commands:

The Cost of Production Blindness

Fri, 22 Jul 2022 08:11:03 +0000

When I speak at conferences, I often fall back to the fact that just a couple of decades ago we’d observe production by kicking the server.

This is obviously no longer practical. We can’t see our production. It’s an amorphous Cloud that we can’t touch or feel. A power that we read about but don’t fully grasp.

In this case, we have physical evidence that the Cloud is there.

A part of this major shift in our industry is a change to our fundamental roles as engineers. DevOps and SRE are roles that didn’t exist back then. Yet today, they’re often essential for major businesses. They brought with them tremendous advancements to the reliability of production, but they also brought with them a cost: distance.

General Build Distribution: A Game-Changer or a Gimmick?

Wed, 20 Jul 2022 21:09:29 +0000

Understand the performance potential of remote and distributed builds and explore how to improve build feedback times.

The Remote and Distributed Build Patterns article explains the differences between remote and distributed builds and variations on each. Specifically, we distinguished between “test distribution” and “general build distribution”.

This article discusses distributed builds in a broader perspective of improving build feedback times. We’ll start by explaining the types of changes engineers tend to make, identify the typical bottlenecks and share how these relate to distributed builds. We will also study the performance potential of general build distribution. Finally, we will explore a holistic approach to improving build feedback times.

Released: OpenJDK 18.0.2, 17.0.4, 15.0.8, 13.0.12, 11.0.16, 8u342

Wed, 20 Jul 2022 12:32:00 +0000

Java has regular patch and security updates that are co-ordinated across the community, they happen once per quarter. When these updates happen, there are fixes that include security issues, all of which are displayed on Foojay.io.

The next quarterly release of the OpenJDK has been made available, as scheduled, for July 2022, impacting a number of OpenJDK releases.

All the fixes provided for each updated OpenJDK release are found here:

Remote and Distributed Build Patterns

Tue, 19 Jul 2022 10:48:48 +0000

Remote and distributed builds are terms frequently used, misused and abused. Here we share insight for what these terms mean and how they affect your build feedback times.

A frequently-requested feature for the Gradle Build Tool is the ability to perform remote or distributed builds.

But what exactly does this mean? And what are the motivations behind the requests?

This article will explore the difference between remote vs. distributed builds and their variations. As there is no industry-wide agreement on consistent terminology for these concepts, the goal of this article is to give an overview of these patterns and how they relate to each other.

Spring Boot Performance Workshop with Vlad Mihalcea

Fri, 24 Jun 2022 07:43:52 +0000

A couple of weeks ago, we had a great time hosting the workshop you can see below with Vlad Mihalcea. It was loads of fun and we hope to do this again soon!

In this workshop, we focused on Spring Boot performance but most importantly on Hibernate performance, which is a common issue in production environments.

It’s especially hard to track since issues related to data are often hard to perceive when debugging locally. When we have “real world” data at scale, they suddenly balloon and become major issues.

Building Project Panama's jextract tool by yourself

Thu, 09 Jun 2022 14:22:47 +0000

Absorb what is useful, discard what is useless and add what is specifically your own. – Bruce Lee

Do you want to build Project Panama’s Jextract tool by yourself? I can show you how!

If you’ve seen any of my past articles on Project Panama I’ve mentioned a really convenient tool called jextract that can generate Java binding code that represents native functions or variables (symbols) from C libraries.

This alleviates the developer’s need of creating binding code by hand. By passing in a C header file (.h extension) jextract can generate source code or compiled Java classes.

How DataStax Tracked Down a Linux Kernel Bug with Fallout

Thu, 02 Jun 2022 15:32:08 +0000

Sometimes as a developer, you run into a bug buried deep within the layers of your software stack. Chasing down the root cause requires not only curiosity, patience, and a healthy dose of tenacity but a willingness to try different tools and approaches. This post describes our challenges and ultimate success in tracking down a Linux kernel bug using Fallout.{#ee66}

Bugs come in all shapes and sizes and it’s not always clear at the beginning of a debugging session which one you’re currently chasing. Some bugs can be fixed up in a matter of minutes while others take weeks to nail down. And the really tricky ones require you to dig through multiple layers of your software stack, stressing the limits of your patience.{#8aae}

Optimizing Distributed Joins: The Case of Google Cloud Spanner and DataStax Astra DB

Tue, 31 May 2022 16:25:25 +0000

In this post, learn how relational and NoSQL databases, Google Cloud Spanner and DataStax Astra DB, optimize distributed joins for real-time applications.{#c63a}

Distributed joins are commonly considered to be too expensive to use for real-time transaction processing. That is because, besides joining data, they also frequently require moving or shuffling data between nodes in a cluster, which can significantly affect query response times and database throughput. However, there are certain optimizations that can completely eliminate the need to move data to enable faster joins. In this article, we first review the four types of distributed joins, including shuffle join, broadcast join, co-located join, and pre-computed join. We then demonstrate how leading fully managed Relational and NoSQL databases, namely Google Cloud Spanner and DataStax Astra DB , support optimized joins that are suitable for real-time applications.{#bea1}

Superfast Application Startup: Java on CRaC

Mon, 30 May 2022 05:37:24 +0000

It’s now twenty-seven years since Java was first released, and it continues to be one of the most popular platforms for applications, especially on servers.

One of the reasons for this is the Java Virtual Machine (JVM) . This provides a managed runtime environment that removes the need for developers to deal with things like memory management; the garbage collector takes care of this for you. Another significant advantage of the JVM is the use of bytecodes that can be converted to native instructions at runtime using a Just-In-Tim (JIT) compiler.

Let's Compile Java Code in the Cloud!

Wed, 18 May 2022 12:03:34 +0000

Across the industry, companies are trying to rein in runaway cloud costs by squeezing more carrying capacity out of the instances they run in the cloud.

Especially in the Java space, developers are trying to fit workloads into smaller and smaller instances and utilize server resources with maximum efficiency.

Relying on elastic horizontal scaling to deal with spikes in traffic means that Java workloads must start fast and stay fast.

Diving into JVM Framework Monitoring and Profiling

Fri, 13 May 2022 06:36:05 +0000

Managing available resources on demand in a cloud environment can be a very challenging topic. It is worth the effort, since it may however utilise resources far more efficiently.

Companies or projects are therefore very keen to migrate to the Cloud providers, such as Azul, AWS, Google Cloud or others. For software engineers one truth still stands, also in the Cloud: It’s recommended to understand the behaviour and limitations of our deployed JVM application (or pods, the smallest deployable instance in Kubernetes).

Getting More Mileage Out of Kafka: OpenJDK vs. Azul Prime

Wed, 11 May 2022 06:47:07 +0000

Building real-time data pipelines and streaming applications just got more cost-effective.

Kafka is great because it’s horizontally scalable, fault-tolerant, and runs in production for thousands of companies – and we figured out how to help you get more mileage out of it.

How We Did It

In a recent post we compared Kafka throughput on Azul Platform Prime versus OpenJDK, noting that on our config Azul Platform Prime reaches 45% higher max throughput than OpenJDK.

Thinking About Massive Throughput? Meet Virtual Threads!

Thu, 28 Apr 2022 07:41:25 +0000

The goal of this article is to examine known facts about an upcoming Java threading model extension.

No, no-worries, the current Java threading model remains but behind the curtains something good is already knocking on the virtual door.

Yes, we are talking about JEP-425: Virtual Threads.

Knocking on current concurrency limits

Let’s first look at the current Java threading model. It provides an implementation of the Thread class. A Thread can be considered a Java concurrency unit which can execute so-called Runnable tasks. The instance of a Thread class is also an object but there is a bit more happening behind the scenes.

Java Panama Polyglot (Python/Tensorflow) Part 3

Tue, 26 Apr 2022 04:42:58 +0000

Hello and welcome back to the Java Panama Polyglot series where we are presenting quick tutorials or recipes on how to access native libraries written in other languages.

If you are new to Java’s Foreign Function Access APIs (Project Panama ) check out: Panama4Newbies

In Part 2 you got a chance to learn about how to use Java Project Panama’s (foreign function interface APIs) abilities to access native libraries written in Apple’s Swift language .

Does Java 18 Finally Have A Better Alternative To JNI?

Tue, 19 Apr 2022 21:01:50 +0000

Java 18 was released last month (March 2022), and with it comes the second incubator of the Foreign Function & Memory API, so let us look at the state of Foreign Function Interface (FFI) in Java.

If you would prefer to follow along by watching a video, here’s the recording of my FOSDEM'22 talk on this topic, from the the OktaDev YouTube channel .

What is a Foreign Function Interface?

A foreign function interface is the ability to call functions or routines written in one programming language from another programming language.

Introducing the "Coordinated Restore at Checkpoint" Project

Mon, 18 Apr 2022 08:13:55 +0000

Introduction

One of the great things about the Java Virtual Machine (JVM) is the fact that it is able to adapt the performance of a Java application to the way it is used.

It can figure out what parts of your code are used often and it can then optimize the code by means of its ability to compile code just in time (JIT).

But that also means that it has to figure out those parts first, before it can compile those parts into faster code.

Java Panama Polyglot (Swift) Part 2

Wed, 13 Apr 2022 15:34:59 +0000

Hello and welcome back to the Java Panama Polyglot series where we will be presenting quick tutorials or recipes on how to access native libraries written in other languages.

In Part 1 you got a chance to learn about how to use Java Project Panama ’s (foreign function interface) abilities to access native libraries written in C++. Today, we will be looking at Java code being able to talk to Apple’s Swift language.

Java Panama Polyglot (C++) Part 1

Wed, 06 Apr 2022 15:41:49 +0000

Hello and welcome to the Java Panama Polyglot series where we will be presenting quick tutorials or recipes on how to access native libraries written in other languages.

For example, you will learn about Java Project Panama’s (foreign function interface) abilities to access native libraries written in C++, Swift, Python, and others.

What is Polyglot?

Have you heard of polyglot as it relates to developing full stack applications? If your answer is yes, then you probably know about the programming languages needed to build an enterprise web application.

Hardware Acceleration For Java? TornadoVM Can Do It!

Fri, 01 Apr 2022 07:37:03 +0000

Java programs can primarily run on x86 and Arm platforms and recent efforts focus on ports to PowerPC and RISC-V.

Despite the diverse range of ISAs, contemporary computers are equipped with heterogeneous devices, such as Graphics Processing Units (GPUs), Field Programmable Gate Arrays (FPGAs), and Tensor Processing Units (TPUs), which operate as co-processors that offload data processing from the main processor.

A question that rises is whether such compute power can be utilized by Java programs. The answer is that several frameworks have been created to address this challenge. For instance, IBM J9 , Aparapi , and TornadoVM , are frameworks that aid Java programmers to accelerate their programs on heterogeneous hardware devices.

Increasing Event Streaming with Kafka and Azul

Tue, 29 Mar 2022 13:41:48 +0000

Welcome to getting started with Azul Platform Prime and Apache Kafka !

In this article you will learn how to switch between two different Java runtime environments to run an Apache Kafka instance.

In later articles, this will allow you to compare runtime performance benchmarks.

Before we begin, let’s supply some context on Azul’s Platform offerings and Apache Kafka.

What is Azul Platform Prime and Platform Core?

Azul offers two Java runtime environments Platform Prime and Platform Core . Platform Prime (formerly known as Zing) is a high-performance implementation of the JVM (Java Virtual Machine) while Platform Core refers to Azul’s solution that includes the Zulu build of OpenJDK with dedicated support.

Reaper 3.0 for Apache Cassandra is available

Fri, 18 Mar 2022 14:55:43 +0000

The K8ssandra team is pleased to announce the release of Reaper 3.1 . Let’s dive into the features and improvements that 3.0 recently introduced (along with some notable removals) and how the newest update to 3.1 builds on that.

Starting with 3.1.0, Reaper can now compile and run with jdk11. Note that jdk8 is still supported at runtime.

Over the years, we regularly discussed dropping support for Postgres and H2 with the The Last Pickle (TLP) team, now part of DataStax , the organization leading the open-source development of Reaper. Despite our lack of expertise in Postgres, the effort required to maintain support for these storage backends was moderate as long as Reaper’s architecture was simple. However, complexity grew with more deployment options, culminating with the addition of the sidecar mode.

Jakarta Concurrency: Present and Future

Wed, 23 Feb 2022 14:15:13 +0000

Jakarta EE , previously Java EE, is a set of specifications that enables the world wide community of Java developers to work on cloud native Java enterprise applications. It is an open source project maintained by the Eclipse Foundation.

Jakarta Concurrency is a small, but fundamental, specification under the Jakarta EE umbrella. As project lead, I provide more information on what it is, its future and how to be involved.

Monitoring Spring Boot Applications (Part 1)

Wed, 12 Jan 2022 16:34:53 +0000

In part 1 of this series, we will learn about JDK Flight Recorder and how we can use it to monitor a Spring Boot application.

Introduction

Application monitoring is one thing that we as developers cannot overlook. It doesn’t matter if you run a monolith or microservices application because application monitoring is a must for production workloads to know what’s happening with your application. If you are using Spring Boot, there are different ways to monitor an application. The most popular way to monitor a Spring Boot application is to enable the spring-boot-actuator module to achieve the desired result.

Debugging RAM: Java Garbage Collection - Java Heap Deep Dive (Part 1)

Tue, 11 Jan 2022 15:36:04 +0000

There are many excellent articles on Java Garbage Collection, Java Memory usage and generally Java heap. Unfortunately, they are all over the place. They mix architecture, concepts and problem solving as separate pieces. A lot of the material is out of date or doesn’t include pragmatic information for solving problems with the garbage collector. E.g. e.g. pause times, heap space usage etc.

In this post I won’t go into memory leaks. They’re important but this is a different subject I would like to discuss in a post on its own.

Hashcode and Equals: Debugging and Performance

Fri, 07 Jan 2022 13:31:35 +0000

A few weeks ago I ran into this story on reddit that discusses the problem with using the URL class as a key in a Map. This boils down to a remarkably slow implementation of the hashcode() method in java.net.URL which makes this class unusable in such situations.

Unfortunately, this is a part of the Java API specification and is no longer fixable without breaking backwards compatibility.

What we can do is understand the problem with equals and hashcode. How can we avoid such problems in the future?

Fail-Fast Reliable Software Strategy. Debug Failures Effectively

Tue, 14 Dec 2021 15:30:46 +0000

I love cooking and use my Thermomix a lot. If you hadn’t heard about that amazing innovation, it’s a kitchen robot… Well, it’s a magical super cooking machine. When designing the Thermomix, its designers took the approach of fail-safe instead of fail-fast . This is a smart choice in this case, but it has its drawbacks.

E.g., my machine tried to recover from a failure which sent it into an infinite recovery loop. I literally couldn’t pull out the food from the lid that was sealed shut. But normally, it’s one of the most reliable devices I own.

Native-image with Quarkus

Mon, 13 Dec 2021 17:50:08 +0000

So far, we have looked at how well Spring Boot and Micronaut integrate GraalVM native image extension. In this post, I’ll focus on Quarkus :

A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.

Creating a new project

Just as Spring Boot and Micronaut, Quarkus provides options to create new projects:

A dedicated quarkus CLI
A Web UI

Quarkus offers a definite improvement over its competitors. Every dependency has a detailed contextual menu that allows:

Native-image with Micronaut

Mon, 22 Nov 2021 10:18:53 +0000

Last week, I wrote a native web app that queried the Marvel API using Spring Boot . This week, I want to do the same with the Micronaut framework.

Creating a new project

Micronaut offers two options to create a new project:

A web UI :

As for Spring Initializr, it provides several features:

Preview the project before you download it
Share the configuration
An API

I do like that you can check the impact that the added features have on the POM. 2. A Command-Line Interface :In parallel to the webapp, you can install the on different systems. Then you can use the mn command to create new projects.

A List of Cache Providers

Thu, 18 Nov 2021 08:01:25 +0000

Recently, we described several criteria to look at to choose a cache . Now it’s time to list Java cache providers based on these criteria.

Java Caching System
Guava
Caffeine
Ehcache
Infinispan
Coherence Community Edition
Ignite
Geode
Hazelcast

Java Caching System

JCS is a distributed caching system written in Java. It is intended to speed up applications by providing a means to manage cached data of various dynamic natures. Like any caching system, JCS is most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system.

Kotlin and FaaS: An Impossible Union?

Tue, 02 Nov 2021 08:40:48 +0000

Some time ago, I read a post describing how to run a serverless Kotlin function on OpenFaaS . While the content is technically correct, I believe the concept itself is very wrong. Such posts can lead people to make ill-advised decisions: “because we can” is hardly a winning strategy.

In this article, I’d like to first explain why the JVM platform is a bad idea for . Then, I’ll proceed to propose alternatives to use Kotlin nonetheless.

How to Choose a Cache: Capabilities

Tue, 26 Oct 2021 13:20:11 +0000

Today, I’d like to provide some help on how to choose a cache solution. I will organize it into two parts:

In this post, we will list what features a cache must have and which ones it can optionally provide. Most criteria are general and can be used regardless of the tech stack, while a couple is specific to the JVM.
In the second part, I’ll list providers and verify their respective capabilities

Why cache?

First, let’s bust a common myth. Using a cache is not the sign of a badly-designed system per se, though it might be the case. Like in many design decisions, a cache is a trade-off.

Faster Maven Builds (Part 2): Inside Docker

Thu, 14 Oct 2021 08:33:09 +0000

Following on from different techniques to speed up your Maven builds, I’d like to widen the scope and do the same for Maven builds inside Docker.

Between each run, we change the source code by adding a single blank line; between each section, we remove all built images, including the intermediate ones that are the results of the multi-stage build. The idea is to avoid reusing a previously built image.

Baseline

To compute a helpful baseline, we need a sample project. I created one just for this purpose: it’s a relatively small Kotlin project.

How to Do Faster Maven Builds (Part 1)

Thu, 14 Oct 2021 08:27:35 +0000

Builds require a few properties, chief among them reproducibility. I would consider speed to be low on the order of priorities. However, it’s also one of the most limiting factors to your release cycle: if your build takes T , you cannot release faster than each T. Hence, you’ll probably want to speed up your builds after you’ve reached a certain maturity level to enable more frequent releases.

I want to detail some techniques you can leverage to make your Maven builds faster in this article. The next article focuses on how to do the same inside of Docker.

On The Costs of Hidden Logging

Mon, 11 Oct 2021 08:05:33 +0000

A while ago I received a customer escalation ticket regarding performance degradation when using Datadog Continuous Profiler for Java . The degradation was observable as an increased CPU usage as well as unexpected latency.

The Beginning: Unusual Customer Escalation

To bootstrap the troubleshooting, I usually try to isolate the area which might be causing the regression.

The profiler is packaged as a Java agent and for ease of use it is bundled together with the Datadog Java tracer agent. The profiler itself uses JDK Flight Recorder (JFR) under the hood.

JDK Mission Control 8.1.0 Released!

Mon, 09 Aug 2021 18:02:33 +0000

Yay, the latest release of JDK Mission Control was just released!

Since this is the source release, it may still take a bit of time until the downstream vendors release binary builds of JDK Mission Control 8.1.0.

I will try to remember to tweet or say something on the JMC Facebook page once the binaries start showing up.

Mission Control 8.1 – New and Noteworthy

General

JMC 8.1 – New Release!

Let's Optimize Relational Database Access

Mon, 28 Jun 2021 07:42:54 +0000

Database performances have been massively documented in the literature. Every week, a new blog post or article explains why database X is better than database Y. And, no, this post is not about that. This article summarizes the interactions between your database client (sometimes called driver) and the database server. It is essential to understand the principles of these exchanges to comprehend the limitations of the API the driver can expose safely.

BlockHound and Blocking Calls: How It Works

Tue, 22 Jun 2021 17:09:13 +0000

One of the talks in my current portfolio is Migrating from Imperative to Reactive . The talk is based on a demo migrating from Spring WebMVC to Spring WebFlux in a step-by-step approach. One of the steps involves installing BlockHound : it allows to check whether a blocking call occurs in a thread it shouldn’t happen and throws an exception at runtime when it happens.

I’ve presented this talk several times in the previous week, both in its Java version and its Kotlin one. One such presentation was at Javaday Istanbul . After the talk, one of the questions I received was, “How does BlockHound work?” I admit that at the time, I couldn’t remember. After the surprise had passed, but too late, I remembered it involved a Java agent. But I wanted to go down the rabbit hole.

Apache Cassandra 4.0: Taming Tail Latencies with Java 16 ZGC

Tue, 22 Jun 2021 07:45:40 +0000

With Apache Cassandra 4.0, you not only get the direct improvements to performance added by the Apache Cassandra committers, you also unlock the ability to take advantage of seven years of improvements in the JVM itself. This article focuses on improvements in Java garbage collection that Cassandra 4.0 coupled with Java 16 offers over Cassandra 3.11 on Java 8.

Like so many others in the Apache Cassandra community, I’m extremely excited to see that the 4.0 release is finally here. There are many, many improvements to Cassandra 4.0 . One enhancement that is more important than it might look is the addition of support for Java versions 9 and up. This was not trivial, because Java 9 made changes to some internal APIs that the most performance-oriented Java projects like Cassandra relied on (you can read more about this here ).

Concurrency in Java (Compared with Other Programming Languages)

Tue, 15 Jun 2021 08:05:50 +0000

This is a multi-part series where I talk about concurrency in modern programming languages and build and benchmark a concurrent web server, inspired by the example from the Rust book , in popular languages like Java, Rust, Go, JavaScript (NodeJS), TypeScript (Deno) and Kotlin to compare concurrency and its performance between these languages/platforms.

The chapters of this series are as below, with part 6 here on Foojay.io, the place for friends of OpenJDK.

Querying Your In-Memory-Data-Grid: Why and How?

Fri, 21 May 2021 07:11:28 +0000

An in-memory data grid (IMDG) is a set of networked/clustered computers that pool together their random access memory (RAM) to let applications share data with other applications running in the cluster. Though IMDGs are sometimes generically described as a distributed in-memory data store, IMDGs offer more than just storage. IMDGs are built for data processing at extremely high speeds. They are designed for building and running large-scale applications that need more RAM than is typically available in a single computer server. This enables the highest application performance by using RAM along with the processing power of multiple computers that run tasks in parallel. IMDGs are especially valuable for applications that do extensive parallel processing on large data sets.

Demystifying Java Virtual Machine Memory Management

Thu, 20 May 2021 07:26:37 +0000

In this multi-part series , I aim to demystify the concepts behind memory management and take a deeper look at memory management in some of the modern programming languages, in particular Java, Kotlin, Scala, Groovy, and Clojure.

I hope the series would give you some insights into what is happening under the hood of these languages in terms of memory management. In this chapter, we will look at the memory management of the Java Virtual Machine (JVM) used by languages like Java, Kotlin, Scala, Clojure, Groovy, and so on.

A (Definitive?) Guide to LazyInitializationException

Mon, 29 Mar 2021 07:19:49 +0000

Posts that have been written about Hibernate’s LazyInitializationException could probably fill whole books.

Yet, I believe each of them focuses on a particular aspect of it: some on a specific solution, some on how to solve it with Spring Boot, etc.

I’d like this post to be the definitive guide on the subject, even though I’m pretty sure it won’t. At least, I’ll be able to point others to it!

Billion Events Per Second, Millisecond Latency: Giga Streaming Analytics

Thu, 25 Mar 2021 17:04:38 +0000

This post is a part of a series:

Part 1 (Intro and high-throughput streaming benchmark)
Part 2 (batch workload benchmark)
Part 3 (low-latency benchmark)
Part 4 (concurrent GC with green threads)
Part 5 (you are here)

We’re preparing a scientific paper on Hazelcast Jet, describing its architecture based on symmetric, data-local, non-blocking distributed event processing. As a part of this effort, we implemented the vendor-neutral NEXMark benchmark suite, consisting of 8 streaming queries that aim to capture typical kinds of questions you’re likely to ask about your real-time data.

Kicking Spring Native's Tires with GraalVM

Mon, 22 Mar 2021 17:18:05 +0000

I’ve been playing with GraalVM Ahead-Of-Time compilation capability since I became aware of it. As a long-time Spring aficionado , I carefully monitored the efforts that the engineers at Tanzu have put into making Spring AOT-compatible. Recently, they announced the beta version of the integration.

In this post, I want to check how easy it is to produce a (working!) Docker image from an existing Spring Boot application.

Introduction

GraalVM provides many different features. Among them, the component known as Substrate VM allows to AOT-compile regular bytecode to a native executable. The process “walks” the application starting from the main method at build time. Substrate VM leaves out the code that it doesn’t follow out from the resulting binary.

Evolution of Java Memory Architecture (Post Java 7.0)

Wed, 03 Mar 2021 16:19:20 +0000

[About SKP’s Core Java/Java EE Roots]
Series of Articles on Rooted Concepts in Core Java and J2EE. They Revolve Around Memory Architecture, Connection & Memory Leaks, Core Java Syntax & Semantics, Java Object Layout/Anatomy, Multi-Threading, Asynchronous Task Execution, Design Patterns, Java Agents, Class Loading, API Design, OOPs & SOLID.

Java Memory Architecture (Pre Java 8.0)

Before we get started, you might want to take a look at Part 1. It explains the core concepts of the Java Memory Architecture, the ones that should get you started to understand this evolution better.

Evolution of Java Memory Architecture (Pre Java 8.0)

Thu, 25 Feb 2021 14:59:16 +0000

→ Java Memory Architecture (Java Memory Model)

The diagram below is the Java Memory Model for the Heap as well as the PermGen for any Java Application running in the Java Virtual Machine (JVM). The ratios are also provided to get a fair understanding of how the distribution of allowed memory is done across each of the generation types. All of the info is completely applicable up to Java 1.7 (inclusive). This diagram is also known as the ‘Managed Area’ of the memory model.

Towards Continuous Performance Regression Testing

Thu, 25 Feb 2021 09:44:43 +0000

Functional unit and integration tests are a standard tool of any software development organization, helping not only to ensure correctness of newly implemented code, but also to identify regressions — bugs in existing functionality introduced by a code change. The situation looks different though when it comes to regressions related to non-functional requirements, in particular performance-related ones: How to detect increased response times in a web application? How to identify decreased throughput?

Safe Writing to Files in IoT and Industrial Systems

Thu, 11 Feb 2021 09:12:23 +0000

Especially on IoT devices, file corruption on shutdown is a common concern. This article discusses how to write to disk safely in Java, combining disk sync, shutdown hooks, and atomic renaming of files.

Files On Disk Can Still Easily Become Corrupted

For performance optimization, file systems write to disks asynchronously resulting in potential corruption when a hard system shutdowns occurs through power off or crashes.

As this has become a rare experience for desktop and server users, it comes as a surprise to many developers working on IoT devices and industrial computers that hard power cuts are a common operational scenario and storage is far less robust than expected.

A Compendium of 2021 Java & OpenJDK Predictions

Fri, 22 Jan 2021 08:03:25 +0000

Now that 2021 is well underway, many prominent Java developers have taken the time to predict what 2021 may bring to the Java universe.

In December, here on Foojay.io, several articles were published on this theme, such as Java Predictions for 2021 , Java Predictions for 2021: Jakarta EE , and Java Predictions for 2021: Raspberry Pi . In early January, Simon Ritter published Staring Into My Java Snow Globe 2021 . Separately, I conversed with another six developers about their visions for the coming year.

Tips on High Performance Rendering in JavaFX

Mon, 18 Jan 2021 09:07:52 +0000

In this article, we comparatively evaluate four different approaches to render particles in JavaFX in terms of runtime performance.

The approaches are Canvas, PixelBuffer AWT, PixelBuffer CPU and PixelBuffer GPU.

The evaluation suggests the following order of approaches from fastest to slowest:

PixelBuffer GPU (fastest).
PixelBuffer CPU.
PixelBuffer AWT.
Canvas (slowest).

All of the source code developed for this article can be found on GitHub . An example demo with 1 000 000 particles looks like this:

Continuous Production Profiling and Diagnostics

Mon, 09 Nov 2020 15:57:38 +0000

I’ve gotten a lot of questions about continuous production profiling lately. Why would anyone want to profile in production, or, if production profiling seems reasonable, why the heck leave it on continuously? I thought I’d take a few moments and share my take on the problem and the success I’ve seen the past years applying continuous production profiling in systems in the real world.

Trigger warning: this blog will not contain code samples.

Peter Lawrey Talks about Low-Latency, High-Performance Java

Thu, 22 Oct 2020 04:28:38 +0000

About 7 years ago, I attended a session given by Java Champion Peter Lawrey, leader of Chronical Software , at a JavaOne conference. Since most of my prior development work in the realm of low-latency high-performance was C/C++ software, I was very interested in hearing what Peter might say about how Java addresses this problem.

I have to admit, being a long-time C/C++ developer, but also with quite a lot of experience with Java, I was a bit skeptical as to how Java might match up to C/C++ in terms of multithread performance.

Timing Compiling .java Code Files and Executing .class Bytecode

Mon, 28 Sep 2020 04:37:39 +0000

Java developers are familiar with the notion that the foundation of Java is “write once, run anywhere.” That is, the same Java code will run on all the primary operating systems and hardware platforms. As I noted in my earlier post Why Java, C, and Python Are Today’s Most Utilized Programming Languages , Python comes somewhat close to this (though in my experience what works on Linux may not work out-of-the-box on Windows or Mac), and of course C/C++ require immense adaptation of the software in order for it to work on different operating systems and hardware platforms.

Startup Speed of Spring and Quarkus JARs on the Raspberry Pi

Fri, 18 Sep 2020 09:16:03 +0000

For my book “Getting Started with Java on Raspberry Pi ”, an example was described to store sensors and measurements in an H2-database through REST APIs with a Spring application on the Raspberry Pi.

The application takes some time to start on a Raspberry Pi, and Adam Bien who does the airhacks.fm podcast asked me if I could compare this to a similar Quarkus application, which resulted in some nice results.

What is JVM Bytecode?

Wed, 16 Sep 2020 03:55:43 +0000

Everyone who programs in Java, or any of the other languages built on top of the Java Virtual Machine (Scala, Closure, Kotlin, Groovy, Nashorn, Jython, JRuby, et al.) is familiar with the term “bytecode.” But how many of us understand what JDK bytecode actually is?

I became more curious about this after I wrote my last foojay.io post, Why the JVM Is a Brilliant Platform for New Programming Languages . What exactly is bytecode?

Useful Hotspot JVM Options for Today: Heap Sizing

Mon, 14 Sep 2020 16:37:30 +0000

The HotSpot JVM has a lot of options available. Maybe too many. Sometimes we are looking for a specific option or the “magic” one that can give a serious boost in an application. Unfortunately, I think that magic option may not exist! However, some can help you for optimizing your application or for tuning some of its parts.

To find the complete list of options you will find in the globals.hpp file from OpenJDK sources. However, the VM Options Explorer , also integrated neatly here into foojay , can help you to navigate through the list.

Why the JVM Is a Brilliant Platform for New Programming Languages

Wed, 09 Sep 2020 05:07:34 +0000

In my previous post , I speculated that Java, Python, and C are likely to be the most prominent programming languages going pretty far into the future.

Another point in my speculation was that utilizing the Java Virtual Machine facilitates the invention of new programming languages created for special purposes that could not be easily created by other means. The JVM takes care of all of the low-level infrastructure problems that are involved in the creation of any software that you’d like to be runnable on any device or operating system.

JmFrX: A Bridge From JMX to Java Flight Recorder

Thu, 03 Sep 2020 09:24:29 +0000

I’m excited to share news about an open-source utility I’ve been working on lately: JmFrX , a tool for capturing JMX data with Java Flight Recorder.

When using JMX (Java Management Extensions ), the Java platform’s standard for monitoring and managing applications, JmFrX allows you to periodically record the attributes from any JMX MBean into Java Flight Recorder (JFR) files, which you then can analyse using JDK Mission Control (JMC).

Stream.concat vs. New ArrayList Performance

Thu, 27 Aug 2020 05:34:58 +0000

During a code review, I suggested some code improvements related to JDK8+ streams. The original code looked very similar to the following:

List<Element> result = content.getFancyStuffs().stream()
 .flatMap(item -> {
 List<Element> objects = new ArrayList<>();
 objects.add(item.getElement());
 objects.addAll(item.getElements());
 return objects.stream();
 })
 .collect(toList());

Some more details here — the getFancyStuffs() returns a list of FancyStuff elements. The FancyStuff class contains two getters where getElement() returns a single Element whereas the getElements() returns (guess what?) a list of Elements.

Monitoring REST APIs with Custom Java Flight Recorder Events

Wed, 26 Aug 2020 08:36:57 +0000

The Java Flight Recorder (JFR) is an invaluable tool for gaining deep insights into the performance characteristics of Java applications. Open-sourced in JDK 11, JFR provides a low-overhead framework for collecting events from Java applications, the JVM and the operating system.

In this blog post, we’re going to explore how custom, application-specific JFR events can be used to monitor a REST API, allowing to track request counts, identify long-running requests and more. We’ll also discuss how the JFR Event Streaming API , new in Java 14, can be used to export live events, making them available for monitoring and alerting via tools such as Prometheus and Grafana.

Container Awareness for Java Developers Today

Mon, 24 Aug 2020 08:55:22 +0000

When you containerize a Java application, make sure you use a base JDK image that is container-aware (CGroup aware) so that the JDK can allocate memory and CPU counts properly.

Older versions of JDK (prior to 8u192) may not have container awareness (or may have experimental support that requires explict flags to enable). Older versions of JDK may look at the traditional /proc/meminfo and /proc/cpuinfofiles for available memory and CPUs. The content of these files reflects the amount of resources of the host/node machine that is running the container, but do not reflect the actual limits assigned to the container (which may be much less).

A Closer Look at Java Flight Recorder Streaming

Mon, 17 Aug 2020 11:04:00 +0000

By Marcus Hirt and JP Bempel

Since JDK 14, there is a new Java Flight Recorder (JFR) kid on the block – JFR streaming. 🙂 This blog post, written together with JP Bempel, will discuss some of the things that you can do with JFR streaming, as well as some of the things you may want to avoid.

An Introduction to JFR Streaming

In the most recent version of the JDK, a new JFR-related feature was introduced – JFR streaming. It is a feature allowing a developer to subscribe to select JFR data and to decide what to do with that data in the host process. JFR events can also be consumed from a separate process by pointing to the file repo of a separate JVM process – the mechanism is the same.

Sub-10 ms Latency in Java: Concurrent GC with Green Threads

Wed, 05 Aug 2020 17:44:00 +0000

This post is a part of a series:

Part 1 (Intro and high-throughput streaming benchmark)
Part 2 (batch workload benchmark)
Part 3 (low-latency benchmark)
Part 4 (you are here)
Part 5 (billion events per second)

In Part 3 we showed that a modern JVM running live stream aggregation can achieve a 99.99% latency lower than 10 milliseconds. The focus of that post was comparing the different GC options available for the JVM. In order to maintain a level playing field, we kept to the default settings as much possible.

Performance of Modern Java on Heavy Workloads: Low-Latency Rematch

Tue, 23 Jun 2020 17:48:00 +0000

This post is a part of a series:

Part 1 (Intro and high-throughput streaming benchmark)
Part 2 (batch workload benchmark)
Part 3 (you are here)
Part 4 (concurrent GC with green threads)
Part 5 (billion events per second)

This is a followup on Part 1 of the blog post series we started earlier this month, analyzing the performance of modern JVMs on workloads that are relevant to the use case of real-time stream processing.

Performance of Modern Java on Data-Heavy Workloads: Batch Processing

Tue, 09 Jun 2020 14:45:00 +0000

This post is a part of a series:

Part 1 (Intro and high-throughput streaming benchmark)
Part 2 (you are here)
Part 3 (low-latency benchmark)
Part 4 (concurrent GC with green threads)
Part 5 (billion events per second)

Batch Pipeline Benchmark

A batch pipeline processes a finite amount of stored data. There are no running results, we need the output of the aggregate function applied to the entire dataset. This changes our performance requirements: the key factor in streaming, latency, doesn’t exist here since we are not processing data in real time. The only metric that matters is the total run time of the pipeline.

Performance of Modern Java on Workloads: Real-Time Streaming

Tue, 09 Jun 2020 01:45:00 +0000

This post is a part of a series:

Part 1 (you are here)
Part 2 (batch workload benchmark)
Part 3 (low-latency benchmark)
Part 4 (concurrent GC with green threads)
Part 5 (billion events per second)

The Java runtime has been evolving more rapidly in recent years and, after 15 years, we finally got a new default garbage collector: the G1. Two more GCs are on their way to production and are available as experimental features: Oracle’s ZGC and OpenJDK’s Shenandoah.

Fun with Flags: My Top 10 Resources for JVM Flags

Mon, 08 Jun 2020 08:21:02 +0000

When I first started programming in Java and configuring my local environment, I came across mentions of JVM flags. I wanted to find out more about what options are available, what they do, and how to make use of them. Delving into the internet to discover what other more seasoned developers had to say on the topic, I was surprised at how hard it was to get definitive answers, and ultimately this research left me with more questions than answers. Since resources on this topic are scattered and hard to find, I put together this consolidated list in the hopes that others don’t have to scour the internet as I did to find these useful morsels.

JDK14 - New Features and Enhancements

Tue, 19 May 2020 23:29:37 +0000

Well, another six months have passed, and we have another release of Java, this one pretty packed with exciting new features. It is, therefore, time for another blog post trying to list everything new in JDK 14 .

In total, there are a very impressive 16 JDK Enhancement Proposals (JEPs) and 69 new API elements.

Let’s start with the more significant items that introduce changes to the Java language syntax.

Records

Java is an object-oriented language; you create classes to hold data and use encapsulation to control how that data is accessed and modified. The use of objects makes manipulating complex data types simple and straightforward. It’s one of the reasons Java is so popular as a platform.

Performance on foojay.io - Friends of OpenJDK

Toward a Durable Spring PetClinic

Overview

BoxLang 1.15.0 Released: Blazing Fast Strings, Runtime Portability, and much more

Temporal Is to Your Code What a Database Is to Your Data

"This Can't Possibly Work": What I Learned at a Temporal.io Workshop

Nulling Out References Won't Help Your Garbage Collector

Jurassic JDK: Migrate or Extinct

Why Are We Still Here? 👀

Quarkus Unpacked: Insights from the Foojay Podcast

Your TLS Stack Is Lying to You About Zero-Copy

The “No Waste Compute” Constraint

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

AWS Nitro and CPU Graviton Meets Unikernels

AWS Nitro and CPU Graviton Meets Unikernels: Java and Quarkus on ARM64 AWS Graviton with Nanos Unikernel

Java and Jakarta EE Truly Meet Unikernels

Thread Safe Native Memory in Java

What is Memory Order and Why Does It Matter for Native Memory?

TestBox 7: Real-Time Feedback, a Browser-Based IDE, and Modern Testing Workflows on the JVM

TestBox RUN: A Browser IDE for Your Tests

Native Memory in Java: Arenas, Malloc, and Pools

What is the Memory API

How is Leyden improving Java Performance? Part 3 of 3

How is Leyden improving Java Performance? Part 2 of

How is Leyden improving Java Performance? Part 1 of 3

BoxLang 1.11.0 Release

I Benchmarked Java on Single-Board Computers: Orange Pi 5 Ultra and Raspberry Pi 5 Lead the Pack

JC-AI Newsletter #14

Runtime Code Analysis in the Age of Vibe Coding

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Profiling a Java Application Running Inside an Unikernel with JProfiler

Webinar: "Moving Applications From JDK 21 to JDK 25: What You Need to Know"

Why Upgrade?

Get high performance Java applications with IBM Semeru Runtimes

JC-AI Newsletter #12

Java Warmup and the Scaling Loop Problem

Optimizing Java for the Cloud-Native Era with Quarkus

Java and Jakarta EE and the Evolution of the Cloud with Nanos Unikernel

Make Java Fleets Warm Up Faster on AWS With Azul Optimizer Hub

More Java From Azul!

The Art of Performance Tuning: Why Saving 30% in the Cloud Means Nothing if Your Code Wastes 1000× More

The Hidden Cost of “Good Enough” Code

Java Security Starts with the JVM

JC-AI Newsletter: Easy Access to Expanding Challenges

What Happens When 10,000 JVMs Collaborate

Take the State of Java 2025 Survey

Azul’s High-Performance Java Platform Achieves Historic First

JetBrains and Azul Collaborate on Kotlin Performance in Various JVMs

Boosting Kafka Latency Performance by 3x with Zing JVM and AutoMQ

Why is Latency so Important to Kafka?

Preparing for Spring Boot 4 and Spring Framework 7: What’s New?

Sustainability Starts with Your Runtime: Meet a Green JVM

Prime Time: The High Performance Java Event

When ReadyNow Can Only Compile on Traffic Loads

Improve Your Java Applications’ Startup and Compilation Speed with Optimizer Hub

Benchmark and profiling Java with JMH

Introduction: Why JMH?

How to Train ReadyNow to Achieve Optimal Java Performance

Your Complete Guide to Diagnose Slow Queries in MongoDB

How ReadyNow Improves Java Warmup Time

Faster Java Warmup: CRaC versus ReadyNow

10 Best Practises For Jakarta EE Performance Optimization

Optimizing the Garbage Collector when Migrating Cloud Workloads

Building JavaFX Native Images

A Glance into JFR Class and Method Tagging

Tags

Warp: the new CRaC engine

Speed up your Spring Batch with Native Image and GraalVM

How Organizations Became Stuck on Outdated Java Versions

Reasons to Stick to 8

Why Java 8 is a Ticking Time Bomb Hiding Within Your Organization

Book Review: Mastering the Java Virtual Machine

How to profile a performance issue using Spring Boot profiling tools

Unsupported OpenJDK Distributions are at Risk of Non-Compliance with DORA

Running JavaFX applications on ARM with Azul Zulu

Connecting Resilience to Performance in Relation to OpenJDK

The Impact of the EU DORA Act on Non-EU Financial Organizations

1. Third-Party Service Providers

2. Cross-Border Operations

3. Competitive Pressure