Performance on foojay.io - Friends Of OpenJDK

From OpenTelemetry to DuckDB

Tue, 08 Sep 2026 08:29:37 +0000

Observability platforms generally expect you to do your analysis inside them, using their query language and their dashboards. That works for the questions you already know you have. It works less well for the ad-hoc ones: a quick percentile , a pivot by status code , or “which service is actually eating the latency budget?” once the data is in front of you.

This article describes a small pipeline for that kind of question. On one side is DuckDB, the in-process analytical database that reads CSV, JSON and Parquet directly. On the other is the Dash0 CLI, which pulls OpenTelemetry spans, logs, metrics and traces out of Dash0 and prints them as CSV or JSON.

Jakarta Faces, Java Web Framework, Stateless Edition: Marketplace AliFaces

Sat, 29 Aug 2026 19:22:52 +0000

A Fully Stateless Jakarta Faces Marketplace with Server-Side Rendering — No HttpSession, No Saved ViewState, No Sticky Sessions

(see the poc on: AliFaces POC Run On Oracle OCI(Nanos Unikernel))

Jakarta Faces still carries a few persistent assumptions: it is stateful, it requires HttpSession, it needs sticky sessions to scale horizontally, and its server-side rendering model belongs to an older generation of web applications.

AliFaces challenges those assumptions with running code — not a Hello World, but a marketplace-style application with catalog, search, filters, cart, checkout, orders, browsing history, themes, responsive layouts and a JSON API for mobile clients.

Running DuckDB's JDBC Driver in a GraalVM Native Image

Sat, 29 Aug 2026 16:22:10 +0000

DuckDB is an in-process analytical database. You add one JAR to a Java project and get a SQL engine that reads CSV, Parquet, and JSON files directly, with no server to run.

GraalVM Native Image compiles a Java program ahead of time into a standalone executable that starts in milliseconds and needs no JVM on the target machine.

Combining the two produces a data tool that is distributed as a single binary, like a Go or Rust program, while using Java libraries.

DuckDB in Spring Batch: Replace In-Memory Java Loops with One SQL Statement

Tue, 11 Aug 2026 13:34:43 +0000

Spring Batch jobs usually follow the same pattern: an ItemReader streams rows, an ItemProcessor transforms each one, and an ItemWriter writes them out, chunk by chunk. A chunk-oriented step wires those three pieces together:

new StepBuilder("transform", jobRepository)
 .<Order, Summary>chunk(1_000, transactionManager)
 .reader(reader) // stream rows
 .processor(processor) // transform each row
 .writer(writer) // write the chunk
 .build();

The chunk-oriented processing model (Spring Batch reference).

That pattern works well for moving records between systems.

Embedding DuckDB in a Maven App (and Using It for Things That Aren't Databases)

Thu, 06 Aug 2026 08:46:28 +0000

DuckDB is described as “SQLite for analytics,” which is true: it’s an in-process database engine that runs inside your application, with no server to install or manage. What’s less obvious from that description is that you can get value out of it without ever creating a database at all. Because it can query CSV, JSON, and Parquet files directly — local or over HTTP — it works perfectly well as an embedded data-crunching library that happens to speak SQL.

Idempotent Spring Boot: Safe REST with One Annotation

Tue, 04 Aug 2026 22:11:22 +0000

Idempotent REST Endpoints Without the Boilerplate

Stop Charging Your Users Twice: Idempotent REST Endpoints with One Annotation

The problem nobody talks about until production

A user taps “Pay.” The request times out. Their app retries. Your server charges them twice.

You didn’t write a bug. The network did. But your users don’t care about that distinction.

The idempotency problem shows up in more places than payments. A load balancer replays a timed-out request. A mobile client double-taps a submit button. A Kubernetes pod retries after a restart. From the server’s perspective, all of these look identical: a second POST that arrives after the first one already executed.

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.

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.