Kafka on foojay.io - Friends of OpenJDK

🛑⚡ When NOT TO USE Event-Driven Architecture (EDA)

Sat, 11 Jul 2026 00:34:03 +0000

When Event-Driven Architecture Is Not the Right Choice

Event-Driven Architecture (EDA) can help teams build scalable, loosely coupled and highly responsive distributed systems. Technologies such as Apache Kafka, RabbitMQ, Pulsar and cloud messaging platforms have made this architectural style increasingly popular.

However, EDA also introduces significant complexity. Asynchronous communication requires teams to manage retries, duplicate events, eventual consistency, schema evolution, observability and failure recovery. When these challenges are introduced without a clear business or technical need, an event-driven system can become harder to develop, operate and debug than a simpler synchronous architecture.

Event-Driven Architecture in Java and Kafka

Tue, 10 Mar 2026 18:35:42 +0000

Reactive Java is well suited to modern streaming, event driven applications. In this article, we’ll walk through an example of such an application using Reactive Java with MongoDB. Specifically, we’re going to cover:

Why Reactive Java was introduced and how it differs from more traditional Java programming.
Details of some of the key elements of Reactive Java - Mono , Flux and flatMap.
A walk through of a sample application, comparing a Reactive version of the code using the Reactive Streams MongoDB driver, with a more traditional version of the code using the synchronous MongoDB driver.

Streaming Data - The Air Traffic Control Example.

As a key part of global initiatives to modernize national airspace systems, many national aviation authorities have introduced mandates requiring most non-military aircraft transmit GPS based location data using a system known as Automatic Dependent Surveillance Broadcast, or “ADS-B”.

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

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

The Hidden Cost of “Good Enough” Code

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

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

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

Micrometer & Prometheus in Spring Boot: Kafka Burger Orders

Fri, 14 Nov 2025 10:13:03 +0000

👨‍💻 GitHub: https://github.com/vinny59200/dukeburger

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪

This guide shows how to use Micrometer and Prometheus in Spring Boot to track a custom metric for a Kafka-driven Burger Orders app. You’ll post a burger order to a REST endpoint, publish it to Kafka, consume the topic, and increment a counter for all “DukeBurger” orders. Copy the snippets, run, and you’ll see your metric on /actuator/prometheus.

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

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

Why is Latency so Important to Kafka?

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

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

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

SpringBoot and Kafka Streams – Event Routing & Testing

Thu, 19 Jun 2025 08:37:11 +0000

Welcome to this hands-on guide to building a Spring Boot Kafka Streams application! (SpringBoot and Kafka Streams).

In this article, I’ll walk you through a project I built during the first day of a three-day Kafka Streams training. The goal? Validate sightseeing events in Lille based on predefined timetables and route the data accordingly.

Let’s explore how Kafka Streams powers a real-time city tour experience! 🧭

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪

Spring Cloud Stream: Demystifying Event-Driven Architecture

Fri, 28 Feb 2025 08:34:32 +0000

Consider a bustling restaurant environment. The kitchen receives a flood of orders, waitstaff dart between tables, and patrons anxiously glance at their watches. Each time a waiter takes an order, he or she must verify it with the kitchen and wait for the kitchen to prepare the meal before attending to another table. This cumbersome method hampers efficiency, leaving the restaurant unable to meet customer demand.

Now envision an alternative situation. Instead of enduring delays, waitstaff enter orders into a centralized system, prompting the kitchen to begin meal preparation immediately upon receipt. As soon as the kitchen prepares the food, waiters receive instant notifications, enabling them to serve customers promptly without any delays. This exemplifies event-driven architecture: a fluid, real-time system where they exchange information asynchronously, promoting scalability and quick responsiveness.

Event-Driven Architecture and Change Data Capture Made Easy

Tue, 18 Feb 2025 16:44:14 +0000

Hello again! In this article (Part 1), we will discuss two common ways to build modern software systems : Event-Driven Architecture (EDA) and Change Data Capture (CDC). They serve different purposes but can work well together in some situations.

we’ll explain EDA and CDC, discuss their use cases, and explain when to use them and when not to. Using plain language and relatable examples, we’ll also explore how they work together.

Writing a Data Orchestrator in Java

Thu, 02 May 2024 19:43:32 +0000

A data orchestrator is a platform to schedule, organize, and monitor data-oriented workflows. A workflow is a set of tasks, most data orchestrators come with built-in tasks for a wide range of technologies and provide support for custom processing via a scripting language. A data orchestrator can have multiple types of triggers to start a workflow.

Most Data orchestrators are written in Python.

Most Data orchestrators mandate that you write Python code.

Building Real-Time Applications to Process Wikimedia Streams

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

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

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

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

Starting Apache Kafka on Java 8, Win 10

Mon, 07 Aug 2023 09:39:39 +0000

This is part 2 of a two part series on Starting Apache Kafka Server, Configuring Kafka Topic, and Creating a Core Java Based Kafka Consumer, as also a Core Java Based Kafka Producer.

All this is demonstrated in step-by-step examples. All of this is for Java v8.0, Apache Kafka v3.4 on Windows 10. Part 1 focused on Kafka Consumer and Kafka Producer from the Command Line. This article focuses on the Core Java counterparts. It is important that the reader reads part 1 and completes the example so that the reader has a basic foundation in Kafka.

Starting Apache Kafka v3.4 on Win 10

Sat, 29 Jul 2023 07:43:32 +0000

Introduction

This is part one of a two part articles series on Running Apache Kafka Server, Configuring Kafka Topics, and Creating a Kafka Consumer and Kafka Producer.

All this is demonstrated step-by-step example that works from the Command Line.

All of this is for Apache Kafka v3.4 on Windows 10.

Pre-Requisites

Install Java ( v8.0 is used in this Example )
Install Apache Kafka v3.4.0 from the Given Link
Set Java Classpath > Set JAVA_HOME Correctly
UnZIP/UnTAR Apache Kafka Downloaded in (2)
Use a Text Editor like [ Notepad++ ] for Editing

Ingesting Data from Kafka into the QuestDB time-series database

Tue, 28 Mar 2023 09:38:35 +0000

If you are working on a project with fast or streaming data, chances are Apache Kafka is already part of your pipeline .

But if you want to analyse your data, you will need to ingest from Kafka into some destination.

For time-series data, QuestDB can be an excellent choice.

For those of you who are not yet familiar with QuestDB , it is an Apache 2.0 licensed database designed for high throughput ingestion and fast SQL queries.

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?

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.

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.

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

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

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

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

How We Did It

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

Bring Streaming to Apache Cassandra with Apache Pulsar

Thu, 05 May 2022 18:10:42 +0000

Twitch, YouTube, Instagram, Facebook — virtually every major brand nowadays uses live streaming to connect and engage their audience.{#2544}

For enterprises and developers building cloud-native applications , this growing trend creates a need for streaming technologies that can reliably handle the rush of massive amounts of data, while also being flexible and easy to manage for developers.{#2544}

One such technology is Apache Pulsar ® — an open-source, distributed messaging and streaming platform that’s easy to deploy, simple to scale, and packed with developer-friendly APIs.{#8b5a}

Increasing Event Streaming with Kafka and Azul

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

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

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

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

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

What is Azul Platform Prime and Platform Core?

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

Why Pulsar Beats Kafka for a Scalable, Distributed Data Architecture

Thu, 03 Mar 2022 14:10:45 +0000

The leading open source event streaming platforms are Apache Kafka and Apache Pulsar. For enterprise architects and application developers, choosing the right event streaming approach is critical, as these technologies will help their apps scale up around data to support operations in production.

Everyone wants results faster. We want applications that know what we want, even before we know ourselves. We want systems that constantly check for fraud or security issues to protect our data. We want applications that are smart enough to react and change plans when faced with the unexpected. And we want those services to be continuously available.

Simplify Migrating from Kafka to Pulsar with Kafka Connect Support

Wed, 05 Jan 2022 11:30:09 +0000

Large-scale implementations of any system, such as the event-streaming platform Apache Kafka, often involve customizations and tools and plugins developed in-house. When it’s time to transition from one system to another, the task can become complicated, drawn-out, and error-prone. Often the benefits of an alternative system (which can include significant cost savings and other efficiencies) are outweighed by the risks and costs of migration. As a result, an organization can end up locked into a suboptimal situation, footing a bigger bill than necessary and missing out on modern features that help move the business forward faster.