Java Core on foojay.io - Friends of OpenJDK

New Between-Quarters Security Updates for Java: What CSPUs Mean for Your Release Pipeline

Mon, 27 Jul 2026 07:31:11 +0000

In an announcement on the OpenJDK Updates Mailinglist on July 20, 2026, Rob McKenna explained a change in the Oracle security release cycle for JDK builds. They plan to deliver security updates for the Oracle JDK as part of (some) monthly Critical Security Patch Updates (CSPUs) .

This brings more exact info, after an earlier message on April 26, 2026, in which Oracle announced the acceleration of Vulnerability Detection and Response . In that article they introduced the idea of monthly Critical Security Patch Updates (CSPU) across all their products. At that moment, it was not clear if this also applied to the Java releases, and how this would impact the normal quarterly cycle of Critical Patch Updates (CPUs).

Azul Zulu July 2026 Quarterly Update Released

Thu, 23 Jul 2026 12:35:26 +0000

Every three months your production JDKs fall further behind on security patches. Azul closes that gap today with the July 2026 quarterly update for Azul Zulu Builds of OpenJDK, covering Java 26, 25, 21, 17, 11, 8, 7, and 6.

The Quarterly Update Cycle

Every three months, in January, April, July, and October, the OpenJDK project ships security patches, bug fixes, and improvements for all supported Java versions. This predictable schedule lets teams plan Java updates and keep production environments secure.

Your Loom App Quietly Became a Thread Pool Again: A Field Guide to Virtual Thread Pinning

Thu, 16 Jul 2026 07:43:16 +0000

The incident that taught me to respect pinning looked like nothing. A service freshly migrated to virtual threads, a load test that plateaued at about 420 requests per second no matter how much traffic we threw at it, CPU sitting at 9%, zero errors, zero warnings, nothing in the logs. The machine had 8 cores, and the one downstream HTTP call in the hot path took about 19 ms. Do the arithmetic: 8 × (1000 / 19) ≈ 421.

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.

Endive 1.0 Is Here: Wasm on the JVM Ships Under the Bytecode Alliance

Mon, 29 Jun 2026 00:11:00 +0000

A few weeks ago, we wrote about a new generation of Java libraries powered by WebAssembly. SQLite, QuickJS, Protocol Buffers, the Ruby Prism parser, all compiled to Wasm and shipped as regular JARs. No JNI, no platform-specific binaries. Wasm as an implementation detail.

Today, the runtime that makes it all work has its first official release under the Bytecode Alliance . Endive 1.0 is available on Maven Central.

What Shipped

Endive continues the work started as Chicory , the pure-Java WebAssembly runtime that has been powering this ecosystem since 2023. Same API, same community, same codebase. The move to the Bytecode Alliance is organizational, not technical. For details on the fork and governance, see the announcement article .

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

Wed, 17 Jun 2026 10:36:28 +0000

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

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

BoxLang 1.14.0 : Introducing Inner Classes

Thu, 11 Jun 2026 10:29:32 +0000

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

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.

Foojay Podcast #95: Is Your Java App Actually Secure, Or Does It Just Look That Way?

Mon, 11 May 2026 09:57:00 +0000

Is your Java application actually secure, or does it just look that way? In this episode of the Foojay Podcast, Frank is joined by Steve Poole and David Welch, both from HeroDevs , to dig deep into the state of Java security in 2025 and beyond.

Steve introduces the concept of zombie dependencies: end-of-life libraries that appear safely dormant but are quietly accumulating vulnerabilities waiting to bite you. David, a co-chair of the CVE Automation Working Group, explains what a CVE actually is, how the identification and disclosure process works in practice, and why AI tools like Mythos are dramatically accelerating the pace at which new vulnerabilities are found — on both sides of the wall.

Using the Azul Zulu Docker Official Images: From Simple Pull to Lean Container

Fri, 08 May 2026 09:05:22 +0000

Previously in this series:

Azul Zulu is now a Docker Official Image , so getting a trusted, secure Java base image is now just a FROM azul-zulu line in your Dockerfile. But pulling the right image is just the beginning. This post shows you how to use these images in practice, and how a few extra steps can seriously cut the size of what you ship.

UCanAccess: The Modern Pure-Java Bridge to Microsoft Access

Wed, 06 May 2026 08:44:00 +0000

Microsoft Access databases are everywhere. Decades of .mdb and .accdb files silently power spreadsheets, small business applications, and legacy data stores across organizations of all sizes. Yet for Java developers, connecting to these files has historically meant wrestling with native Windows libraries, ODBC bridges, and platform-specific hacks.

UCanAccess puts an end to that. It is an open-source, pure-Java JDBC driver that lets you read and write Microsoft Access databases (.mdb and .accdb) just like any other SQL database — no native drivers, no Windows dependency, no friction.

Foojay Podcast #94: More Than a Blog: How Foojay Connects, Sustains, and Evolves the Java Community

Mon, 04 May 2026 06:26:00 +0000

Foojay.io, the website for the Friends of OpenJDK, is turning six years old. To celebrate, Frank Delporte headed to JCON in Cologne, Germany, and sat down with twelve members of the Java community to talk about what Foojay means to them, what they learn from each other, and how the community is evolving.

This episode covers a lot of ground. Sharat Chandar reflects on 25 years in the Java community and why the people are what keep the language alive. Markus Westergren and Iryna Dohndorf both focus on a theme that comes up again and again: developer sustainability. Not just green software, but how you stay healthy, grounded, and relevant when AI is changing everything around you. Markus and his wife researched how developers are reacting to AI, from ignoring it completely to transforming everything they do. Iryna talks about building resilience and robustness as skills, not afterthoughts.

The Road to Docker Official Images for Java: The Azul Zulu Story

Fri, 24 Apr 2026 08:57:12 +0000

Previously in this series:

Trusted Java Containers: Azul Zulu OpenJDK Joins Docker’s Official Images

After more than two years of collaboration, reviews, and back-and-forth with the Docker team, Azul Zulu Builds of OpenJDK have officially joined Docker’s Official Images program. This is not just a badge of honor. It changes how Java developers can pull and trust their container base images.

The formal announcement is on the Azul blog . In this post, I’ll walk you through what happened, why it matters, and how to start using these images today.

How to Use Java as a Scripting Language

Mon, 23 Mar 2026 10:00:19 +0000

The Scripting Dilemma

If you’re like me, as a Java developer, you struggle to remember bash or python syntax for quick scripts.

You end up “vibe coding” it, then struggle again when you need to adapt it. If only you could write it in Java!

You might say “Java is not for scripting” and “I don’t want maven or Gradle”.Modern Java has quietly eliminated the traditional barriers that made it unsuitable for scripting.With instant execution, shebang support, and zero-setup automation, Java has evolved into a lean scripting language. Write precise, maintainable code without the “vibe coding” that comes with unfamiliar languages.

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.

Foojay Podcast #92: Java 26 Is Here: What's New, What's Gone, and Why It Matters in 2026

Mon, 16 Mar 2026 06:58:00 +0000

Welcome to another episode of the Foojay Podcast! In this episode, we’re talking about Java 26, released on March 17 in the year 26. Again, right on schedule with Java’s six-month release cadence.

Now, Java 26 is not a Long Term Support (LTS) release; that was Java 25. But don’t let that fool you into thinking there’s nothing interesting here. This release brings ten JDK Enhancement Proposals (JEPs). They cover everything from performance improvements to long-overdue cleanups. Of those ten JEPS, five are new features, and we also get five preview/incubator features.

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:

Gotta Code 'Em All: How Java Evolved Beyond Verbosity – Celebrating 30 Years of Pokémon

Fri, 27 Feb 2026 09:57:35 +0000

Happy 30th Anniversary to Pokémon! 🎉

February 27, 2026 marks exactly 30 years since the original Pokémon Red and Green launched in Japan on February 27, 1996. From catching your first Pokémon in Pallet Town to becoming Champion in the Indigo League, the franchise has spent three decades teaching millions of players about strategy, friendship, exploration, and constant improvement, evolving creatures, teams, and even entire generations of games.

Pokémon is literally all about evolution and that same spirit of evolution perfectly matches what’s happening in Java right now.

A Visual Diff of Java’s Evolution: Inside java.evolved

Fri, 20 Feb 2026 17:48:21 +0000

A community project called java.evolved was recently launched to document how common Java coding patterns have changed across releases. Instead of explaining features in isolation, the site presents “before and after” examples: traditional idioms next to modern alternatives.

The approach targets a practical problem. Most developers work in mixed-era codebases where Java 6, 8, and 17 styles coexist. Rather than memorizing new language features, the site shows what existing code would look like if written today.

What 2,000+ Professionals Told Us About the State of Java, AI, Cloud Costs, and the Future of the Java Ecosystem

Tue, 17 Feb 2026 08:58:26 +0000

Every year, I look forward to our State of Java Survey & Report because it gives us a view into how organizations are using Java today and where they’re heading next. This year, more than 2,000 Java professionals from around the world weighed in, and their message is clear:

Java is evolving faster than ever. AI is accelerating that shift. And the pressure to optimize cloud spending and avoid unpredictable Java licensing costs is now shaping strategic decisions across the enterprise.

Foojay Podcast #90: Highlights of the Java Features Between LTS 21 and 25

Mon, 16 Feb 2026 07:32:52 +0000

Every six months, we get a new version of Java. Java 26 is just around the corner and will be released soon. But most companies stick to LTS (Long-Term Support) versions, which are maintained and receive security updates for many more years. Versions 8, 11, 17, 21, and 25 are such LTS versions. Hopefully, most of your systems are already on the latest versions and you are not stuck on 8 or earlier. As a reminder, 8 was released in 2014, so much has changed since then.

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.

Bringing Java Closer to Education: A Community-Driven Initiative

Mon, 02 Feb 2026 18:02:20 +0000

Over the past decades, Java has proven itself to be one of the most reliable, versatile, and widely used programming languages in the world. From enterprise systems to mobile applications and embedded devices, Java continues to evolve and adapt. Yet, one important area still holds enormous untapped potential: education.

This initiative was born from a simple but powerful idea: to aggregate Java-related educational content in a way that helps newcomers get started, supports educators, and encourages new Java initiatives focused on learning. By making Java more accessible and visible in educational environments, we strengthen not only the language itself, but the entire ecosystem around it.

OpenJDK January 2026 Critical Patch Update and Patch Set Update Released

Wed, 21 Jan 2026 08:32:01 +0000

The January 2026 OpenJDK quarterly updates are now (or will soon be) available from various OpenJDK distributors. This quarterly release brings important security fixes and updates to all currently supported Java versions.

The Quarterly Update Cycle

Every three months (in January, April, July, and October), the OpenJDK project releases security updates, bug fixes, and improvements for all supported Java versions. This predictable schedule helps organizations plan their Java updates and maintain secure, stable production environments.

The FFM API: How OpenJDK Changed the Game for Native Interactions (And Made Pi4J Better!)

Fri, 16 Jan 2026 08:18:00 +0000

The Pi4J project is a Java library that allows you to control the GPIO pins and electronic components connected to a Raspberry Pi with pure Java code. It removes the complexity of using native libraries and the Java Native Interface (JNI) , allowing you to focus on your application logic.

This is a crosspost from the article I contributed to this year’s JVM Advent .

In the Java Advent of 2020, I published “Light up your Christmas lights with Java and Raspberry Pi ”, using Java 11 and Pi4J V1.2. Wow, things have changed a lot: this article uses Java 25 and a snapshot of the soon-to-be-released Pi4J V4!

The Ultimate 10 Years Java Garbage Collection Guide (2016–2026) - Choosing the Right GC for Every Workload

Thu, 15 Jan 2026 10:00:00 +0000

Memory management remains the primary factor for application performance in enterprise Java environments. Between 2017 and 2025, the ecosystem shifted from manual tuning to architectural selection. Industry data suggests that 60 percent of Java performance issues and 45 percent of production incidents in distributed systems stem from suboptimal Garbage Collection (GC) behavior. This guide provides a strategic framework for selecting collectors based on workload characteristics. It covers the transition from legacy collectors to Generational ZGC, analyzing trade-offs regarding throughput, latency, and hardware constraints with mathematical precision.

First Experiments with Java on the LattePanda IOTA: An Alternative to Raspberry Pi?

Thu, 11 Dec 2025 09:13:14 +0000

After years of experimenting with Raspberry Pi boards, Java, JavaFX, and Pi4J to control electronics, I wanted to explore whether my knowledge and experience could be applied to similar boards from other providers. There are many alternatives available these days, based on ARM, Intel processors, and RISC-V architectures.

I reached out to several suppliers to see if I could get evaluation copies, and I’m happy to share that I received my first box from DFRobot containing the LattePanda IOTA .

Java, What's Old? Part III - I/O

Tue, 09 Dec 2025 08:23:00 +0000

After Java, What’s Old? Part I: Collections and Java, What’s Old? Part II: Utils , let’s now have a look at less-known old input/output classes of the JDK that can still be useful.

Everything in this series will be in Java 8 and later, so after reading this article, you will be able to use it in your projects.

Scanner

Scanner is a class in java.util package that helps you parse files and input stream.

foojay – a place for friends of OpenJDKJava 21+ on Raspberry Pi Zero 2 is Back In Business

Thu, 04 Dec 2025 08:46:00 +0000

As described before on Java 21+ Not Working on Raspberry Pi Zero 2 , a problem appeared to execute Java code on the Raspberry Pi Zero 2 with OpenJDK 21 or higher. Reason: in OpenJDK 21 the Just-In-Time (JIT) compiler has been improved, but this change doesn’t work correctly on the ARM Cortex-A53 processor as used in the Zero 2. It’s another type of processor compared to, for instance, the Raspberry Pi 4 (Cortex-A72) and 5 (Cortex-A76).

Foojay Podcast 83: OpenJDK Evolutions plus Tips and Tricks

Mon, 24 Nov 2025 06:07:00 +0000

Welcome to another episode of the Foojay Podcast! Just like in the previous episode, I bring you conversations from two of Europe’s premier Java conferences - Devoxx in Belgium and JFall in the Netherlands.

At these conferences, I had the opportunity to speak with members of the Java community about topics ranging from the evolution of Java itself to mobile development, performance optimization, and even automotive security.

My first guest is Johan Vos, a Java Champion who takes us on a journey through Java’s history - from porting Java to Linux in 1995 to his current work on bringing Java and JavaFX to mobile and embedded devices through the Java On Mobile project.

Foojay Podcast #82: OpenJDK Projects (Leyden, Babylon, Panama) and TornadoVM

Mon, 17 Nov 2025 07:35:00 +0000

In this Foojay Podcast, we’re diving deep into some of the most exciting developments happening within the OpenJDK and TornadoVM projects.

At the Devoxx and JFall conferences, we spoke with several speakers and visitors about some of the major themes shaping the future of Java development. The first guest is Moritz Halbritter from the Spring Engineering team. He provides us with more insights into Project Leyden and how it’s improving Java startup times through ahead-of-time compilation and profiling. We’ll learn how Spring Boot developers can already take advantage of these improvements today.

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 #7

Tue, 14 Oct 2025 05:35:01 +0000

Fourteen days have passed, and it is time to present a fresh collection of readings that could influence developments in the field of artificial intelligence.

Beyond focused tutorials that can enhance your understanding of AI applications, this newsletter concentrates on Hallucination, Java Code Generation, Testing, Agentic System Architecture and LLM benchmarking methodologies designed to ensure models accuracy and competency in handling complex contextual information.

The world influenced by LLM is changing very quickly, let’s start…

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.

Design Patterns Update to JDK25

Wed, 24 Sep 2025 11:29:34 +0000

T he information technology landscape is changing rapidly. This is not only due to the utilization of AI and new methodologies [8] , or business requirements trying to keep up, but also because of the incremental complexity of expected solutions.

Statistics and probability are slowly beginning to play a very important role in this evolution. The Java ecosystem has proven its maturity many times by delivering essential features that businesses require, although many may argue that these have been inspired by other existing solutions.

Here's Java 25, Ready to Perform to the Limit

Tue, 16 Sep 2025 06:05:00 +0000

It’s been six months since Java 24 was released, so it’s time for a fresh set of new Java features.

And the feature that immediately grabs the attention this time is stable values, taking Java’s support of immutability to the next level. Also, Java’s focus on improving performance intensifies, as more JEPs emerge from Project Leyden. On top of that, the Java Flight Recorder is now more equipped than ever to tackle performance issues!

Research: Measuring Energy Consumption in Programming Languages for AI Applications

Mon, 15 Sep 2025 07:03:00 +0000

Decades ago, I contributed to a very interesting project called SunSPOT at SUN Microsystems. It was a small device with wireless connectivity, built-in sensors, running on Java (compatible with runtime 1.6), and powered by battery. It enabled the design of small applications and the connection of additional hardware, or simply the utilization of available sensors. Later, together with Markus Hirt, we created the Robo4j framework . A small and lightweight Java framework that enables rapid assembly of robots or other IoT systems (JDK 21+). In Robo4j, we primarily used thePi4j project for handling I/O operations on the Raspberry Pi platform with drivers created for specific hardware.

Taking Java Arrays to Another Dimension

Fri, 29 Aug 2025 12:53:09 +0000

Explore the intricacies of Java’s multidimensional arrays with this in-depth guide. Learn how to declare, initialize, and utilize arrays of Java arrays to manage complex data structures effectively. In this blog post, Azul Deputy CTO Simon Ritter explains how to leverage multidimensional arrays as a tool to do even more.

Java, along with many other programming languages, includes the concept of arrays. An array is an object that contains a number of variables. Since an array is itself an object, the variables in an array can also be arrays, which leads us to the idea of multidimensional arrays.

Why Java is Still Worth Learning in 2025: A Developer's 25-Year Journey

Mon, 04 Aug 2025 06:32:05 +0000

I’ll be honest - my first encounter with Java in 1999 wasn’t love at first sight. It was during a university distributed systems course, and coming from a background in assembler and C, Java felt bloated, slow, and frankly untrustworthy. That “automatic memory handling” seemed like dangerous magic I couldn’t control. After years of meticulously tracking every allocated memory block, the idea that the runtime would handle memory management felt like giving up control to forces I didn’t understand.

For the first eight years of my career, I stubbornly stuck with C, convinced that Java was just a passing trend for developers who couldn’t handle “real” programming.

Java, What's Old? Part II: Utils

Wed, 30 Jul 2025 08:48:29 +0000

After Java, What’s Old? Part I - Collections , let’s now have a look at less known old utility classes that can still be useful.

Everything in this series will be in Java 8 and later, so after reading this article, you will be able to use it in your projects.

Objects

Objects (with a s) is a utility class from the java.util package that contains static methods to make your code more readable. Do not confuse it with the Object (without s) class of the java.lang package.

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 .

Foojay Podcast #75: JCON Report, Part 4 - Tips and Tricks for Java Devs

Mon, 14 Jul 2025 06:47:00 +0000

This is the final part of the JCON 2025 interviews with a lot of tips and tricks!

In the three previous podcasts, we featured interviews from the JCON conference on “Being a better Java developer ,” “Evolutions in Java ,” and “How to use AI with Java .” However, we talked to many more people during the conference, so this podcast focuses on tips and tricks. Let’s learn from the many other experienced visitors of JCON.

Clean and Modular Java: A Hexagonal Architecture Approach

Tue, 24 Jun 2025 08:03:50 +0000

One of the discussions that always leaves me with both doubts and excitement is the one about system architecture. Ever since I started diving deeper into programming, I’ve encountered questions like how to separate packages and modules: is it really worth creating so many divisions? I must admit, it’s often complicated to understand or make decisions without being fully sure that I’m doing the right thing.

Right from the start, I want to make it clear that this content will definitely spark a lot of discussion around best practices and whether what I’m doing is correct — but, above all, I guarantee it will be fun!

Java, What's Old? Part I: Collections

Thu, 19 Jun 2025 08:31:52 +0000

A few weeks ago, I had the honor to present at the Arnhem JUG in the Netherlands about “Java, What’s old?” In this series, I’m focusing on what’s old in the JDK, not that known, and can be useful. A few hidden gems in the JDK.

Everything in this series is in Java 8 and earlier. So after reading this article, you will be able to use it in your projects.

Foojay Podcast #73: JCon Report, Part 2 – Evolutions in the Java language and runtime

Mon, 16 Jun 2025 07:42:00 +0000

In the second part of our JCON interviews, recorded at the conference in May, we focuses on general evolutions within the Java world and how they influence how we write code and develop applications. We take a look back at the history of Java, discuss new features in the latest release, how Java evolves with OpenJDK projects and JEPS, how Java is used in education, and much more…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Java’s Structured Concurrency: Finally Finding Its Footing

Wed, 04 Jun 2025 12:21:07 +0000

The structured concurrency API changed again after two incubations and four rounds of previews.

Ideally, this scenario is unexpected.

However, given its status as a preview API, such changes can occur, as was the case here.

These changes lend considerable maturity to the API, and I am hopeful it will now stabilize without requiring further modifications.

What Actually Changed This Time

When I first started working with structured concurrency back in its incubation phase, I was excited about the promise of cleaner concurrent code.

Foojay Podcast #71: Celebrating 30 Years of Java with James Gosling

Mon, 05 May 2025 06:55:39 +0000

We are celebrating Java’s 30th anniversary this May!

This is a very special anniversary episode of the Foojay Podcast! As we approach May 23rd, marking exactly 30 years since Java’s first beta release in 1995, we’re honored to present our first-ever single-guest podcast. But we have a very special guest for you: James Gosling, the creator of Java!

Join us for this exclusive conversation as we explore Java’s beginnings, its revolutionary impact on the programming world, its continuous evolution over three decades, and James’s insights on where the language is heading. From that groundbreaking beta release over “Write Once, Run Anywhere” to powering billions of devices worldwide, this is the story of Java, told by the man who started it all, the father of Java.

Async file IO with Java and io_uring

Fri, 18 Apr 2025 09:28:16 +0000

When I first started exploring Virtual Threads in Java, I wanted to understand everything about them like, performance characteristics, when they yield, and limitations. This journey led me to an interesting challenge about file I/O operations. These operations cause Virtual Threads to become “pinned” to platform threads, limiting their effectiveness for I/O-heavy applications.

This pinning issue has been widely acknowledged across the Java community. It’s mentioned in the Virtual Threads JEP , discussed on Reddit threads , debated on mailing lists , and highlighted in the “State of Loom ”. The consistent message: File I/O and Virtual Threads don’t play nicely together.

Six JDK 24 Features You Should Know About

Thu, 03 Apr 2025 08:42:12 +0000

Since 2018, we’ve had a new release of the Java platform every six months. With Swiss watch-like regularity, the latest version of Java is upon us. This time it’s JDK 24. In an almost poetic way, it contains 24 JDK Enhancement Proposals (JEPs).

JDK 24, which was released on March 18, 2025, has 24 JDK Enhancement Proposals (JEPs), the largest number of new features since the introduction of the time-based release schedule. While 10 of them are preview features, incubator modules, or experimental, that still leaves 14 new features.

Clean your Memory: From Finalize to Cleaner

Mon, 31 Mar 2025 12:30:08 +0000

Garbage collection in Java takes care of memory management, but it does not clean up non-memory resources like sockets or file handles.

Resource leaks may occur without proper management, leading to performance degradation or crashes.

Java’s Cleaner API , introduced in Java 9, provides a modern and efficient mechanism for resource cleanup when objects are no longer reachable.

It addresses the shortcomings of the deprecated finalize() method, offering a predictable and efficient way to manage non-memory resources: so let’s take a short trip on clean memory from finalize to Cleaner API.

Foojay Podcast #68: Welcome to OpenJDK (Java) 24

Mon, 17 Mar 2025 06:44:08 +0000

We serve you a podcast about the new Java version every six months.

Our regular guest, Simon Ritter, Deputy CTO of Azul, is known on social media as “speakjava.” He is part of the OpenJDK vulnerability group, JCP executive committee, and expert group for the Java SE specification request so that he can share a lot of inside information with us.

In this episode, we are joined by Hanno Embregts, a Java Developer by day and musician by night. He publishes a post on Foojay with all the details of every new Java release and prepared a long description of all the new features included in Java 24.

Project Loom: Structured Concurrency - Java

Wed, 29 Jan 2025 12:12:38 +0000

In today’s era of cloud computing, where high-performance infrastructure is readily available, developers face a complex challenge in achieving efficient concurrency.

While modern technological advancements have brought us closer to solving these challenges, we must adopt a thoughtful, incremental approach to concurrency.

This principle holds especially true as we strive to design scalable, reliable, and easy-to-maintain systems.

One such advancement in this domain is structured concurrency, a paradigm that simplifies concurrent programming by bringing order and predictability to task management.

How JVM handles exceptions

Tue, 21 Jan 2025 14:45:12 +0000

It’s interesting to know how the JVM runs bytecode instructions… But do you know what is going on when an exception is thrown? How does the JVM handle the delegation of control? What does it look like in the bytecode?

Let me quickly show you!

Example

Here’s a simple bit of Java code that includes all the important actors in the exception-throwing game (try-catch-finally):

int a = 0;
try {
 if (a == 0) { // to make it less boring, let's have some branching logic
 throw new Exception("Exception message!");
 }
} catch (Exception e) {
 doSomethingOnException();
} finally {
 doSomethingFinally();
}

Exception table

The resulting bytecode includes an interesting section in the Code attribute called the Exception table. Each method can have its own exception table, and it’s only present when relevant. If there is no exception-handling logic in the method, it won’t have an exception table.

Foojay Podcast #64: Interviews at JFall about opensource, OpenJDK evolutions, Project Loom, JVM,...

Mon, 23 Dec 2024 10:51:20 +0000

Let’s wrap up this year with more interviews from the JFall conference.

In this episode you’ll learn more about Foojay, JVM internals and writing your own programming language, Project Loom and structured concurrency, learning at conferences, code reviews, creating desktop applications with Java, infrastructure as code, JUG Noord, and much more!

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #63: How do we keep your Java applications up to date and secure?

Mon, 16 Dec 2024 12:41:10 +0000

Last month, I published a Foojay article about the risks in systems that are stuck on old or outdated Java versions and got a lot of feedback from developers . Most of them want to move on but get stuck on management decisions, outdated production environments, or one of the many other reasons that keep systems stuck on old Java versions and dependencies.

Do you want to bring your system from Java 8 to 23? Did you know that Java 17 already has 13 security releases? And that you can use tools like OpenRewrite to help you update your code?

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.

Hot Class Reload in Java: A Webpack HMR-Like Experience

Tue, 19 Nov 2024 15:57:59 +0000

In the world of software development, time is everything. Every developer knows the frustration of waiting for a full application restart just to see a small change take effect.

Java developers, in particular, have long dealt with this issue. But what if you didn’t have to stop and restart every time you updated a class? Enter Hot Class Reload (HCR) in Java—a technique that can keep you in the flow, reloading classes on the fly, much like Hot Module Reload (HMR) does in JavaScript.

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…

JDK 23: Module Design Pattern with JEP-476

Thu, 31 Oct 2024 09:41:20 +0000

Although the module design pattern can be implemented in many different ways, the main motivation behind using it remains the same. This is the isolation of a specific section into small building blocks, which are the so-called modules. Therefore, the module design pattern belongs to the structural design pattern family.

Before Java 9, each project using the module design pattern at any level was a bit difficult and many times broken. Such a situation had a direct impact on source code maintainability and event extensibility, as it was very easy to break module boundaries. Many times this state has been called a bit like “classpath hell”. In order to avoid such a situation, it was necessary to preserve the coding discipline.

Learn About How Your Peers Use Java!

Thu, 24 Oct 2024 12:44:16 +0000

Do you ever wonder what OpenJDK distributions and what Java versions your peers are using? Java-based infrastructures and languages? How many are using Java to code AI functionality? How Java workloads are affecting cloud compute costs?

Azul has been gathering all that data from a survey of Java users, running until 6:30pm CT on October 31, 2024. If you want to participate, the survey is short, and we’ll hook you up with the report after the survey is complete in January 2025.

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.

Deep dive into bits, bytes, shorts, ints, longs, signed, and unsigned with Java

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

On the Pi4J discussion list, someone recently asked what the best and easiest way is in Java to convert a byte value . In Java, there is no distinction between signed and unsigned bytes, which can be confusing. My book “Getting Started with Java on the Raspberry Pi” contains an explanation about this, and I am happy to share it in this post with some more info and code examples…

Foojay Podcast #58: How Java Developers Can Secure Their Code

Mon, 30 Sep 2024 07:43:46 +0000

Three years after Log4Shell caused a significant security issue, we still struggle with insecure dependencies and injection problems.

In this podcast, we’ll discuss how developers can secure their code.

I talked with three authors who posted a security and code quality post on Foojay.io.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Azul Brings Java from Edge to Cloud

Fri, 27 Sep 2024 11:30:22 +0000

In Part 1 of this series, “A Fresh Look at Embedded Java ,” we explored the use of Java for embedded use cases.

Azul and its Zulu Build of OpenJDK (Zulu) are the ideal partners in this part of the software world.

Let’s expand and look at the cloud part of a typical end-to-end solution with sensors, edge devices, client applications, and cloud services.

Azul Platform Core for edge devices and client applications

Because Java delivers fast development speed thanks to its amazing methods and tools and its impressive performance in handling massive amounts of data, it’s the ideal programming language for building applications for edge devices that collect data from various sensors.

Java 23 Has Arrived, And It Brings a Truckload of Changes

Tue, 17 Sep 2024 06:45:11 +0000

Java 23 has arrived! It’s been six months since Java 22 was released, so it’s time for a fresh truckload of JEPs.

In this article, we take you on a tour of everything that is part of this release, giving you a brief introduction to each of them.

Where applicable the differences with Java 22 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to start using these features after reading this.

Foojay Podcast #57: Welcome to OpenJDK 23

Mon, 16 Sep 2024 11:34:40 +0000

OpenJDK (Java) 23 is (almost) here!

OpenJDK 23 introduces three new features to the language and runtime and many bug fixes, small improvements, and a longer list of preview features.

What are the most important facts about this release? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

A Fresh Look at Embedded Java

Wed, 11 Sep 2024 07:37:10 +0000

Since its inception, Java has promised to “Write Once, Run Anywhere.” In its early days, the main focus of Java was embedded devices, such as set-top boxes and televisions.

But soon, it became one of the leading programming languages powering high-scale business applications that can handle massive amounts of transactions with high throughput.

Because those use cases are very visible and there are a lot of job opportunities within that area, we tend to forget that Java on embedded is also still very much alive and kicking!

Top Security Flaws hiding in your code right now

Thu, 05 Sep 2024 16:41:02 +0000

Recent years have seen numerous injection attacks causing significant damage, including a 2019 SQL injection breach in the Fortnite video game and a 2018 attack on Tesla’s systems.

Other serious incidents involve the Log4Shell logging injection and a deserialization attack on Atlassian Jira. These examples show that various code vulnerabilities can affect any organization. This article will examine the three most common attack types—SQL injection, Deserialization Injection, and Logging Injection—and discuss ways to prevent them.

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.

Trash Pandas Love Enterprise Java Garbage Code

Tue, 13 Aug 2024 08:16:55 +0000

If raccoons were software engineers, they would feel at home inside many enterprise systems. These systems are often full of unused and dead code that was written, fully tested, then altered in a way that prevents teams from ever running it.

This garbage code — a raccoon’s favorite — is a maintenance burden that developers must work around to keep passing tests while other major changes are made. This code often doesn’t end up in the trash because it’s hard to know what can be safely removed without breaking the application. But you can better identify bad code if you understand how to look for it.

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.

JUG PH: 1-Day Modern Java Development Bootcamp

Fri, 02 Aug 2024 07:53:16 +0000

A 1-Day Modern Java Bootcamp for students, early professionals and career shifters with minimal Java programming or general programming experience.

The Java User Group Philippines (JUG PH) in partnership with Developer Connect (DEVCON) Philippines/Manila executed its 1st Modern Java Development Bootcamp.

The bootcamp was organized by the JUG Leaders and Volunteers and DEVCON Volunteers.

Registration

The bootcamp received an overwhelming 110+ registrations but 50 was only accomodated due to the slots of the venue.

Understanding JVM Memory Layout with OpenJDK24's New PrintMemoryMapAtExit VM Option

Sat, 27 Jul 2024 10:38:31 +0000

OpenJDK24 recently added a new HotSpot JVM option called PrintMemoryMapAtExit.

I know this because I’m the maintainer of a project called VMOptionsExplorer, whose job is to track changes to the more than 2000 command line options you can use to control the Java Virtual Machine (JVM).

VMOptionsExplorer presents this information as a searchable online dictionary of VM options available at https://chriswhocodes.com

and also on Foojay at https://foojay.io/command-line-arguments/ (although the Foojay copy doesn’t always cover the latest JDKs).

Effective Java Logging

Mon, 22 Jul 2024 11:39:40 +0000

Effective Logging is an essential aspect of any Java application, providing insights into its operational state. It is especially crucial in production environments, where it aids in debugging, monitoring, and incident response. In this comprehensive guide, we will explore the effective practices for using SLF4J with Logback, ensuring a reliable and maintainable logging strategy.

By following these best practices, developers and operations teams can leverage SLF4J and Logback to turn logs into strategic resources for application management and incident resolution. Embracing these guidelines will lead to improved observability, quicker troubleshooting, and a deeper understanding of system behavior, establishing a solid foundation for application reliability and performance.

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.

Structured Concurrency is More Than ShutdownOnFailure

Thu, 11 Jul 2024 16:34:52 +0000

Since Java 21, structured concurrency has been added as a preview feature. Structured concurrency is a way to manage sub-tasks that are run in parallel within a given scope.

If you’ve ever seen a presentation about structured concurrency , you’ve probably seen the use of the ShutdownOnSuccess or ShutdownOnFailure classes.

These classes will stop the scope and the still running sub-tasks within that scope when one of the sub-task succeeds or fails.

Dynamic watermarking on the JVM

Tue, 09 Jul 2024 07:59:29 +0000

Displaying images on your website makes for an interesting problem: on one side, you want to make them publicly available; on the other, you want to protect them against undue use. The age-long method to achieve it is watermarking:

A digital watermark is a kind of marker covertly embedded in a noise-tolerant signal such as audio, video or image data. It is typically used to identify ownership of the copyright of such signal. “Watermarking” is the process of hiding digital information in a carrier signal; the hidden information should, but does not need to, contain a relation to the carrier signal. Digital watermarks may be used to verify the authenticity or integrity of the carrier signal or to show the identity of its owners. It is prominently used for tracing copyright infringements and for banknote authentication.

The Best Way to Handle Phone Numbers

Fri, 05 Jul 2024 07:00:23 +0000

Processing phone numbers seems complicated at first glance because of the many different formats. In this post, I’ll show you that with libphonenumber, it becomes child’s play. I’ll also recommend how to store the phone number in the database.

Introduction Google’s libphonenumber

According to the GitHub repository https://github.com/google/libphonenumber/ libphone number is:

Google’s common Java, C++ and JavaScript library for parsing, formatting, and validating international phone numbers. The Java version is optimized for running on smartphones, and is used by the Android framework since 4.0 (Ice Cream Sandwich).

Foojay Podcast #55: Embedded Java, Part 2

Mon, 01 Jul 2024 08:21:42 +0000

As a backend developer, you may not realize that Java was initially born on embedded devices like set-top boxes and gateways. We discussed this topic for the first time almost three years ago in Foojay Podcast #2 with James Gosling, Johan Vos, Erik Costlow, and Frank Delporte .

In this episode #55, we look into the history of the Java Micro Edition and how things evolved. Nowadays, with processors becoming increasingly powerful, we can run the exact same Java runtime on any Linux system, from the biggest cloud servers to the smallest Raspberry Pi Zero.

Master Your Journey in the School of OpenJDK Migration

Sun, 30 Jun 2024 09:46:03 +0000

Azul has led so many OpenJDK migrations, we could write a book. Like, seriously, we wrote the book . If you prefer more a more visual, immersive experience, welcome to the School of OpenJDK Migration!

The School of OpenJDK Migration is your ultimate resource for mastering OpenJDK migration. Dive into our rich collection of webinars, where OpenJDK experts divulge their secrets, from foundational knowledge to advanced tactics, derived from industry knowledge and professional experience. You’ll leave the course with a blueprint to navigate the complexities of OpenJDK migration with confidence and ease.

Foojay Podcast #54: Music and MIDI with Java and Kotlin

Mon, 24 Jun 2024 18:23:33 +0000

MIDI is a universal standard for communicating between musical instruments and computers.

Within OpenJDK, there is a whole Java package dedicated to MIDI communication and data handling. Is it up to date? Are there better approaches now? And what can we do with music, Java, and Kotlin?

Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #53: JCON Report, Part 5 – CQRS, JOOQ, GraphQL, API, Vaadin, OpenRewrite, ErrorProne, Gateways, Proxies,...

Mon, 17 Jun 2024 09:24:52 +0000

This is the final part of the JCON interviews. Did I save the best for last? It’s up to you to decide…

In this episode you’ll hear Simon Martinelli, Nicolas Fränkel, Marcus Hellberg, Rick Ossendrijver, and Abdel Sghiouar.

We talked about a bunch of topics like evolving your APIs, GraphQL, Java versus Kotlin versus Rust, Vaadin, AI and ChatGPT, OpenRewrite, ErrorProne, Infrastructure, and a lot more.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Foojay Podcast #52 from JCON in Cologne!

Mon, 10 Jun 2024 09:32:12 +0000

This is part 4 of the JCON interviews!

In this episode, we have 5 new guests for you.

We start with garbage collectors and Intelligence Cloud, a tool created by Azul to find out which of your code is actually used in production and which dependencies are known to have vulnerabilities. My colleague Gerrit Grunwald was at JCON to give a talk about these subjects.
With Balkrishna Rawool we dove into Virtual Threads, a very interesting topic as concurrency and threads can be challenging…
Piotr Przybyl came to JCON to give a talk about Test Containers and how to test your application in an environment that is similar to your production environment. Another important topic related to testing is Flaky Tests. How do you handle tests that only fail from time to time and make your whole test report unreliable?
François Martin had a talk about this subject, and he came to the conference together with Annelore Egger, who was one of the many volunteers.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Java: Functional Programming f(x) – Part2

Mon, 03 Jun 2024 17:05:56 +0000

In the preceding article , we explored the significance of Functional Programming, Lambda Calculus, and other related concepts.

In this article, we delve deeper into the essential aspects of Functional Programming, such as…

1. Lambda Expressions 2. Method References 3. Functional Interfaces

And we will discuss about the relationship between each of the features.

JSR 335 has greatly facilitated programming in a multicore environment by introducing Lambda Expressions/closures/anonymous method, and related features.

Foojay Podcast #50: JCON Report, Part 2 - Maven, Software Security, Code Quality

Mon, 27 May 2024 08:07:54 +0000

This is part 2 of the interviews we recorded at the JCON conference earlier this month in Germany. In this episode, you get two main topics: Maven and Code Quality.

In the first part, you’ll hear Karl Heinz Marbaise and Steve Poole discuss the Maven project, the repository, Sonaytype, and the security impact of dependencies.

But next to security, we developers are also responsible for creating readable and maintainable code. Miro Wengner, Marit van Dijk, and Hinse ter Schuur dive into this topic, in the second part!

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:

Foojay Podcast #49: JCON Report, Part 1 - JUGs, Communities, Generative AI, and more!

Tue, 21 May 2024 06:05:39 +0000

On Tuesday, May 14th, the Foojay Podcast went live at the JCON conference in Cologne, Germany, to talk with speakers and visitors about all things Java.

We had so many amazing talks that we will combine them into several podcast episodes in the next weeks.

This is part 1 about JUGs, Communities, Open Source, Generative AI, LangChain4j, Machine Learning!

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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.

Let's Replace the synchronized Keyword

Tue, 07 May 2024 04:26:29 +0000

Let’s see in this article different ways to replace the synchronized keyword to make our code more virtual threads friendly.
Lines of code of the different solutions discussed in this article

Synchronized and pinning threads

Since Java 21, we can enjoy virtual threads and have more than 1 million threads in Java.

But it has a condition, the virtual thread shouldn’t be pinned to the OS thread.

Pinning means that a virtual thread is blocking the OS thread from being used by any other virtual threads.

Functional Programming: Revolutionizing Software Development

Thu, 25 Apr 2024 17:43:17 +0000

Mathematics serves as the driving force behind significant advancements in computer science from my perspective. We deeply root the fundamental principles that we utilize in our daily programming tasks and application development in mathematical concepts. I am constantly intrigued by the opportunity to incorporate mathematical ideas into the programming languages I work with as a student of Mathematics.

Many other programming paradigms, like functional programming, take inspiration from Mathematics to address challenges related to concurrency and parallelism. Computing shifts towards utilizing multiple cores and distributed systems, which makes this increasingly important.

Java 22 Is Here, And It's Ready To Rock

Tue, 19 Mar 2024 13:56:23 +0000

Java 22 is here!

It’s been six months since Java 21 was released, so it’s time for another fresh set of Java features.

In this article, you’ll go on a tour of the JEPs that are part of this release, giving you a brief introduction to each of them.

Where applicable, the differences with Java 21 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after reading this!

Foojay Podcast #45: Welcome to Java 22

Mon, 18 Mar 2024 10:31:53 +0000

Last September, we got Java 21, a Long Term Support (LTS) version with eight new big features and seven incubator or preview features.

Does Java 22 also bring that much innovation, or is it just a bug-fix release?

And what needs to be done to get such a release published on time? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

How Oracle Separates Java Pricing from Value

Fri, 15 Mar 2024 14:00:25 +0000

On January 23, 2023, Oracle quietly replaced the online link to the Oracle Java SE Subscription Global Price List with a link to a new Oracle Java SE Universal Subscription Global Price List.

The old Oracle Java pricing was far from perfect. It was based on a processor-count metric for servers and a named-user-plus metric for desktops. With the processor-count metric, the license cost was determined by multiplying a processor’s total number of cores by a core processor licensing factor specified by Oracle. The named-user metric applied to all individuals authorized to use a program regardless of whether they were actively using it. These definitions left the door open for uncomfortable conversations with Oracle reps who were famous for setting up meetings “to talk about your Java usage.” Unpleasant in themselves, these meetings could lead to painful Java audits.

Builders, Withers, and Records - Java’s path to immutability

Wed, 28 Feb 2024 12:19:11 +0000

We know that immutable objects are easier to maintain, lead to fewer errors, and are multi-thread friendly. In this article, I will talk about two different approaches in Java to creating objects: Builders and Withers, typically used in the context of immutable objects, along with a new type of immutable object in Java: Records.

When it comes to creating objects in Java, we can use fluent approaches, especially for complex objects containing lots of fields, that will increase readability and also adaptability allowing us to evolve the code with lower impact on the existing code. And we want to because fluent code is both easier to read and easier to write.

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.

foojay – Sorting Text in Java

Wed, 07 Feb 2024 08:41:54 +0000

Sorting text should be easy as String implements the Comparable interface. In this article, we’ll see that it can be more complicated than that.

Text is represented by the String class in Java. In this article we’ll explore how to sort String, the advantages and drawbacks of each possibility.

Level 1: Comparable

The class String implements Comparable so sorting a list of String is as simple as

List<String> textList = new ArrayList<>(List.of("test","test11","test2","Test4","test3","test5","tést2","test2","3test","testa","test2a","test4a","test2b"));
Collections.sort(textList);

=> [3test, Test4, test, test11, test2, test2, test2a, test2b, test3, test4a, test5, testa, tést2]

Achieving High Throughput Without Sacrificing Latency

Fri, 02 Feb 2024 09:39:47 +0000

Latency and Throughput

In discussions on performance, it is common to encounter the terms Latency and Throughput to describe the characteristics of a software component.

We can define these terms as follows:

Latency is a measure of the time taken for one thing to occur. For example, it could be the time taken to respond to a change in the price of a financial instrument that could influence the decision on whether to buy, or sell. It could be the time taken for a component monitoring some external device to respond to an indication of a change in the status of that device (like a change in temperature reported from a thermometer).

Building gdocweb with Java 21, Spring Boot 3.x and Beyond

Tue, 30 Jan 2024 12:40:00 +0000

Table of Contents

Introducing gdocweb
- Java 21 and Spring Boot 3.x: Innovation and Maturity
GraalVM Native Image for Efficiency
Deployment: VPS and Docker Compose
Front-End: Thymeleaf Over Modern Alternatives
Final Word

Starting a new project is always a mix of excitement and tough decisions, especially when you’re stitching together familiar tools like Google Docs with powerhouses like GitHub Pages.

Java Flight Recording and Analysis with Azul Mission Control

Thu, 25 Jan 2024 07:59:42 +0000

Java Flight Recording (JFR) is a Java Virtual Machine (JVM) profiling and diagnostics tool. It enables you to collect and analyze data regarding the performance and behavior of a Java application. As JFR is included in the JVM, there is no need for additional tools or installations to make recordings of your applications.

By utilizing JFR, you gain valuable insights into the runtime behavior of your Java applications. It helps you to optimize performance, identify and troubleshoot issues, and ensure better overall reliability. JFR is designed with very low overhead, allowing its use in production environments with minimal impact on the performance of your application.

Revolutionising Java Collections: The Advent of Sequenced Collections in Java 21

Tue, 26 Dec 2023 14:07:42 +0000

Java has been a staple in the software development world for decades, renowned for its robustness and vast ecosystem. However, some seasoned Java developers have encountered limitations within its collections framework, particularly when dealing with ordered elements.

Enter JEP 431. JEP 431, part of the Java Enhancement Proposal system, represents a significant advancement in Java’s ongoing evolution.

The Java Enhancement Proposal system is a process for proposing, reviewing, and implementing new features in the Java programming language.

Writing C Code in Java

Wed, 20 Dec 2023 09:21:56 +0000

The Foreign Function & Memory API (also called Project Panama) has come a long way since it started. You can find the latest version implemented in JDK 21 as a preview feature (use --enable-preview to enable it) which is specified by the JEP 454 :

By efficiently invoking foreign functions (i.e., code outside the JVM), and by safely accessing foreign memory (i.e., memory not managed by the JVM), the API enables Java programs to call native libraries and process native data without the brittleness and danger of JNI. JEP 454

Strategies for Managing State in Chronicle Services

Fri, 01 Dec 2023 08:41:44 +0000

Introduction

In distributed, microservice-based applications, the management of state is one of the most important, yet difficult aspects of design.

Ensuring the accuracy and consistency of state without introducing excessive complexity that affects performance or flexibility to support evolving requirements requires careful thought.

This article discusses issues around state management and shows how the Chronicle Services framework provides support to deal with these in ways that maintain a resilient and high performing microservices architecture.

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.

Video: "If I decide to stay with Oracle Java what issues will I face?"

Thu, 23 Nov 2023 09:12:35 +0000

Simon Ritter and Gerrit Grunwald answer a question that they hear repeatedly: “If I decide to stay with Oracle Java (rather than migrate to an OpenJDK distribution) what issues will I face?”

Announcing the Build Server for Gradle Open-Source Repository

Tue, 21 Nov 2023 10:08:33 +0000

Build Server for Gradle

In September, we shared that Microsoft and Gradle have joined forces to explore a novel approach to Gradle project import and building, based on the Build Server Protocol (BSP) . The objective is address the existing Gradle issues on Visual Studio Code and improve support for Gradle projects.

The Build Server for Gradle, developed in collaboration with Gradle, will delegate build tasks to the Gradle build tool, which will be responsible for compiling and generating code directly. This ensures that the results of building in Visual Studio Code will be consistent with the output obtained by running Gradle build commands.

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.

JDWP, onthrow and a mysterious error

Thu, 26 Oct 2023 13:44:01 +0000

In my previous Java-related blog post called Level-up your Java Debugging Skills with on-demand Debugging , I showed you how to use the onthrow option of the JDWP agent to start the debugging session on the first throw of a specific exception.

This gave us a mysterious error in JDB:

And I asked if somebody had any ideas. No one had, but I was at Devoxx Belgium and happened to talk with Aleksey Shipilev about it at the Corretto booth: Two OpenJDK developers having fun at Devoxx: Investigating a jdb bug with Shipilev
in the Coretto booth (Tweet )

Navigating Behaviour with Events

Wed, 25 Oct 2023 15:04:35 +0000

Two Approaches

There’s little doubt that modern software architectures lean towards asynchronous models for communication between distributed components (where “distributed” means components that are not part of the same process, be they on the same or on different physical machines). Synchronous models such as Remote Procedure Call (RPC) are now largely discredited [Waldo , Vinoski ]; even asynchronous variants of these are not seen as desirable.

When we strip away the layers that present the illusion that RPC is really just the same as Local Procedure Call (i.e. a normal method invocation), we find sitting above the transport some form of messaging protocol. And these days, the APIs seem more willing to expose developers to these lower-level details, making it clear to programmers that communication with a remote component is inherently more complex than making a simple procedure call.

Foojay Podcast #31: Report of Devoxx 23 in Belgium

Mon, 16 Oct 2023 07:16:57 +0000

The first week of October, the 20th edition of Devoxx took place in Antwerp, Belgium.

Over 3000 Java developers, speakers, and enthusiasts gathered to share their knowledge and learn from each other.

I got the opportunity to walk around with a microphone and talk to visitors and speakers.

Not all of them, as there were just too many people and too many exciting sessions happening simultaneously.

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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).

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.

Java 21 Is Available Today, And It's Quite The Update

Tue, 19 Sep 2023 05:31:13 +0000

Today’s the first day of Java 21’s availability! It’s been six months since Java 20 was released, so it’s time for another fresh wave of Java features. This post takes you on a tour of the JEPs that are associated with this release and it gives you a brief introduction to each of them, and check out the Java 21 podcast here . Where applicable the differences with Java 20 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after reading this!

Foojay Podcast #28: Java 21 Has Arrived!

Tue, 19 Sep 2023 05:27:07 +0000

Since 2018, we get a new version of Java every 6 months.

And version 21, released during today, is a long-term support version that can be used for many years.

It also brings a lot of new features and improvements in both the language and the runtime.

Actually, there are so many that we’ll probably not get all of them discussed in this podcast!

Let’s see what our experts find the most important facts we need to know about Java 21.

The DiscoAPI Helps You To Find Any OpenJDK Distribution

Tue, 12 Sep 2023 03:42:44 +0000

Did you know Foojay is not only a human-readable OpenJDK knowledge base but also provides the Disco API that lets you search all OpenJDK distributions? And even if you didn’t know, you probably already are using it, as it’s integrated into SDKMAN! , JReleaser , JBang! , Gradle toolchain , Paketo buildpacks ,and more.

The Disco API (i.e., the short name for the Universal OpenJDK Discovery API) is a database and API with all the available OpenJDK versions from all distributors, like Corretto, Liberica, Oracle, Temurin, Zulu, and many others. In total, there are now 89352 different packages at the end of August 2023.

The Evolution of Bugs

Tue, 12 Sep 2023 03:34:48 +0000

Memory Management: The Past and The Present
Concurrency: A Double-Edged Sword
The Pervasiveness of State Bugs
Exceptions: The Noisy Neighbor
Faults: Beyond the Surface
Thread Bugs: Unraveling the Knot
Race Conditions: Always a Step Ahead
Performance Pitfalls: Monitor Contention and Resource Starvation
Final Word

Programming, regardless of the era, has been riddled with bugs that vary in nature but often remain consistent in their basic problems. Whether we’re talking about mobile, desktop, server, or different operating systems and languages, bugs have always been a constant challenge. Here’s a dive into the nature of these bugs and how we can tackle them effectively.

A Look at Sealed Classes, Pattern Matching, Functional Paradigms

Mon, 11 Sep 2023 08:42:17 +0000

Introduction

The introduction of Sealed Classes in Java and the combination with pattern matching in switch statements has sparked a debate among software developers.

The argument in question raises concerns about the real-life use cases for Sealed Classes and suggests that pattern matching with switch might promote poor coding practices.

This article aims to counter these assertions by examining the principles and practical applications of Sealed Classes and pattern matching.

Book review: "OpenJDK Migration for Dummies"

Fri, 01 Sep 2023 07:42:43 +0000

In the past couple of years, there have been quite a lot of Oracle Java licensing changes which can have quite the impact on how much using the Oracle JDK will cost your organization, especially since under the latest terms it’s quite easy to have a “rogue” install cost you quite a bit.

This is where the new free book OpenJDK Migration for Dummies by Simon Ritter offers a very useful resource.

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.

Well Worth My Time: "OpenJDK Migration for Dummies"

Thu, 24 Aug 2023 07:51:26 +0000

I’ve just read the (free) OpenJDK Migration for Dummies book . It was well worth my time!

I first started using Java in 1998, so I’ve got a long history with it and feel very comfortable with the language itself. However, the licensing changes and proliferation of OpenJDK distributions are much more recent, and those aspects can be a bit confusing.

The book is obviously written by a vendor, but it’s very honest about that. It does a good job of establishing the motivation for using OpenJDK, providing actionable steps for how to pursue that migration, and presenting meaningful information that a business should consider when selecting an OpenJDK vendor.

Is OpenJDK Just a Drop-In Replacement?

Fri, 18 Aug 2023 07:58:02 +0000

I don’t know anyone who is still using the Oracle JDK. It has been my recommendation for quite a while to just switch to an OpenJDK distribution as they are roughly drop-in replacements for Oracle’s official JDK. I’ve repeated that advice quite frequently but I guess I glossed over a lot of details that might be insignificant for hackers but can become a pretty big deal in an enterprise setting.

Taming the Bias: Unbiased Safepoint-Based Stack Walking

Thu, 17 Aug 2023 14:00:34 +0000

Walking only at safepoints has advantages. The main one is that you aren’t walking the stack in a signal handler but synchronously to the executed program. Therefore you can allocate memory, acquire locks and rematerialize virtual thread / Loom frames. The latter is significant because virtual threads are the new Java feature that cannot support using signal-handler-based APIs like AsyncGetCallTrace.

This article is based on the ideas of Erik Österlund, and the second one is related to these new ideas. The first one is AsyncGetCallTrace Reworked: Frame by Frame with an Iterative Touch! , which you should read before continuing with this post. For a refresher on safepoints, please read The Inner Workings of Safepoints .

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.

Building High-Performance Java Microservices with EDA

Wed, 16 Aug 2023 21:34:18 +0000

Event-Driven Architecture (EDA) is a design principle focused on the creation, detection, and reaction to events.

Renowned for its resilience and low latency, EDA is a reliable choice for developing robust, high-performing microservices.

Moreover, this method can be helpful in improving productivity and making the process of cloud migration smoother.

In this article we will outline 6 key considerations and tactics for developing such services.

1) Crafting Event-Based Microservices

Within EDA, microservices interact with each other through events. An event is simply an immutable indication that something has happened. Microservices register their interest in a subset of events and perform their processing by reacting to these events when they occur. On completion of handling of an event, microservices will usually post one or more events reflecting the result of this processing, which will trigger further downstream microservices.

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:

Sealed Interfaces & Pattern Matching: Java's Modern Capabilities

Wed, 09 Aug 2023 07:01:51 +0000

Sealed classes in Java are a new feature that provides a way to restrict the classes that can inherit from a superclass or extend an interface. This new language feature enhances the encapsulation and provides more control to developers over their codebase.

In this tutorial, we will explore sealed classes, how to use them to find all subclasses, and how to apply pattern matching in a practical context.

Let’s start with a basic interface definition named Shape.

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 Inner Workings of Safepoints

Wed, 02 Aug 2023 10:27:27 +0000

A Java thread in the JVM regularly checks whether it should do extra work besides the execution of the bytecode.

This work is done during so-called safepoints. There are two types of safepoints: local and global.

At thread-local safepoints, also known as thread-local handshakes, only the current thread does some work and is therefore blocked from executing the application.
At global safepoints, all Java threads are blocked and do some work. At these safepoints, the state of the thread (thread-local safepoints) or the JVM (global safepoints) is fixed. This allows the JVM to do activities like method deoptimizations or stop-the-world garbage collections, where the amount of concurrency should be limited.

But this article isn’t about what (global) safepoints are. Fr this, please refer to Nitsan Wakart’s and Seetha Wenner’s articles on this topic and for thread-local safepoints, which are a relatively recent addition to JEP 312.

Building for Failure: Best Practices for Easy Production Debugging

Fri, 21 Jul 2023 15:29:09 +0000

Before going into the content of this post, check out my new book which launched last week!

Quite a few years ago I was maintaining a database-driven system and ran into a weird production bug.

The column I was reading from had a null value, but this wasn’t allowed in the code and there was no place where that value could have been null.

The database was corrupt in a bad way and we didn’t have anything to go on.

JDK Safari: How To Find Hidden Tools in the JDK

Wed, 19 Jul 2023 08:25:23 +0000

We all have some hobby, be it sports, fishing, playing games or building compilers.

One of my hobbies is regularly searching the JDK for new Java classes with executable main methods.

Many years ago, during my forays through the JDK sources, I first encountered a class with a main-method I didn’t know about. That was in 2007 (oh boy).

The class was Class2HTML from the BCEL (Bytecode Engineering Library) library embedded in the JDK back then.

Dive into the OpenJDK: Top 10 Reads on Foojay.io

Wed, 19 Jul 2023 07:45:04 +0000

Foojay.io is a community platform dedicated to the needs of Java developers (and beyond, e.g., Kotlin) who use OpenJDK and related technologies.

It serves as a central hub for sharing knowledge, resources, and tools related to Java and OpenJDK.

The platform offers a wide range of content, including articles, tutorials, and insights from industry experts and Java enthusiasts.

Whether you’re a seasoned developer or a beginner in the world of Java, Foojay.io provides valuable information and a supportive community to help you navigate and excel in your Java development journey.

Journeys in Java, Level 10: Service Discovery with Eureka

Thu, 13 Jul 2023 06:39:06 +0000

Gaining complexity in a microservices system certainly isn’t for the faint of heart (though neither is complexity in monoliths!).

When there are many services that need to communicate with one another, we might need to coordinate multiple services communicating with multiple other services.

We also might code for varying environments such as local, development server, or the cloud.

How do services know where to find one another?
How can we avoid problems when a service is unavailable?
How do we handle requests when we scale up or down certain parts of our system?

This is where something like Spring Cloud Netflix Eureka comes into play.

Billions of Messages Per Minute Over TCP/IP

Wed, 05 Jul 2023 21:05:08 +0000

Key Takeaways

Data consistency is critical when communicating between software components on different machines to ensure information remains in tact.
Low-latency data exchange requires a different approach than common formats.
Chronicle’s open-source Wire library provides a highly efficient means of marshalling and unmarshalling data for transmission to and from Chronicle Queue.
Recent additions to the library extend its use with TCP/IP communications channels, offering extremely high throughput.
Using Wire across TCP/IP opens up the possibility of Cloud Native deployment of Chronicle-based applications.

Introduction

One of the most important issues when building distributed applications is that of data representation. We must ensure that data sent by a component to a “remote” component (i.e. one that is part of a different process) is received correctly, with the same values. This may seem straightforward but remember that the communicating components may have been written in completely different languages.

Time Machine: A Look-Back at Java Sessions from NODES 2022

Wed, 28 Jun 2023 07:53:07 +0000

Figure 1. Base Photo by Compare Fibre on Unsplash

As we prepare for NODES 2023, I wanted to pull out the time machine and review the Java sessions from NODES 2022 .

I will be submitting some abstracts to the 2023 Call for Proposal here soon, likely in the Java category, so I thought looking at last year’s sessions might give me some inspiration or ideas for gaps or continuations I might want to explore.

Building Custom Solutions vs. Buy-and-Build Software

Wed, 21 Jun 2023 14:41:33 +0000

The Challenges of Building a FIX Engine

The first day I was introduced to Financial Information eXchange (FIX) was when I worked at an investment bank in London as a developer.

I was told to write a feed handler to retrieve market data.

Bear in mind that at this time, I knew nothing about FIX, apart from Googling it for about 10 mins on the internet.

With a touch of overconfidence and slight arrogance, I set to work coding a direct socket connection to the remote FIX endpoint, “how hard could it be?”

Exploring Java 21's Intriguing Additions (Part 1)

Tue, 20 Jun 2023 13:40:21 +0000

Introduction:

Java 21 is going to introduce several intriguing additions that enhance the language’s capabilities.

This article aims to discuss a few notable features that stand out, providing an overview of their functionalities and potential use cases.

Character Enhancements:

Character.isEmoji(int codePoint): This method determines whether a character is considered an emoji based on its Unicode properties defined in Unicode Emoji (Unicode Emoji Technical Standard #51 ). For example, executing Character.isEmoji(9203) would return true for the character ⏳, which has the code point 9203.
Character.isEmojiPresentation(int codePoint): Similar to isEmoji(), this method checks if a character has the Emoji Presentation property. It helps identify characters that display as emojis when rendered.

Example:

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.

Operator Overloading in Java

Sat, 10 Jun 2023 12:19:26 +0000

In this article, we’ll delve into the fascinating world of operator overloading in Java.

Although Java doesn’t natively support operator overloading, we’ll discover how Manifold can extend Java with that functionality.

We’ll explore its benefits, limitations, and use cases, particularly in scientific and mathematical code.

We will also explore three powerful features provided by Manifold that enhance the default Java type safety while enabling impressive programming techniques.

We’ll discuss unit expressions, type-safe reflection coding, and fixing methods like equals during compilation.

Upgrade a Java 8 Project to 11 or Higher

Thu, 08 Jun 2023 15:12:27 +0000

Java 8 is a Long Term Supported (LTS) version, and Azul will maintain it until 2030 for customers with a support license. You can continue to run Java 8 applications until then on updated and secure Java runtimes. But by staying on Java 8, you miss many other improvements in runtime performance and language enhancements for your developers.

Keeping a project on Java 8 will eventually lead to running it on a non-maintained runtime.

Class Loader Hierarchies

Sat, 03 Jun 2023 08:56:55 +0000

Understanding class loader hierarchies is essential when developing Java agents, especially if these agents are instrumenting code.

In my Instrumenting Java Code to Find and Handle Unused Classes article, I instrumented all classes with an agent and used a Store class in this newly added code:

A challenge here is that all instrumented classes will use the Store. We, therefore, have to put the store onto the bootstrap classpath, making it visible to all classes.

Java is Very Fast, If You Don’t Create Many Objects

Thu, 01 Jun 2023 04:45:56 +0000

This article looks at a benchmark passing events over TCP/IP at 4 billion events per minute using the net.openhft.chronicle.wire.channel package in Chronicle Wire and why we aim to avoid object allocations.

One of the key optimisations is creating almost no garbage. Allocation is supposed to be a very cheap operation and garbage collection of very short lived objects is also very cheap.

Does not allocating really make such a difference? What difference does one small object per event (44 bytes) make to the performance in a throughput test where GC pauses are amortised?

Rolling Binary Trees: A Guide to Common Design Patterns in Java

Wed, 24 May 2023 12:55:14 +0000

Introduction

Binary trees are fundamental data structures, ubiquitous in computer science and software engineering. We use them to represent hierarchical data and implement more complex data structures, such as search trees, syntax trees, cryptographic hash trees, space partitioning trees, heaps, and so on. Common binary tree operations include insertion, deletion, traversal, and rotation.

A relatively uncommon and unexplored operation is roll , which modifies the structure of a binary tree in such a way that, when visualized, the newly obtained structure appears to be rolled at a 90-degree angle, either clockwise or counterclockwise. This gives us two variants of the roll operation — clockwise roll (CR) and counterclockwise roll (CCR).

"Transitioning to Java": My First Book!

Wed, 24 May 2023 08:01:58 +0000

When I retired from the classroom in 2021, I had no intention of sitting on a rocking chair on my front porch.

I looked for speaking opportunities, became a member of the JCP EC, and continued thinking about ways to enhance Java teaching.

I also wanted to write a book. I approached a number of publishers with my idea for a beginner’s book. I even wrote a sample chapter and publsihed it on my blog, https://www.omnijava.com/2021/10/20/java-for-beginners-my-unsuccessful-book-proposal/ .

Foojay Developer Certification: Measure Skills!

Tue, 23 May 2023 16:32:31 +0000

Learn the why and how of a group of enthusiastic people implementing a new sort of developer certification that objectively measures dev skills. We also invite you to join our initiative if you’re interested via #certification on the Foojay slack .

There’s a lot of debate about what defines a ‘good’ developer. Of course, there are different dimensions to start with. Perhaps you can say there are two main ones: soft and technical skills. Soft skills include collaboration skills, communication, organizational sensitivity, personal leadership and so on.

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.

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.

Write Once, Run Embedded in any IDE

Tue, 16 May 2023 13:34:19 +0000

Having written many Java GUI applications, I thought it would be cool to run them embedded in IntelliJ IDEA, Eclipse and NetBeans. I didn’t want to write three plugins per application so I came up with this solution.

The embedded panel criteria

To convert my Java Swing applications to run embedded in an IDE, I had to put the user interface in a panel with minimal implementation changes. I came up with these should ideally criteria:

Monitoring Event Loops for Blockages

Mon, 15 May 2023 16:42:18 +0000

Chronicle’s open source Chronicle Threads library has a little known feature which is one of the first tools I get from my bag if a client reports that they are seeing latency outliers.

The usual way that a developer will measure their system for latency hotspots is to use a profiler, and modern profilers are amazing; there are numerous commercially available, but I generally find myself using Java Flight Recorder, async-profiler, or honest-profiler. These three are engineered to avoid the safepoint bias , and thus give very accurate results.

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.

Unconventional Remote Process Control in Java

Mon, 08 May 2023 14:03:08 +0000

Have you ever wanted to control a remote process from a Java application? Essentially something like a ProcessBuilder for remote systems that allows you to run and configure a process on almost any system and also supports all regular features that you would expect from it.

Now obviously, this isn’t a revolutionary idea. You can easily take an SSH library like the newer jsch fork and use the exec or shell channel to control remote processes or remote shells by just copying and pasting some tutorial code. So what is this about then?

Interview with Paul Kocian aka Orango_Mango

Mon, 08 May 2023 07:49:40 +0000

Some time ago on Twitter, I discovered @Orango_Mango , who shared his progress in creating a 3D engine with JavaFX. The shared videos started with a Rubik’s cube in January ‘23 , over a basic tumbling car in February , to a full Minecraft-like world in April . Who is this @OrangoMango? And why did he take up the challenge to create a 3D engine with Java and JavaFX? Let’s find out…

Spring Boot Debugging with Aspect-Oriented Programming (AOP)

Fri, 05 May 2023 08:19:18 +0000

Aspect-Oriented Programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.

In simple terms, it helps you keep your code clean, modular, and easy to maintain.

We can leverage AOP to debug Spring Boot applications more effectively and seamlessly.

In this post, we will explore how to use AOP to debug a Spring Boot application effectively.

AOP Concepts

Before diving into debugging with AOP, it is essential to understand the core concepts. AOP lets us write code that executes before or after a method. It includes the following common terms:

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:

Hidden and Not-So-Hidden Gems In Java 20

Wed, 03 May 2023 14:32:45 +0000

Let’s see the preview and incubator JEPs in Java 20, as well as many smaller enhancements, bug fixes, and deprecations.

March 2023 marked the latest feature release of the Java platform, which was delivered on time through the six-month release cadence as Java 20. Like Java 19, which became generally available in September 2022, Java 20 targeted JEPs—seven, in this case—from the Panama , Amber , and Loom projects.

I am using the Java 20 jshell tool to demonstrate the code in this article. To follow along, download JDK 20 , fire up your terminal, check your version, and run jshell. Note that you might see a newer version of the JDK; that’s okay.

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.

Creating Scalable OpenAI GPT Applications in Java

Thu, 27 Apr 2023 14:18:45 +0000

One of the more notable aspects of ChatGPT is its engine, which not only powers the web-based chatbot but can also be integrated into your Java applications.

Whether you prefer reading or watching, let’s review how to start using the OpenAI GPT engine in your Java projects in a scalable way, by sending prompts to the engine only when necessary:

Imagine you want to visit a city and have a specific budget in mind. How should you spend the money and make your trip memorable? This is an excellent question to delegate to the OpenAI engine.

Approaches to Durability in Low Latency Messaging Queues

Wed, 26 Apr 2023 13:17:59 +0000

A significant feature of Chronicle Queue Enterprise is support for TCP replication across multiple servers to ensure high availability of application infrastructure.

I have generally held the view that replicating data to a secondary system is faster than sync-ing to disk, assuming the round trip network delay wasn’t high due to quality networks and co-located redundant servers.

This is the first time I have benchmarked it with a realistic example.

Relearning Java Thread Primitives

Tue, 25 Apr 2023 05:26:16 +0000

I’ve coded in Java since the first beta, even back then threads were at the top of my list of favorite features.

Java was the first language to introduce thread support in the language itself, it was a controversial decision back then.

In the past decade, every language raced to include async/await and even Java had some third-party support for that …

But Java zigged instead of zagging and introduced the far superior virtual threads (project Loom) . This article isn’t about that.

A Java Library’s New Approach To Observability

Tue, 18 Apr 2023 08:10:01 +0000

How a Java library is taking a completely new approach to understanding what the code does, and why it makes perfect developer sense.

A while back, I wrote about the fact that logs need an overhaul, and that practices that were relevant when logs were still text messages in files may no longer be relevant in an age when logs traces and metrics are as artifacts and observations stored in cloud platforms.

Time Zone and Currency Database in JDK

Sat, 08 Apr 2023 13:39:00 +0000

There is a saying that you aren’t a real developer until you have done programming involving dates, times, daylight savings, and time zones.

Luckily the JDK contains multiple methods to assist you.

Related to this topic, it is essential to understand that each new JDK release includes a new version of the time zone and currency database.

As we will discover, you can get correct output by just switching to the most up-to-date version of Java – without changing code!

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.

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.

Event-Driven Order Processing Program

Thu, 23 Mar 2023 09:27:37 +0000

Following the Hello World example of a simple, independently deployable real-time Event-Driven Microservice, this article looks at a more realistic example of an Order Processor with a New Order Single in and an Execution Report out.

A New Order Single is a standard message type for the order of one asset in the FIX protocol used widely by financial institutions such as banks.

The reply is typically one or more Execution Reports updating the status of that order.

It's Java 20 Release Day! Here's What's New | foojay.io Today

Tue, 21 Mar 2023 06:40:34 +0000

This will be a good day, because it’s Java 20 release day!

It’s been six months since Java 19 was released, and so it’s time for another fresh wave of Java features.

In this article, we will take you on a tour through all JEPs that come with this release and give you a brief introduction of each one of them.

Where applicable the differences with Java 19 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to use these features after you’ve finished reading!

Foojay Podcast #16: Welcome to Java 20!

Mon, 20 Mar 2023 08:00:14 +0000

Since 2018, we get a new version of Java every 6 months.

Some are long-term supported versions that can be used for many years, while others are only maintained for a short time. Version 20 is such a short-term supported version.

So, what new features does this version bring? And why should we use it? And what can we expect from the next version, 21, in September that will be a long-term supported version?

Book Review: "API Design Patterns"

Sun, 19 Mar 2023 15:20:56 +0000

Disclaimer: this post includes affiliate links; I may receive compensation if you purchase the book from the different links provided in this post.

This review is about API Design Patterns by JJ Geewax from Manning.

I already mentioned how I’m trying to get to speed in the API world: reading books, viewing relevant YouTube videos and reading relevant s.

Facts

30 chapters, $35.00
The author is a Principal Software Engineer at Google
He’s also the author behind

Chapters

Introduction
Design principles 3. Naming 4. Resource scope and hierarchy 5. Data types and defaults
Fundamentals 6. Resource identification: How to identify resources in an API 7. Standard methods: The set of standard methods for use in resource-oriented APIs 8. Partial updates and retrievals: How to interact with portions of resources 9. Custom methods: Using custom (non-standard) methods in resource-oriented APIs 10. Long-running operations: How to handle methods that are not instantaneous 11. Rerunnable jobs: Running repeated custom functionality in an API
Resource relationships 12. Singleton sub-resources: Isolating portions of resource data 13. Cross references: How to reference other resources in an API 14. Association resources: How to manage many-to-many relationships with metadata 15. Add and remove custom methods: How to manage many-to-many relationships without metadata 16. Polymorphism: Designing resources with dynamically-typed attributes
Collective operations 17. Copy and move: Duplicating and relocating resources in an API 18. Batch operations: Extending methods to apply to groups of resources atomically 19. Criteria-based deletion: Deleting multiple resources based on a set of filter criteria 20. Anonymous writes: Ingesting unaddressable data into an API 21. Pagination: Consuming large amounts of data in bite-sized chunks 22. Filtering: Limiting result sets according to a user-specified filter 23. Importing and exporting: Moving data into or out of an API by interacting directly with a storage system
Safety and security 24. Versioning and compatibility: Defining compatibility and strategies for versioning APIs 25. Soft deletion: Moving resources to the “API recycle bin” 26. Request deduplication: Preventing duplicate work due to network interruptions in APIs 27. Request validation: Allowing API methods to be called in “safe mode” 28. Resource revisions: Tracking resource change history 29. Request retrial: Algorithms for safely retrying API requests 30. Request authentication: Verifying that requests are authentic and untampered with

Each design pattern chapter follows the same structure:

Book review - Practical Design Patterns for Java Developers

Fri, 17 Mar 2023 08:27:08 +0000

Hone your software design skills by implementing popular design patterns in Java

This book is for sale on Amazon in Kindle and Paperback editions .

We’ll start this post with the personal verdict of two avid readers of this book:

Frank Delporte’s Verdict

I’ve been programming since I was 10y old, but I graduated from film school as a video editor, so I never learned the “official” way to be a programmer. It was only by following courses and, most importantly, learning from colleagues that I started making “readable and maintainable” code, which is precisely the topic of this book.

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().

How Gradle Works: Inside the Daemon

Tue, 14 Mar 2023 11:27:52 +0000

Previously in the How Gradle Worksseries:

How Gradle Works: Startup

This is the second article of the series How Gradle Works.

In this article, we’ll explain what happens inside the Gradle Daemon JVM.

Why Do We Need Gradle Daemon?

In the last article , we mentioned that Gradle starts a Gradle Daemon JVM (“the daemon”) to run the build.

The userguide explains why we need the daemon.

The Daemon is a long-lived background process that reduces the time it takes to run a build. The Daemon reduces build times by caching project information across builds, running in the background so every Gradle build doesn’t have to wait for JVM startup, benefiting from continuous runtime optimization in the JVM, and watching the file system to calculate exactly what needs to be rebuilt before you run a build.

9 Outdated Ideas About Java

Sat, 11 Mar 2023 08:56:17 +0000

Since the first release of Java in 1995, a lot has changed in both software and hardware, and each evolution impacts the next.

Powerful processors and cheaper memory allow software to do more and do it faster.

As Azul Deputy CTO Simon Ritter says, “Java shows no danger of becoming the new COBOL. By adding new features to the platform under the six-month release cadence, we are seeing Java evolve faster than ever before.”

How to Best Use Java Records as DTOs in Spring Boot 3

Thu, 09 Mar 2023 17:06:46 +0000

With the Spring 6 and Spring Boot 3 releases, Java 17+ became the baseline framework version.

So now is a great time to start using compact Java Records as Data Transfer Objects (DTOs ) for various database and API calls.

Whether you prefer reading or watching, let’s review a few approaches for using Java records as DTOs that apply to Spring Boot 3 with Hibernate 6 as the persistence provider.

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.

42 Practical Java Design Patterns: Builder and More

Mon, 27 Feb 2023 08:27:06 +0000

Figure 1.: Hone your software design skills

The aim of the article is to introduce my newly published book “Practical Design Pattern for Java Developers”.

Together, we’ll explore today’s application development challenges and dive deeper into some of Java’s new language enhancements by exploring the Builder Design pattern in more detail.

The days when applications were developed “ad hoc” seem to have ended only on paper.

Journeys in Java, Level 9: Docker compose all the things

Sun, 26 Feb 2023 10:02:15 +0000

Our microservices project contains quite a few pieces now.

We have two databases, three API services, a user-view service for books, and a service to host our configuration.

With so many pieces to manage, it would be nice to have something that orchestrates the individual services into a system, such as Docker Compose.

Back in our Level 5 rendition, we did exactly this for our smaller version of the project.

Now that we have expanded our services, we need to add those new pieces into the existing Docker Compose management umbrella.

Update or Upgrade Java... and Which Version Should You Use?

Thu, 23 Feb 2023 09:12:39 +0000

Update versus Upgrade: what’s the difference and what are the consequences of your decision?

Since 2018, every six months we get an upgrade to a new OpenJDK version, and this year versions 20 and 21 will be released.

Next to these six-month releases, OpenJDK distributor Azul, amongst others, provides four critical patch updates (CPU) and patch set updates (PSU) per year.

So what’s the difference between a Java upgrade and an update?

Is There a Best OS to Develop a Java Application on?

Wed, 22 Feb 2023 11:43:40 +0000

One subject that often evokes a lot of debate is which is the best OS to develop a Java application on. This article gives my view on the issue.

Java runs very well on Windows, macOS and Linux Distributions.

I work for Chronicle Software , and much of our software is open-source Java libraries, so we don’t, or rather we can’t, require our customers to run on a particular operating system. You may be surprised to hear that we don’t mandate which operating system our staff should use either. We let them use the one that causes the least friction, the one that they are most productive with.

An Introduction to Scoped Values in Java

Mon, 20 Feb 2023 11:32:20 +0000

After moving to the six-month release cadence, the Java language has entered a rapid development process.

While the process introduces many new features, these new features sometimes cause updates to existing APIs and sometimes result in the development of new APIs.

An example of the second is Scoped Values which has been included in the JDK since Java 20 as an incubator API.

Why were Scoped Values proposed?

Virtual threads became a part of JDK as a preview feature in Java 19.

Java Sealed Classes: Building Robust and Secure Applications

Mon, 20 Feb 2023 11:11:07 +0000

Java sealed classes were introduced in Java 15 as a way to restrict the inheritance hierarchy of a class or interface.

A sealed class or interface restricts the set of classes that can implement or extend it, which can help prevent bugs and make code more maintainable.

Suppose you’re building an e-commerce application that supports different payment methods, such as credit cards, PayPal, and Bitcoin. You could define a sealed class called PaymentMethod that permits various subclasses for each payment method:

Foojay Podcast #14: Debugging Tools and Skills for Fun and Profit

Mon, 20 Feb 2023 08:29:01 +0000

Let’s talk about debugging and observability.

We work with debugging all the time, but how well do we know this common practice?

Observability, monitoring, and debugging at scale for your production…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

A lot of rubber ducks
Johannes Bechberger
- JVM and profiler developer
- Worked on the JDWP protocol and profiling
- https://github.com/parttimenerd
- https://twitter.com/parttimen3rd
- https://mastodon.social/@parttimenerd
- AsyncGetStackTrace: A better Stack Trace API for the JVM
- A short primer on Java debugging internals
Marit van Dijk
- Developer Advocate at JetBrains
- https://maritvandijk.com/
- https://twitter.com/MaritvanDijk77
- https://mastodon.social/@maritvandijk
Ties van de Ven
- Software Engineer @ JDriven, Coach @ Jcore
- https://www.tiesvandeven.nl/
- https://twitter.com/ties_ven
- 6 Steps to help you debug your application

Host

Shai Almog
- Author of “Practical Debugging at Scale ”
- https://debugagent.com/
- https://mastodon.social/@debugagent
- https://twitter.com/debugagent

Producer

Frank Delporte
- https://foojay.social/@frankdelporte
- https://twitter.com/frankdelporte

Content

00'00 Intro and music
00'24 About the topic of this podcast
00'58 Introduction of the guests and host
05'14 Debugging with IntelliJ IDEA and discoverability of tools
- YouTube: Debugger playlist
- YouTube: Profiling tools
- YouTube: Profiling live stream
13'27 JDWP protocol
19'43 Exception breakpoints
- Foojay: Exception Breakpoint that Doesn’t Suck and a Real Use Case for Method Breakpoints
20'34 External debugging tools
- https://rubberduckdebugging.com/
26'55 Observability
37'58 What information should you look for while debugging
45'46 Be aware of tunnel vision while debugging
49'33 What to do if you don’t know where to search for the bug
- https://git-scm.com/docs/git-bisect
- Foojay: External Debugging Tools 2: git bisect
57'05 Outro

Schedule your 2038 holiday and experiment with dates in jshell!

Thu, 16 Feb 2023 15:54:51 +0000

It’s still more or less the beginning of the year, where you may want to start scheduling your holidays until the end of it. And I decided to go a step further and I’ve already planned those for 2038!

Why? Well, some time ago I gave a presentation to students, when I realized they had no idea what I was talking about when mentioning the Y2K-problem. Most of them weren’t even born in the year 2000!

Behaviour Driven Development with Event Driven Architectures

Wed, 15 Feb 2023 07:57:18 +0000

Behaviour Driven Development (BDD) and Event Driven Architecture (EDA) work well together as they complement each other’s strengths and weaknesses.

Using both can result in a shorter time to market for new functionality and a more maintainable system.

Behaviour Driven Development (BDD) encourages a common language between users and developers in describing requirements in a form the users can understand but can also automatically be checked as the application is developed and maintained.

Null Safety: Kotlin vs. Java

Mon, 13 Feb 2023 12:12:35 +0000

Last week, I was at the FOSDEM conference. FOSDEM is specific in that it has multiple rooms, each dedicated to a different theme and organized by a team. I had two talks:

Practical Introduction to OpenTelemetry Tracing , in the Monitoring and Observability devroom
What I miss in Java, the perspective of a Kotlin developer , in the Friends of OpenJDK devroom

The second talk is from an earlier post . Martin Bonnin did a tweet from a single slide, and it created quite a stir, even attracting Brian Goetz.

Journeys in Java, Level 8: Add MongoDB to Spring Cloud Config

Thu, 09 Feb 2023 16:56:28 +0000

In our last article , we used Spring Cloud Config to provide database credentials to a microservice application connecting to a cloud-hosted Neo4j database. This post will backport this concept to our existing MongoDB database instance and its related microservices.

We will add our MongoDB credentials to the config server, so that it will be the central place for both our Neo4j and MongoDB database access. However, each service only has access to the credentials that it needs to operate, which provides some level of security through “separation of concerns” (versus universal access).

How Gradle Works: Startup

Thu, 09 Feb 2023 08:45:57 +0000

This is the first article of a series How Gradle Works, which includes the following topics:

How Gradle starts up
How many JVMs are involved in a Gradle build
What happens in each JVM during the build

We’ll explain the first topic How Gradle Starts Up in this blog.

Before reading on, we assume you are familiar with basic JVM/Gradle concepts (jar, classpath, wrapper, daemon, project, task, etc.).

How Gradle Starts Up

There are many ways to start a Gradle build:

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).

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.

Optional in Java: A Swiss Army Knife for Handling Nulls and Improving Code Quality

Wed, 01 Feb 2023 05:29:38 +0000

In Java, dealing with null values can be a real headache. Nulls can cause all sorts of problems in your code, from NullPointerExceptions to convoluted if statements and error-prone logic. Fortunately, Java 8 introduced the Optional class, which offers a simple and powerful way to handle nulls and improve code quality. Optional is a container object that may or may not contain a non-null value and provides a range of practical methods for working with its contents. In this article, we’ll explore the many use cases of Optional in Java and show you how to use this powerful class to write cleaner, more expressive, and more resilient code.

Journeys in Java, Level 7: Externalize Microservice Configuration

Mon, 30 Jan 2023 15:43:16 +0000

Our decided next step for this project takes us in a new direction by adding externalized configuration for our applications.

We already saw how to do something similar with MongoDB database credentials in Docker Compose to access a local database container, but what do we do when the database is hosted on public cloud or contains sensitive data?

We probably don’t want to publish our credentials anywhere or even prevent accidental publishing.

Java Bytecode: Journey to the Wonderland (Part 3)

Tue, 24 Jan 2023 15:27:51 +0000

Our previous article unpacked Bytecode further and discussed ConstantPool, today I’ll go through several resources for working with it now.

Java bytecode is the Java Virtual Machine’s (JVM) intermediate representation of Java code. While Java bytecode is not meant to be human-readable, it may be edited and manipulated for several reasons. This article examines the tools and methods used to change and work with Java bytecode.

Changing Java bytecode is often done to add new features to a Java program that already exists. This can be done with a bytecode injector, a tool that lets you add bytecode to a Java class file that has already been compiled. Bytecode injectors are often used for logging or debugging information and for allowing runtime updates like A/B testing or feature flags.

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?

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.

Why Picnic picked Java

Fri, 30 Dec 2022 08:22:54 +0000

Picking a tech stack for your startup isn’t something to do lightly. It’s a choice that will shape the future in many ways: how will the tech enable your emerging product and business, what talent can you attract, and how future-proof is the tech stack?

When Picnic launched as the first app-only supermarket back in 2015 in The Netherlands, the tech landscape looked markedly different from today.

Java and .Net ruled the Dutch developer landscape for backend systems.

Challenges when Developing a GUI for FIX

Wed, 21 Dec 2022 08:06:18 +0000

In this article, we explore the challenges in developing a Graphical User Interface (GUI) for Financial Information Exchange (FIX) data.

FIX is both a protocol and a message format, but to create a FIX GUI we will focus just on the message format.

A FIX message is a standard message format for transmitting financial and investment banking data.

Below is an example of a FIX message, where the “|” character is sent as ‘\1’:

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.

What Java Version Are You Running?

Thu, 15 Dec 2022 08:59:05 +0000

From time to time, you need to check which Java version is installed on your computer or server, for instance when starting on a new project or configuring an application to run on a server.

But did you know there are multiple ways you can do this and even get much more information than you might think, very quickly?

Let’s find out…

Reading the Java Version in the Terminal {#WhatJavaversionareyourunning?TakingalookunderthehoodsoftheJDK.-ReadingtheJavaVersionintheTerminal}

Probably the easiest way to find the installed version is by using the java -version terminal command:

Why the Cool Kids Use Event Loops

Wed, 14 Dec 2022 10:17:48 +0000

A Discussion On the Benefits of Event Loops in Java.

When I was working in software development back in the 1990s, nearly all the software libraries that I worked on made use of event loops. This was because at the time most hardware had just one single CPU.

Back in the day, I remember the excitement when threads were introduced into our development framework. It was revolutionary that we could now run two things at once, or rather appear to run two things at once, since a lot of the hardware at that time still only had a single core, hence our threaded code was never really truly concurrent.

Compilation Avoidance with Gradle

Tue, 13 Dec 2022 15:35:31 +0000

We at Gradle recently noticed some community chatter about speeding up Gradle compilation on the JVM by ignoring changes not affecting the application binary interface (ABIs) of dependencies.

What a great idea! In fact, Gradle has used ABIs for Java out of the box for this without any extra configuration since version 3.4 .

We refer to this feature as compilation avoidance .

This post explains what ABI-based compilation means for the average workflow. Spoiler: utilizing compilation avoidance is one of the best performance enhancements for any build.

Why Did We Choose JSF for the Eclipse Starter for Jakarta EE?

Tue, 13 Dec 2022 10:27:44 +0000

After being taken care of by the Java Community Process (JCP), Java EE is now supported by the Eclipse Foundation as Jakarta EE .

This means that we can focus more on open standards for governance, open-source development, and testing for compatibility.

It is also a great way to include openness to all vendors, a clear flow of intellectual property (IP), well-defined procedures for defining specifications, and a level playing field.

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.

Introducing Gradle Test Suites

Tue, 06 Dec 2022 13:28:26 +0000

This article was initially published at blog.gradle.org

As projects grow in size and complexity and otherwise mature, they tend to accumulate a large collection of automated tests.

Testing your software at multiple levels of granularity is important to surface problems quickly and to increase developer productivity.

In Gradle 7.3 , released November 2021, the Gradle team introduced a new feature called Declarative Test Suites.

Using this feature makes it much easier to manage different types of tests within a single Gradle JVM project without worrying about low level “plumbing” details.

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.

Unusual Java: StackTrace Extends Throwable

Wed, 23 Nov 2022 12:37:13 +0000

There are things you can do in Java you rarely see, generally because there is no use for it.

However, there are some unusual things in Java that could be surprisingly useful.

Chronicle Software uses a number of different useful patterns in its low-level libraries most developers wouldn’t generally come across.

One of them is a class that extends Throwable but isn’t an Error or an Exception.

StackTrace Extends Throwable

package net.openhft.chronicle.core;
/**
* Throwable created purely for the purposes of reporting a stack trace.
* This is not an Error or an Exception and is not expected to be thrown or caught.
*/
public class StackTrace extends Throwable {
 public StackTrace() { this("stack trace"); }
 public StackTrace(String message) { this(message, null); }
 public StackTrace(String message, Throwable cause) {
 super(message + " on " + Thread.currentThread().getName(), cause);
 }

 public static StackTrace forThread(Thread t) {
 if (t == null) return null;
 StackTrace st = new StackTrace(t.toString());
 StackTraceElement[] stackTrace = t.getStackTrace();
 int start = 0;
 if (stackTrace.length > 2) {
 if (stackTrace[0].isNativeMethod()) {
 start++;
 }
 }
 if (start > 0) {
 StackTraceElement[] ste2 = new StackTraceElement[stackTrace.length - start];
 System.arraycopy(stackTrace, start, ste2, 0, ste2.length);
 stackTrace = ste2;
 }

 st.setStackTrace(stackTrace);
 return st;
 }
}

Some important side notes to get out of the way first

Foojay Podcast #7: Security in Java -- what do we need to know?

Mon, 21 Nov 2022 10:22:14 +0000

For this Foojay Podcast**,** we invited security experts to dive into the fascinating world of secure coding and detecting vulnerabilities in your Java applications.

How can you make and keep your systems safe?

That’s what we want to find out…

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

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.

Reducing Tail Latencies with Chronicle Queue Enterprise

Wed, 09 Nov 2022 15:07:36 +0000

Persistent queue solutions are frequently used when designing low-latency applications.

The problem is that high sustained message rates, or bursty workloads, can lead to delays caused by the OS or hardware which are challenging to mitigate.

In this article, we will describe how Chronicle Queue Enterprise solves this.

Background

When benchmarking Java low-latency persistent queue solutions, latencies tend to be excellent up to high percentiles until sustained throughput limits are reached; these sustained throughput limits are determined by disk performance, OS version, and configuration.

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.

The Problem with Functional Programming

Thu, 27 Oct 2022 10:17:32 +0000

Let me start off with saying that I love functional programming.

Although… a better way of saying it would be that I love what functional programming brings me.

It reduces complexity, the code is nice and explicit, and it eliminates certain bugs from occurring.

But there are a few things that I wanted to discuss regarding functional programming.

Object Orientation vs. Functional Programming

Let me start off with the Object Oriented vs. Functional Programming discussion.

A Minor But Useful Refactoring Technique That Would Reduce Your Code Footprint (Part 2)

Wed, 26 Oct 2022 15:16:18 +0000

As I keep refactoring, this article will focus on a few more interesting ways to do it. These are pretty much minor yet effective and useful changes.

Stream.noneMatch() and Stream.anyMatch()

In some situations, we need to find a single case among many. For example, we want to do a certain operation if we have a list of items and a certain item is in that list. Usually, we run a for loop and then use a loop inside the for loop to check the value against our case. Check out the following piece of code:

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.

How to Use Java DTOs to Stay Secure

Fri, 21 Oct 2022 07:29:57 +0000

~~This article was orignally posted on Snyk.io and is reused with permission.~~

Data Transfer Objects (DTOs) in Java are objects that transport data between subsystems.

It is an enterprise design pattern to aggregate data.

The main purpose is to reduce the number of system calls needed between the subsystems, reducing the amount of overhead created.

In this article, I will explain how DTOs are used in modern Java applications, ways your application can benefit, and how Java DTOs can help you be more secure by preventing accidental data leaks.

Minor Techniques That Would Reduce Your Code Footprint (Part 1)

Thu, 20 Oct 2022 14:32:52 +0000

Finally, we upgraded to Java 11 from Java 8.

That was a long-awaited move, but I’m pleased that we eventually made it.

The next thing that came to mind when I stated this was, “Why not Java 17 directly?”

Eventually, we will move to 17, but we had to begin someplace.

And the transition to 11 was not easy either.

We had several dependencies with Mockito, which made the journey somewhat tricky, but we were able to manage it.

Low Latency Crypto Trading Systems with Java and Chronicle

Tue, 18 Oct 2022 14:59:37 +0000

Cryptocurrency trading is an emerging market with its own rules.

However, when it comes to the need for low-latency arbitrage , that is, being able to react rapidly to changing market prices and placing orders ahead of the competition, there are lessons we can learn from optimizing classic trading systems.

Chronicle Software has a successful track record of designing low-latency trading products. This background enables it to provide optimum performance solutions for Crypto trading systems.

MicroProfile Config for Java SE

Thu, 13 Oct 2022 16:10:31 +0000

The MicroProfile Config specification is one of those attempts to create a specification around application configuration for the Java Enterprise world. In the past, there were already some other attempts within Java EE to define this specification for Java EE, but they were never finalised.

Currently, another attempt is in progress with Jakarta EE Config but since MicroProfile is closely related to Jakarta EE, it is the best available solution today. That is the reason why almost all Jakarta EE runtimes also support MicroProfile Config and the other specifications of the MicroProfile umbrella.

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.

The Reason Java is Still Popular

Mon, 10 Oct 2022 16:11:32 +0000

A great time to post this, right after the release of Java 19, yes, another “my language is better” post. No, I didn’t want to write it. But sometimes people’s bad projection gets the better of me.

In this case the post started as a comment and I ended up deciding turn it into a post. This was strengthened with this post which mostly complains about Quarkus (somewhat unfairly if I might add).

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.

Low Latency Microservices, A Retrospective

Thu, 06 Oct 2022 06:25:56 +0000

I wrote an article on low latency microservices almost five years ago now. Chronicle Software has worked with a number of tier one investment banks to implement and support those systems. What has changed in that time and what lessons have we learnt?

Read this article and learn what we learned after five years of developing and supporting low latency microservices.

Separation of Concerns Gives Better Testability

Microservices repeatedly demonstrated that testing and debugging business components were much easier with simple, stand-alone components with clear contracts between microservices.

What Does The JVM Look Like, How Does It Work?

Thu, 29 Sep 2022 05:29:00 +0000

Knowing how to code is fantastic, but it is even more enjoyable if we understand how a specific programming ecosystem works.

I recall the C course I took during my first semester at university. I wanted to learn how C compilers take a program, verify it, and then compile it. As a side project, I wrote a small program that checks another C program to see if there are any syntax errors. I named it Cyntax. It didn’t accomplish much, but I felt euphoria while doing it.

Storing 1TB in Virtual Memory on a 128GB Machine

Tue, 27 Sep 2022 09:10:43 +0000

If you use a standard JVM like the Oracle JVM or the OpenJDK, you might find that as the heap size grows the performance of your JVM can drop as GC pause time escalates.

This tends to be a problem around 32 GB of heap, but it often depends on the application at which point the size of your heap becomes a problem.

One way around this is to use an always concurrent collector such as Azul Platform Prime which is designed to both scale to much larger heap sizes and even reduces the GC pause times for smaller heap consistently.

The 5 Most Pivotal and Innovative Additions to OpenJDK 19

Tue, 20 Sep 2022 16:25:12 +0000

Although OpenJDK 19 is not an LTS, it is still a significant release, in my opinion.

It includes several game-changing features that will alter the Java landscape.

Many features intrigue my interest, but there are five in particular that I can’t wait to try out. Let’s break those down and talk about them separately.

JEP 425: Virtual Threads (Preview)

Under the umbrella of Project Loom, JEP 425 introduces virtual threads, which aim to dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications on the Java platform. This is a preview feature . Consider the following example:

OpenJDK 19 Released!

Tue, 20 Sep 2022 16:00:40 +0000

OpenJDK 19 has been released today! Get it from your favorite vendor… whether it is BellSoft, Amazon, Red Hat, Azul, Oracle, Microsoft or any other of a large number of Java providers .

The friends of OpenJDK community has put together a number of resources, and more coming in the coming weeks, about the new features and all the enhancements and fixes that have gone into the release, accompanied by a brand new podcast released today, featuring key Java community leaders from around the world.

Foojay Podcast #5: OpenJDK Discussion Panel

Tue, 20 Sep 2022 15:56:27 +0000

It’s September 20th, OpenJDK 19 has been released. In this podcast, we discuss the new features and the changes that this release brings.

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Spotify
Apple Podcasts
And most others…

Guests

Miroslav Wengner (OpenValue)
Mary Grygleski (CJUG, DataStax)
Deepu K Sasidharan (Okta, JHipster)

Podcast host

Erik Costlow (Azul)

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.

Use Pattern Matching to Simplify Java

Wed, 07 Sep 2022 10:55:58 +0000

The concept of pattern matching has been around since the 1960s. It’s a well-known language technique used in many programming languages, from Haskell and AWK to Rust and Scala.{#h-the-concept-of-pattern-matching-has-been-around-since-the-1960s-it-s-a-well-known-language-technique-used-in-many-programming-languages-from-haskell-and-awk-to-rust-and-scala}

Pattern matching is relatively new to Java. It was introduced in JDK 14 and has been progressing with new uses since then.

This article explores how these new features can make your code more concise without losing readability.

If you’re more of an interactive learner, watch my on-demand webinar on pattern matching in Java from June 2022. First, let’s back up and explain what pattern matching is.

Java Thread Programming (Part 15)

Wed, 31 Aug 2022 17:30:53 +0000

This article will discuss how we do asynchronous method invocation with Callable and Future with a practical example.

Look at the code snippet. It doesn’t have anything yet, but as we learned about Java threading , we know anything we put here will run on the main thread unless we spawn a new thread from here.

Now consider a case where you work as a banker, and you need to calculate how much credit you can provide to a person.

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.

Java Strings and confusion with Unicode

Tue, 23 Aug 2022 10:29:58 +0000

In this article, I would like to show you a couple of confusing things in connection with Java Strings.

I would also like to give you a few suggestions to avoid issues with them.

I also prepared a GitHub repo for you where you can find some code that you can use to try the examples out on your own: github.com/jonatan-ivanov/java-strings-demo .

Quiz

In order to demonstrate this, let me invite you for a little quiz:

Java Bytecode Simplified: Journey to the Wonderland (Part 2)

Tue, 16 Aug 2022 15:15:22 +0000

Our previous article introduced Bytecode and discussed what it includes.

This article will delve a bit deeper into ConstantPool.

Highlights:

Bytecode is a representation that is abstract in nature. They are fictitious codes for a fictitious machine known as the Java Virtual Machine. The Java virtual machine is a piece of software that interprets Bytecode.
The JVM is a stack-based computer. Real CPUs are register-based systems and execute machine code. Java is compiled into Bytecode, an intermediate form, which is then executed by the Just In Time (JIT) compiler, which generates machine code.

Before going any further, let’s explore javap, which is a very handy tool for deconstructing byte code.

Deserialization exploits in Java: why should I Care?

Thu, 14 Jul 2022 07:39:03 +0000

Hackers refer to deserialization in Java as “the gift that keeps on giving”. But what is actually the problem? In most cases, it is not even your own code that creates this security vulnerability. This problem is also not restricted to Java’s custom serialization framework. When deserializing JSON, XML, or YAML, similar issues can occur as well.

I recently gave a talk about this during Devoxx UK , the largest and most prestigious Java community conference in the United Kingdom. In this talk, I explain how deserialization vulnerabilities work natively in Java and how attack chains are created. This was loosely based on my blog post: “Serialization and deserialization in Java: explaining the Java deserialize vulnerability” .

JDK 7: An Extended Hello and Farewell

Tue, 12 Jul 2022 11:03:39 +0000

On July 7^th^, 2011, eleven years ago, JDK 7 was released . In some ways, it was one of the more significant releases of Java. Indeed, there were some excellent technical features: Project Coin gave us things like try-with-resources, strings in switch and multi-catch.

However, it was two non-technical aspects of JDK 7 that made it important.

The first was that it was the first release since Oracle acquired Sun Microsystems . The Java community had been unsure how Java would fare under Oracle, so this release showed a solid commitment to the platform (which has been maintained since then).
The second was even more important: the fact that a Java SE specification was published through the Java Community Process . Due to issues around the availability of the TCK and the Apache Harmony project , new versions of OpenJDK had been stalled since December 2006. To put this into context, the time between JDK 6 and JDK 7 (one release) was one month longer at four years and seven months than between JDK 9 and JDK 18 (nine releases). Getting things moving again was vital to keeping Java relevant to developers as applications and architectures evolved.

Another significant date for JDK 7 is July 19^th^ this year. That is when the last update will be made available from Oracle , even for commercially supported users. It is the end of what Oracle terms Extended Support.

What I Miss in Java, the Perspective of a Kotlin Developer

Wed, 15 Jun 2022 08:15:34 +0000

Java has been my bread and butter for almost two decades.

Several years ago, I started to learn Kotlin; I never regretted it.

Though Kotlin compiles to JVM bytecode, I sometimes have to write Java again.

Every time I do, I cannot stop pondering why my code doesn’t look as nice as in Kotlin.

I miss some features that would improve my code’s readability, expressiveness, and maintainability.

This article is not meant to bash Java but to list some features I’d like to find in Java.

Wordish with JavaFX - Part 5

Tue, 14 Jun 2022 07:25:37 +0000

Welcome to Part 5 and the final installment of this series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.
In Part 2 , we discussed look and feel enhancements. We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling. In addition, we covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.
Next, in Part 3 , we explored the controller code that maintains game state and responds to user input with appropriate updates to the UI.
Part 4 , What’s in a Word, Anyway?, examines how we get our words and how we determine if a submitted word is valid.

And now in Part 5, we turn to JavaFX charts, showing how to customize charts with orientation and colors and how to add nodes to the chart scene graph.

Wordish with JavaFX - Part 4 : Foojay

Tue, 07 Jun 2022 09:23:47 +0000

Welcome to Part 4 of this five part series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In Part 2 , we discussed look and feel enhancements.

We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling.

We covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Next, in Part 3 , we explored the controller code that maintains game state and responds to user input with appropriate updates to the UI.

What Can We Expect In OpenJDK 19?

Wed, 01 Jun 2022 19:00:37 +0000

Although the Java 19 release is coming in September (2022-09-20), we already know what will happen in that release!

In this article, we’ll touch on upcoming features via examples to get a sense of how valuable these can be to a project.

JEP-405: Record Patterns (Preview)

Java 14 introduced (JEP-361, Reference 2), which made it possible to use a switch as a statement or an expression. In many cases, I think it was something the community shouted for quite some time, because many other JVM languages have already provided such constructs.

Wordish with JavaFX - Part 3

Tue, 31 May 2022 07:23:02 +0000

Welcome to Part 3 of this five part series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In Part 2 , we discussed look and feel enhancements.

We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling.

We covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Now in Part 3, we’ll examine the controller code. The controller code maintains game state and responds to user input with appropriate updates to the UI.

Wordish with JavaFX - Part 2

Tue, 24 May 2022 07:50:54 +0000

Building Games and Having Fun with Java and JavaFX

Welcome to Part 2 of this five part series!

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In this second part, we’ll discuss some important look and feel enhancements.

We’ll show you specialized Label and Button controls and using pseudo-classes for advanced CSS styling.

We’ll also cover incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Wordish with JavaFX - Part 1

Tue, 17 May 2022 10:13:21 +0000

Building Games and Having Fun with Java and JavaFX

Wordish is a JavaFX implementation of the game Wordle. It’s like Wordle. It is Wordle-ish. It’s Wordish. Figure 1. Wordish main layout view

Wordle is a daily online word game. You can play the official Wordle game here:https://www.nytimes.com/games/wordle/index.html . If you haven’t played yet, go check it out.

As I played Wordle, I realized how much fun it would be to create a JavaFX implementation. When you submit a word, each tile rotates to reveal how the individual letter matches – or doesn’t match – the target word. (Ooh, animation!)

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).

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.

Top 10 Java Language Features

Tue, 12 Apr 2022 17:06:07 +0000

Every programming language provides ways to express our ideas and then translates them into reality.

Some are unique to that particular language and some are common to many other programming languages.

In this article, I will explore ten Java programming features used frequently by developers in their day-to-day programming jobs.

Collection’s factory method

Collections are the most frequently used feature in our daily coding. They are used as a container where we store objects and pass them along.

How to Create APIs with the Java 18 jwebserver Ready for Docker

Mon, 11 Apr 2022 14:26:57 +0000

In the age of cloud computing, it is at times very helpful to have the ability to run a very simple web server. A simple web server that delivers static content.

Maybe some of us are already familiar with the neat python util “SimpleHTTPServer” (Example 1.). It allows you to run a web server from the current location and obtain access to static content.

Although such a server is very simple and even without the ability to define a directory, it is very helpful in many cases. For example, exposing a simple end-point that serves a JSON response:

Quest to the OS: Java Native Memory

Fri, 08 Apr 2022 04:19:05 +0000

As developers we want to spend most time on new features and improvements, providing value to our users or customers. However, all software inevitably contains bugs and other defects. A lot can be done to catch defects before software reaches production (something Picnic’s automated fulfillment center team has previously written about ) but some defects are likely to go undetected until the software is in the hands of users.{#44cf}

Switch Statement and the Factory Pattern in Three JVM Languages

Wed, 06 Apr 2022 09:10:08 +0000

The goal of this article is to examine a program selection control mechanism.

A selection control mechanism allows a value, expression or variable type to influence the program flow execution. This concept is commonly used by developers.

A good example for this is a widely used design pattern. A design pattern that belongs to the family of creational patterns and is used for an object creation without exposing the entire logic.

Handling Null: Optional and Nullable Types

Mon, 04 Apr 2022 08:06:37 +0000

Java has long been infamous for its NullPointerException. The reason for the is calling a method or accessing an attribute of an object that has not been initialized.

var value = foo.getBar().getBaz().toLowerCase();

Running this snippet may result in something like the following:

Exception in thread "main" java.lang.NullPointerException
 at ch.frankel.blog.NpeSample.main(NpeSample.java:10)

At this point, you have no clue which part is null in the call chain: foo, or the value returned by getBar() or getBaz()?

Observability for JVM Frameworks with Grafana in Java and Kotlin

Wed, 30 Mar 2022 06:30:58 +0000

Grafana dashboard for all running frameworks

Introduction

In times of Cloud and distributed applications, it is becoming more and more important to be able to evaluate a functionality at runtime, an aspect which is referred to as observability .

A Cloud-based application is usually set up as a collection of different subsystems that may be located in one or more network zones or machines. These subsystems communicate with each other by passing messages (signals) and executing desired actions to each other. The whole collection then appears to the end user as a single coherent system.

Debugging Java Equals & Hashcode Performance in Production

Tue, 29 Mar 2022 06:50:17 +0000

I wrote a lot about the performance metrics of the equals method and hash code in this article . There are many nuances that can lead to performance problems in those methods. The problem is that some of those things can be well hidden.

To summarize the core problem: the hashcode method is central to the Java Collections API. Specifically, with the performance of hash tables (specifically the Map interface hash table). The same is true with the equals method. If we have anything more complex than a string object or a primitive, the overhead can quickly grow.

5 Things You Probably Didn’t Know About Java Concurrency

Fri, 25 Mar 2022 05:51:41 +0000

Threads are at the heart of the Java programming language. When we run a “Hello World” Java program, we run on the main thread. From there, we can create threads easily, as we need to compose our application code to be functional, responsive, and performant, all at the same time.

Think about a web server: it simultaneously handles many thousands of requests at the same time. In Java, we achieve this using multiple threads. While threads are helpful, they are full of dread/thread to many developers.

All about Generics: Part 1

Sun, 20 Mar 2022 22:54:03 +0000

Generics are used to parameterize types. A piece of code can be written generically enough so that we can fit a variety of types in it. Being a strongly type-safe language, Java requires to specify types in all aspects of its code, methods, fields, interfaces, etc.

However, generics is one of the tricky ways to make it possible to use type parameterization so that one particular portion or entirely of a class or their subclass can support a variety of types if an entity such as class, interface, or method that operates on a parameterized type is said to be a generic entity.

7 Reasons Why, After 26 Years, Java Still Makes Sense!

Tue, 15 Mar 2022 08:02:48 +0000

Java has been and continues to be the most popular language over the last two decades. It has always been in the top 5 in the TIOBE index in terms of popularity. Besides popularity, Java is especially dominant in the enterprise world.

However, in recent years, with the popularity of microservices and data science, other programming languages, such as Python, have gained in popularity. Some developers may view this as concerning news, as it may indicate the decline of Java, while others would argue differently.

Java Bytecode Simplified: Journey to the Wonderland (Part 1)

Tue, 08 Mar 2022 10:16:36 +0000

There are two ways to see a thing. One, see it as it appears to us; two, see it and appreciate it. For example, we get light when we switch on a lightbulb. We press the button and then get busy with our life. Pretty simple, but boring. On the other hand, if we know how the light gets energy from an electrical power grid far from our home with wires and while travelling through the wires and filament, the filament heats up and starts emitting photons, we get to see in the light; we can then appreciate the blessing.

Java Thread Programming (Part 14)

Tue, 01 Mar 2022 12:03:03 +0000

In our previous article , we discussed the thread pool’s sizing. We stipulated that if work is computational, we don’t need more threads than the available number of processors. We will discuss this idea a bit further in this article.

Let’s think about an example:

We all know how to compute the Fibonacci series. The simple code is given below-

public static long fib(int n) {
 if (n < 2) {
 return n;
 } else {
 return fib(n - 2) + fib(n - 2);
 }
}

Over here, we have used recursion to solve the Fibonacci series. To find the Fibonacci number of n, we must know the previous two. Each of them again will require to calculate the previous two. The process will continue until it reaches to the bases case and then we have a result.

Project Panama for Newbies (Part 4)

Thu, 24 Feb 2022 08:34:52 +0000

Updated December 31, 2025: This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22.

Welcome to Part 4 of Java’s Project Panama for newbies! If you’ve been following this series of posts on how to use Java’s Project Panama APIs you probably have noticed that all of the examples thus far demonstrate how Java code can execute C code by using the linker ’s downCall() method.

System Logger

Fri, 18 Feb 2022 12:34:57 +0000

December was not a good time for Java developers and even less for Ops. The former had to repackage their apps with a fixed Log4J’s version, and the latter had to redeploy them - several times. Yet, every cloud has a silver lining. In my case, I learned about System.Logger.

[

](https://twitter.com/OndroMih/status/1469599938782932992 ) In short, System.Logger is a façade over your logging engine. Instead of using, say, SFL4J’s API and the wanted implementation, you’d use System.Logger instead of SLF4J. It’s available since Java 9, and it’s a bummer that I learned about it only recently.

Java Thread Programming (Part 13)

Tue, 08 Feb 2022 08:15:29 +0000

Our previous article discussed different ways to create a Java thread pool and put and execute result-bearing tasks to the Pool. This article will go a bit in-depth about how many worker threads we could put in a pool to get the best result.

Using the Executors factory class, we can create our thread pool; however, all the factory methods internally create an instance of ThreadPoolExcutors. This class is the representation of ThreadPool that we use. We can directly create a pool invoking its constructor. The constructor takes 7 arguments:

Java Thread Programming (Part 12)

Tue, 01 Feb 2022 16:02:05 +0000

In our previous article , we introduced ThreadPool through the Executor Framework. This article will discuss the different ways we can create ThreadPool.

The Executors is a factory class, and it has a few static methods ( factory method). Let’s look at them one by one-

Executors.newFixedThreadPool(int nThreads): - this method takes an argument, and with that, we can specify the number of threads we want to have. The threads it creates are called worker Threads. It doesn’t matter how many tasks we put into this ThreadPool; the number of thread will remain the same the whole lifetime of this ThreadPool. If a thread dies for some reason, it will create a new one to keep the number the same.

Java Thread Programming (Part 11)

Wed, 26 Jan 2022 07:58:30 +0000

In the second article of this series , we saw that we can create a functional web server application using Java threads. With that, we could receive multiple requests from many clients and serve them properly.

However, there is a limitation. We cannot just receive an unbounded number of requests simultaneously. The constraint is not on the sockets. The modern OS can handle millions of open sockets at a time. That means, in theory, we should be able to serve that many requests at a time.

The State of Pattern Matching in Java 17

Mon, 03 Jan 2022 10:35:42 +0000

So what exactly is pattern matching?

“The act of checking a given sequence of tokens for the presence of the constituents of some pattern.” – Wikipedia

Or simply put, pattern matching is a language feature where you can test for a specific pattern on a character sequence or a data structure.

Pattern matching can be classified into two types.

Sequence patterns: pattern matching on character sequence or strings. Also known as our beloved Regular Expressions 😉 — I still wish I could write RegEx without cursing and looking up the syntax.
Tree patterns: testing for patterns on a data structure. This is what we are going to talk about today.

Java Thread Programming (Part 10)

Wed, 22 Dec 2021 09:23:41 +0000

In this article, I will discuss BlockingQueue, one of the essential concurrent collections available in the concurrent package in the JDK. In one of our previous articles , we discussed the Producer/Consumer pattern. We will implement the same pattern today using BlockingQueue.

In that implementation, we used a buffer, and when Buffer is full, we put the producer thread in a waiting state. And if Buffer is empty, we put the consumer thread in a waiting state. To coordinate between threads, we had to use, wait(), notify() and notifyAll(), these low-level constructs. However, if we use BlockingQueue, we don’t have to use these low-level details. BlockingQueue was implemented with such details built in, so that we can just rely on it. It has two methods that are important in our discussion:

Equals and Hashcode Implementation Considerations

Sun, 21 Nov 2021 11:55:39 +0000

I always struggled with how to implement equals and hashcode, until I learned about the difference between entities and value objects.

Why implement equals and hashcode?

All classes in Java inherit from java.lang.Object.

The equals() and hashCode() methods are two important methods that you usually should override when defining your own classes.

equals() is important for comparing 2 objects to check if they represent the same thing.

We will see in a bit what that means exactly for different types of objects.

Java Thread Programming (Part 6)

Tue, 16 Nov 2021 15:02:53 +0000

Have you ever wondered what is the purpose of the “wait()”, “notify()”, “notifyAll()” methods that come with each Java object? Well, this article will explain that!

In the previous article , we learned how to use shared variables in a multi-threaded context and ensure thread safety avoiding data race and race conditions. However, in programming, sometimes multiple threads require to coordinate with each other by sending signals. For example -

For a thread, it’s not yet their turn to start work; rather it’s waiting for a signal to start.
A thread is working, but to complete its work, it needs more data; it can send a signal to the Producer to produce more data.
Another thread that are producing data can signal other thread that data is ready.

Basically, there are many similar cases when we need to coordinate among multiple threads. Let’s discuss this in this article.

Let’s Use Optional to Fix Method Contracts

Wed, 10 Nov 2021 11:56:19 +0000

A method is a contract: when we define one, we put thought into it. We specify parameters with their type and also a return type. When we invoke a method, we expect it to behave according to the contract. If it doesn’t, it’s a violation of the contract.

We have been dealing with such violations all the time. We invoke a method with its proper arguments and we get a return. However, sometimes we end up getting a null, which is, in fact, a clear violation. We shouldn’t accept such a violation. If a method cannot return the value of the specified type, it should mention that in the method signature, the method may or may not be returning the value you are expecting. If we know it from the method signature, we then write our code accordingly.

Java Thread Programming (Part 5)

Tue, 02 Nov 2021 08:29:36 +0000

In our previous article , we discussed the “data race” concept and how we can solve it using volatile keywords. However, this is not the only problem we face when dealing with code that runs in multi-threaded environments. In this article, we will discuss another situation called “race conditions” and how we can resolve it.

By now, we know that threads share memory space so that multiple threads can read from and write to the same variable. Unfortunately, although this ability gives us faster memory access, it has an unpleasant side effect which we call “race condition,” and it creates data inconsistency in the program. To understand the problem, let’s see an example.

Java Thread Programming (Part 4)

Tue, 26 Oct 2021 13:04:40 +0000

In the previous article , we discussed the visibility problem while working with multiple threads.

We will discuss another similar situation in this article. However, we will use symbols and pseudocode to explain this.

Symbols

Let’s define the symbols first.

L - Local variable, e.g., L1, L2, etc.
S - Shared variable, e.g., S1, S2, etc. These variables are visible among multiple threads. They can be static as well.

S.X - here X is a field of an object where S is the reference of that Object, e.g., S1.X.

Java Thread Programming (Part 3)

Thu, 21 Oct 2021 13:20:17 +0000

Continuing from part 2 , let’s start this article with a bit of context first (and if you don’t like reading text, you can skip this introduction, and go directly to the section below where I discuss pieces of code).

Context

When we start an application program, the operating system creates a process.
Each process has a unique id (we call it PID) and a memory boundary.
A process allocates its required memory from the main memory, and it manipulates data within a boundary.
No other process can access the allocated memory that is already acquired by a process.
It works like a sandbox, and in that way avoids processes stepping on one another’s foot.
Ideally, we can have many small processes to run multiple things simultaneously on our computers and let the operating systems scheduler schedule them as it sees fit.
In fact, this is how it was done before the development of threads. However, when we want to do large pieces of work, breaking them into smaller pieces, we need to accumulate them once they are finished.
And not all tiny pieces can be independent, some of them must rely on each other, and thus we need to share information amongst them.
To do that, we use inter-process communication. The problem with this idea is that having too many processes on a computer and then communicating with each other isn’t cheap. And precisely that is where the notion of threads comes into the picture.

The idea of the thread is that a process can have many tiny processes within itself. These small processes can share the memory space that a process acquires. These little processes are called a thread. So the bottom line is, threads are independent execution environments in the CPU and share the same memory space. That allows them faster memory access and better performance.

Java Thread Programming (Part 2)

Tue, 12 Oct 2021 09:07:05 +0000

In our earlier article , we explained the background to threading and how to create and start a thread.

In this article, let’s see an example where we can use Threads to our benefit.

Let’s assume we are going to build a web server. For the sake of the example, let’s constrain ourselves to one single use case, which is that the web server will listen to any client, and if it receives a URL, it will return the top five most frequently used words in that website.

Java Thread Programming (Part 1)

Thu, 07 Oct 2021 10:07:29 +0000

What is a Thread?

We write code in a file line by line, and then it gets executed. To be able to execute a piece of code requires an execution environment. In Java, a thread is an execution environment. If a program has only one execution environment, then we call this program a single-threaded program.

Interestingly, in Java, we can create a lot of threads to run different parts of the code of a program executing independently. And when we have achieved that, we call it a multi-threaded program.

Reclaim 25% of Java Heap Memory & Lower Your Cloud Bills

Fri, 24 Sep 2021 09:15:05 +0000

Did you know that you can save up to 25% of your heap memory and your Cloud bills without any effort? Well, it’s true. Many exciting features have been added to the latest releases of Java recently and I’m going to cover one that is often overlooked in this article.

We all know that Strings are the most used Object in any Java application. In fact, they probably take up almost half of the heap size of any Java application. Before delving into this much further, let me answer your obvious question: what are Strings made of?

Demystifying Memory Management in Modern Programming Languages

Tue, 07 Sep 2021 08:13:38 +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.

I hope the series would give you some insights into what is happening under the hood of these languages in terms of memory management.

Learning about memory management will also help us to write more performant code as the way we write code also has an impact on memory management regardless of the automatic memory management technique used by the language.

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.

Introducing Teeing: A Hidden Gem in the Java API

Wed, 12 May 2021 07:15:07 +0000

Last week, I described a use-case for a custom Stream Collector. I received a intriguing comment on Twitter:

Hats off to you, Miguel! Your comment revealed a method I didn’t know!

So I decided to investigate what is the teeing() method about.

Returns a Collector that is a composite of two downstream collectors. Every element passed to the resulting collector is processed by both downstream collectors, then their results are merged using the specified merge function into the final result.

Taking A Deep Dive Into Multi-Threading in Java

Tue, 13 Apr 2021 07:21:59 +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.

Multi-threading represents a very intriguing topic, even after years of research and development for high quality, robust, and efficient software. With equal emphasis on hardware improvements and the software that runs on it – we have newer paradigms for parallelism. The most important yet basic concepts are the ones which I present here. I then explain the intricacies of multi-threading in the Java programming language. Some of these are newer features and supported only from the Java Platform Standard Edition 5.0. Let us start with a quick overview and understanding of the core concepts.

Embracing JVM unified logging (JEP-158 / JEP-271)

Wed, 10 Mar 2021 18:20:13 +0000

In the previous blog post , I briefly introduced unified logging and a simple GC configuration. However for the savvy GC tuners, there are many more options. And there are other logging options that transitionned to unified logging infrastructure as well.

I wasn’t satisfied with the official documentation and other blog posts as they usually present only a fragmented picture of the previous options. This led me to dig in.

Migrating the GC logging (continued)

|——|——————————–| | Note | These log are based on JDK11u. |

Modules, Modules, Everywhere, on Maven Central!

Wed, 24 Feb 2021 08:34:58 +0000

Project 🧩 sormuras/modules

Since August 2018, I have been compiling an overview of Java modules uploaded to Maven Central at https://github.com/sormuras/modules .

This overview is generated by the Scanner program and it is based on the results of the modulescanner that is run on Sonatype s hardware on every uploaded JAR file and stored in an AWS S3 bucket, setup together with the AdoptOpenJDK team at their #java9plusadoption Slack channel. Some of those uploaded JAR files are Java modules. They are the interesting subjects of this overview as they contain a module-info.class, a compiled module descriptor with a stable name and an explicit API their author(s) comitted to.

Much Ado About Nothing (Also Known As "Null") In Java

Tue, 23 Feb 2021 15:19:02 +0000

Occasionally something in Java pops up that I thought I knew about, but it turns out I didn’t appreciate all the subtle details.

This was recently the case for null.

Before I started using Java, the main programming language I used was C. This was great for things like operating systems and device drivers because it uses explicit pointers. References to data are through a numerical address that can be manipulated if required. This was probably (for me at least) the hardest thing to master, especially when you try to figure out things like this:

Learning About Optional.stream() in OpenJDK and Java

Mon, 22 Feb 2021 17:11:33 +0000

This week, I learned about a nifty “new” feature of Optional that I want to share in this post. It’s available since Java 9, so its novelty is relative.

Let’s start with the following sequence to compute the total price of an order:

public BigDecimal getOrderPrice(Long orderId) {
 List<OrderLine> lines = orderRepository.findByOrderId(orderId);
 BigDecimal price = BigDecimal.ZERO; // 1
 for (OrderLine line : lines) {
 price = price.add(line.getPrice()); // 2
 }
 return price;
}

Provide an accumulator variable for the price
Add each line’s price to the total price

Nowadays, it’s probably more adequate to use streams instead of iterations. The following snippet is the equivalent to the previous one:

Migrating Browser-Based Java Applets to IcedTea-Web using JNLP

Tue, 02 Feb 2021 07:55:53 +0000

“Does it run on JDK 11?” – That’s an always interesting question!

As a practical, more challenging example around this question, I used a 20 year old JAR, once created for a Java Applet to be run in the Java 1.1 Browser Plugin. Yes, that’s 1.1 not 11!

To cut to the chase for those who fear this may be too long to read: yes it runs! 🙂

And to provide more detail—it now runs outside of any Web Browser and without modifying its decades-old JAR. The Applet was once created and offered to browse through all raw color images uploaded by the Mars Pathfinder Lander which settled down on the planet on July 4th, 1997.

How to Create Self-Contained Executable JARs

Mon, 01 Feb 2021 08:40:08 +0000

When your application goes beyond a dozen of lines of code, you should probably split the code into multiple classes. At this point, the question is how to distribute them. In Java, the classical format is the Java ARchive, better known as the JAR. But real-world applications probably depend on other JARs.

This article aims to describe ways to create self-contained executable JARs, also known as uber-JARs or fat JARs.

How to Avoid NullPointerException in Java Code

Tue, 22 Dec 2020 10:14:41 +0000

The terrible NullPointerException (NPE for short) is the most frequent Java exception occurring in production, according to a 2016 study . In this article we’ll explore the main techniques to fight it: the self-validating model and the Optional wrapper.

Self-Validating Model

Imagine a business rule: every Customer has to have a birth date set. There are a number of ways to implement this constraint: validating the user data on the create and update use-cases, enforcing it via NOT NULL database constraint and/or implementing the null-check right in the constructor of the Customer entity. In this article we’ll explore the last one.

Seven Ways to Contribute to the OpenJDK

Wed, 18 Nov 2020 08:49:32 +0000

A great many developers today are employed working with OpenJDK. If OpenJDK is the background source for your livelihood, you might want to contribute to future development of the OpenJDK.

There are many ways you can do this. In this article I outline 7 possibilities, ranging from minimal work (because you’re too busy to do much, but you’d like to do something) to intensive work (participating on OpenJDK development is everything you want to do, it’s more than a hobby, you want to contribute to the maximum extent possible).

OpenJDK, JDKs and Every Java Acronym in Between

Wed, 04 Nov 2020 09:57:46 +0000

The Java SE landscape is strewn with acronyms that it has picked up over the last 25 years. Sometimes those acronyms even mean multiple things. This post attempts to explain them all in terms of two main groupings:

OpenJDK
Java Development Kits (JDKs)

What is ‘OpenJDK’?

The phrase OpenJDK is used to describe at least three fundamental things in the Java ecosystem.

First use

Firstly, there is a place called OpenJDK which lives at https://openjdk.java.net/ also known to some as The OpenJDK Project , which is a place to collaborate on an open-source implementation of the Java specifications from Oracle - https://www.oracle.com/java/technologies/java-se-glance.html , which are released every 6 months. Sun Microsystems open-sourced the majority of Java in 2006 under the GNU General Public License (GNU GPL) version 2 with a linking exception. OpenJDK serves as a continuation of that change. This is the use that I will refer to througout this blog. When I say OpenJDK I mean the https://openjdk.java.net/ .

Running Single-File Java Source Code Without Compiling (Part 2)

Thu, 10 Sep 2020 15:54:17 +0000

Let’s continue from part 1 of this series , by looking at JEP 330, Launch Single-File Source-Code Programs, which is one of the new features introduced in the OpenJDK 11 release. This feature allows you to execute a Java source code file directly using the java interpreter. The source code is compiled in memory and then executed by the interpreter, without producing a .class file on disk.

However, this feature is limited to code that resides in a single source file. You cannot add additional source files to be compiled in the same run.

Running Single-File Java Source Code Without Compiling (Part 1)

Tue, 08 Sep 2020 08:15:03 +0000

If you recall the old days, before OpenJDK 11, say you have a HelloUniverse.java source file that contains a class definition and a static main method, which prints out as a single line of text to the terminal, like the following:

public class HelloUniverse{
 public static void main(String[] args) { 
 System.out.println("Hello foojay!");
 }
}

Normally to run this class, first, you would need to compile it, using a Java compiler (javac), which would result in a HelloUniverse.class file:

Overview of JVM Vendors and Choosing the Right One

Wed, 22 Jul 2020 13:07:29 +0000

Since you’re reading this blog, chances are that you’re writing software which will eventually run on a JVM. Most of you are using the Java language. Many of you are using a variety of other languages that target the JVM, such as Scala, Kotlin, Clojure, Groovy, (J)Ruby etc. Eventually you’ll need to decide on which JDK/JRE to deploy your software on in production. This is much easier said than done. There are quite a few different vendors out there, providing support and taking responsibility for the binaries they produce. They can have different support lengths for specific versions, and whereas you can sometimes find a vendor providing extended support for a version that has been officially end-of-lifed at Oracle, you may not find builds with the latest fixes in them publicly available. You’ll need to get those directly from the vendor.

Highlights of Changes to the Core Java Platform

Thu, 02 Jul 2020 14:12:00 +0000

February 12th, 1996. This is a significant date for me personally since it was the day I started work at Sun Microsystems as a Solaris Systems Engineer. It was also two weeks and six days after the release of the Java Development Kit (JDK 1.0).

Of course, the origins of Java go further back than this; James Gosling and others started work on a new programming language in 1991, and it was the May 23rd 1995 when Java was officially announced to the world.

How does Java handle different Images and ColorSpaces – Part 4

Tue, 23 Jun 2020 17:20:00 +0000

Unless you are creating all your images, by drawing then inside the code with the Graphics2D commands, you will need an image library to load images as BufferedImages. You will also need an Image library if you wish to save the results.

ImageIO is part of Java, it is free and it supports a range of Image formats including GIF, JPEG, PNG, and TIF. Because it is expandable, there are additional libraries to extend it. We recommend you check out the excellent TwelveMonkeys image library which is free and Open Source.

How does Java handle different Images and ColorSpaces – Part 3

Mon, 22 Jun 2020 17:16:00 +0000

BufferedImage is one of the most useful Java abstractions. It hides all the complexity of different types of images whilst allowing access to the underlying data. Under the hood, a BufferedImage can be many types of image. This is the list of types visible in an IDE.

The differences between the types of BufferedImage are:-

Range of Colours (Binary will give back and white only, RGB will provide 24-bit color)
Opacity (only available in ARGB – the A is an 8 bit Alpha channel).
Amount of memory used (ARGB uses the most as 4 bytes per pixel).
Size of the saved file.

A BufferedImage generally uses the RGB, Gray or Binary Color Spaces. Data can be in other formats, and the raw raster data can be loaded and accessed for CMYK and YCCK, but the Colors will not display correctly. BufferedImage provides lots of methods to access the raw image data, including the Raster, pixel and ColorModel used.

How does Java handle different Images and ColorSpaces – Part 2

Sun, 21 Jun 2020 17:11:00 +0000

There are lots of different ways of describing Color. As developers, we are most familiar with the RGB model, where every color is defined by mixing Red, Green and Blue together. In the print world, CMYK is very common, where colors or printed by literally mixing different amounts of Cyan, Magenta, Yellow and Key (black). You may also come across other ways of describing color such as DeviceN. There are also lots of different versions of RGB.

How does Java handle different Images and ColorSpaces – Part 1

Sat, 20 Jun 2020 17:03:00 +0000

One of the attractions of Java is the way it abstracts and simplifies many programming constructs. In place of Tiffs, PNGs, JPEGs and other Image formats, you get a simple BufferedImage object. ImageIO and other third-party libraries such as our own JDeli image library provide methods to read and write a BufferedImage.

We have spent a lot of time working with different images formats in the process of writing the JDeli Image library as a replacement for ImageIO and the aim of this series is to share that knowledge to a wider audience.