fidzu : Java

Agentic AI is changing how enterprises think about automation and intelligence. Agents are no longer reactive systems. They are goal-driven, context-aware, and capable of autonomous decision-making. But to operate effectively, agents must be connected to the real-time pulse of the business. This is where data streaming with Apache Kafka and Apache Flink becomes essential.

Apache Flink is entering a new phase with the proposal of Flink Agents, a sub-project designed to power system-triggered, event-driven AI agents natively within Flink's streaming runtime. Let's explore what this means for the future of agentic systems in the enterprise.

21 Jan 2026 8:00pm GMT

Most engineers imagine failures as sudden events. A service crashes. A node goes down. An alert fires, and everyone jumps into action. In real high-availability Java systems, failures rarely behave that way. They almost always arrive quietly first.

Systems that have been running reliably for months or years begin to show small changes. Latency creeps up. Garbage collection pauses last a little longer. Thread pools spend more time near saturation. Nothing looks broken, and dashboards stay mostly green. Then one day, the system tips over, and the failure suddenly looks dramatic.

21 Jan 2026 2:00pm GMT

Instead of building custom integrations for a variety of AI assistants or Large language models (LLMs) you interact with - e.g., ChatGPT, Claude, or any custom LLM - you can now, thanks to the Model Context Protocol (MCP), develop a server once and use it everywhere.

This is exactly as we used to say about Java applications; that thanks to the Java Virtual Machine (JVM), they're WORA (Write Once Run Anywhere). They're built on one system and expected to run on any other Java-enabled system without further adjustments.

14 Jan 2026 1:00pm GMT

Many Kotlin codebases are written by developers with a Java background. The syntax is Kotlin, but the mindset is often still Java, resulting in what can be called "Java with a Kotlin accent." This style compiles and runs, but it misses the core advantages of Kotlin: conciseness, expressiveness, and safety.

Common symptoms include:

12 Jan 2026 7:00pm GMT

In a recent post, I have demonstrated the benefits of using AWS ECS (Elastic Container Service), with Quarkus and the CDK (Cloud Development Kit), in order to implement an API for the customer management.

In the continuity of this previous post, the current one will try to go a bit further and replace ECS by EKS (Elastic Kubernetes Service) as the environment for running containerized workloads. Additionally, an automated CI/CD pipeline, using AWS CodePipeline and AWS CodeBuild, is provided.

08 Jan 2026 2:00pm GMT

The purpose of this article is to depict and demonstrate how to automate the build and deployment process using a CI/CD pipeline with CloudHub 2.0 (Mule 4).

Prerequisites

• Anypoint CloudHub account (CloudHub 2.0)
• app.runtime - 4.9.0
• mule.maven.plugin.version - 4.3.0
• Anypoint Studio - Version 7.21.0
• OpenJDK - 11.0

07 Jan 2026 4:00pm GMT

In my previous article, I demonstrated how to implement OIDC4VCI (credential issuance) and OIDC4VP (credential presentation) using Spring Boot and an Android wallet. This follow-up focuses on a critical security enhancement now mandated by EUDI standards: DPoP (Demonstrating Proof-of-Possession).

The Problem With Bearer Tokens

Traditional Bearer tokens have an inherent weakness: anyone who obtains the token can use it. If an attacker intercepts or steals a Bearer token, they can impersonate the legitimate client until the token expires (or is revoked).

05 Jan 2026 7:00pm GMT

One of the core factors in API test automation is verifying the response body for data integrity. It is a crucial step in the functional validation of the API to confirm that it is returning the correct data as desired.

This verification of the response body can be of a POST, GET, PUT, or PATCH API request. The same logic can be applied to any API response for verifying the data returned by the API.

05 Jan 2026 3:00pm GMT

Working with dates and time has always been one of the trickiest parts of Java development. For years, developers wrestled with java.util.Date, Calendar, and the never-ending confusion around mutability, time zones, thread safety, and formatting quirks. When Java 8 introduced the java.time package, it finally brought a modern and much more intuitive date-time API inspired by Joda-Time. Yet even with this improved API, many developers still find themselves constantly converting between different date representations, especially when integrating legacy systems, REST interfaces, databases, or front-end clients.

In this article, I want to walk through the best practical approaches for date conversion in Java 8+, focusing on clarity and reliability. These are patterns I've seen consistently used in production systems, and they help avoid many silent bugs that come from incorrect time zone assumptions, accidental loss of precision, and misuse of the older date classes.

05 Jan 2026 2:00pm GMT

Java remains one of the most popular languages for enterprise applications running on the cloud. While languages like Go, Rust, JavaScript, and Python have a high profile for cloud application developers, the RedMonk language rankings have ranked Java in the top three most popular languages throughout the history of the ranking.

When deploying applications to the cloud, there are a few key differences between deployment environments and development environments. Whether you're spinning up a microservice application on Kubernetes or launching virtual machine instances, it is important to tune your Java Virtual Machine (JVM) to ensure that you are getting your money's worth from your cloud spend. It pays to know how the JVM allocates resources and to ensure you use them efficiently.

26 Dec 2025 9:00pm GMT

What is Virtual Thread

Multi-threading is a widely used feature across the industry for developing Java-based applications. It allows us to run operations in parallel, enabling faster task execution. The number of threads created by any Java application is limited by the number of parallel operations the OS can handle; in other words, the number of threads in a Java application is equal to the number of OS threads. Until now, this limitation has created a bottleneck on further scaling any application, considering the current fast-paced ecosystem.

To overcome this limitation, Java has introduced the concept of Virtual Thread in JDK21. A Java application creates a Virtual Thread and is not associated with any OS thread. It means every Virtual Thread does not need to be dependent on a Platform Thread (aka OS thread). Virtual Thread will work on any task independently and will acquire a Platform Thread only when it needs to perform any I/O operation.

15 Dec 2025 12:00pm GMT

In the previous article, we learnt the basics, setup, and configuration of the REST Assured framework for API test automation. We also learnt to test a POST request with REST Assured by sending the request body as:

1. String
2. JSON Array/ JSON Object
3. Using Java Collections
4. Using POJO

In this tutorial article, we will learn the following:

12 Dec 2025 2:00pm GMT

Web applications depend on Java-based services more than ever. Every request that comes from a browser, a mobile app, or an API client eventually reaches a backend service that must respond quickly and consistently. When traffic increases or a dependency slows down, many Java services fail in ways that are subtle at first and catastrophic later. A delay becomes a backlog. A backlog becomes a timeout. A timeout becomes a full service outage.

The goal of a reliable web service is not to avoid every failure. The real goal is to recover from failure fast enough that users never notice. What matters is graceful recovery.

09 Dec 2025 7:00pm GMT

Design documents in Enterprise Java often end up trapped in binary silos like Excel or Word, causing them to drift away from the actual code. This pattern shows how to treat Design Docs as source code by using structured Markdown and generative AI.

We've all been there: the architecture team delivers a Detailed Design Document (DDD) to the development team. It's a 50-page Word file, even worse, a massive Excel spreadsheet with multiple tabs defining Java classes, fields, and validation rules.

03 Dec 2025 8:00pm GMT

In this article, we will walk you through how to conduct a load test and analyze the results using Java Maven technology. We'll covering everything from launching the test to generating informative graphs and tables.

For this demonstration, we'll utilize various files, including Project Object Model (POM) files, JMeters scripts, and CSV data, from the jpetstore_loadtesting_dzone project available on GitHub. This will help illustrate the steps involved and the functionality of the necessary plugins and tools. You can find the project here: https://github.com/vdaburon/jpetstore_loadtesting_dzone.

02 Dec 2025 9:00pm GMT

When engineering teams modernize Java applications, the shift from JDK 8 to newer Long-Term Support (LTS) versions, such as JDK 11, 17, and soon 21, might seem straightforward at first. Since Java maintains backward compatibility, it's easy to assume that the runtime behavior will remain largely unchanged. However, that's far from reality.

In 2025, our team completed a major modernization initiative to migrate all of our Java microservices from JDK 8 to JDK 17. The development and QA phases went smoothly, with no major issues arising. But within hours of deploying to production, we faced a complete system breakdown.

02 Dec 2025 6:00pm GMT