fidzu : Java

Testing is an essential step in the API development process to ensure that APIs are working correctly. There are multiple HTTP methods in RESTful APIs, including POST, GET, PUT, PATCH, and DELETE. In our earlier articles, we learned how to perform automated testing of POST, PUT, and GET APIs using Rest-Assured Java.

In this tutorial article, we will discuss and cover the following points:

13 May 2026 1:30pm GMT

The Problem

You're running a Java application in a Docker container on your M1 Mac. Everything works fine, but you notice something strange: The resident set size (RSS) keeps growing, even though your heap usage is stable. After hours of investigation, you find mysterious rwxp memory regions, each exactly 128 MB, accumulating in your process memory map.

What's causing this? Is it a memory leak? A JVM bug? Something else entirely?

12 May 2026 7:00pm GMT

Modern Java applications require robust observability and automated intelligence to ensure reliability at scale. Dynatrace's AI-driven platform continuously learns application behavior, establishes statistical baselines and applies deterministic, causation based analysis to detect anomalies and pinpoint root causes.

By correlating metrics, logs, traces, and topology context across applications, services and infrastructure, Dynatrace can automatically highlight the true source of problems and assess their impact. This drastically reduces alert noise and MTTR .

11 May 2026 12:00pm GMT

Building real-time applications means balancing user responsiveness with heavy backend processing. A proven solution is to decouple heavy workloads using events and asynchronous processing. In this approach, a Spring Boot application quickly publishes events to Kafka instead of processing requests inline. Then Kafka consumers (with AI/ML logic) handle the data in the background, and the results are pushed to clients in real time via WebSockets. This article highlights three key patterns enabling this architecture:

1. Event Production with Spring Boot and Kafka
2. AI-Driven Processing in Kafka Consumers
3. Real-Time WebSocket Delivery to the Frontend

Event Production with Spring Boot and Kafka

The first step is capturing an event and publishing it to Kafka. By offloading work to Kafka the application can respond immediately to the user without waiting for processing. Spring Boot's integration with Apache Kafka provides a KafkaTemplate to send messages to topics.

08 May 2026 2:00pm GMT

PUT requests are typically used for updating an existing resource. This means replacing the current data for the target resource with the data sent in the API request body.

Just like POST requests, the content-type header is important because it tells the server how to interpret the data we're sending.

07 May 2026 2:30pm GMT

Java has always been a serious language for production systems, and in 2026, the Generative AI ecosystem has finally caught up. For years, Java developers watched from the sidelines as Python and TypeScript accumulated framework after framework for building LLM-powered applications. Today, the picture is very different. Java has multiple mature, actively maintained AI frameworks, each with its own philosophy and trade-offs.

This article covers the four frameworks I have personally used to ship Java AI applications: Genkit Java, Spring AI, LangChain4j, and Google ADK Java. Each one represents a meaningfully different bet on what a Java AI framework should be, and understanding those differences will save you from picking the wrong tool.

07 May 2026 12:30pm GMT

Recently at IBM Software Labs, I worked on a task that forced me to understand something many Java developers rarely think about - how Java interacts with the operating system.

Most of our daily work happens safely inside the JVM. Memory management, threads, and file handling - the JVM abstracts these away nicely.

30 Apr 2026 5:00pm GMT

We moved our monolithic Java application to Kubernetes last year. The promise was scalability and resilience. The reality was a series of silent failures during deployments. Users reported dropped connections every time we pushed a new version. Our monitoring showed zero downtime, but the customer experience told a different story. Requests vanished into the void during rolling updates. We spent weeks chasing network ghosts before finding the root cause. The issue was not the network. It was how our Java application handled termination signals.

In this article, I will share how we adapted our Java backend for container orchestration. I will explain the specific lifecycle issues we encountered. I will detail the configuration changes that solved the dropout problem. This is not a guide on writing Dockerfiles. It is a record of the operational friction we faced when Java met Kubernetes. Building cloud-native Java apps requires more than just packaging a JAR. It requires understanding how the orchestration layer interacts with the JVM.

28 Apr 2026 4:00pm GMT

There is a specific kind of frustration reserved for Java developers who have just containerized their application. You spend hours optimizing your Spring Boot microservice, ensuring your logic is sound and that your tests pass. You wrap it in a Docker container, push it to the registry, and deploy. Then the reality sets in. Your image is 800MB, your startup time is 40 seconds, and during load testing, the container is killed silently by the OS.

In my recent work, migrating a monolithic Java application to a microservices architecture, we faced this exact triad of issues. We were treating Docker containers like lightweight virtual machines and ignoring the nuances of how the JVM interacts with container boundaries. The result was bloated infrastructure costs, slow CI/CD pipelines, and unstable production pods.

28 Apr 2026 2:00pm GMT

The Problem With How We're Sending Data to AI Models

Most Java applications that integrate with AI models do something like this:

String userInput = request.getParameter("topic");
String prompt = "Summarize the following topic for a financial analyst: " + userInput;

24 Apr 2026 8:00pm GMT

Imagine deploying a robust Spring Boot microservice that passes every integration test in your local Docker environment, only to watch it crash loop endlessly shortly after launching to your Kubernetes production cluster. Everything ran fine on your laptop, but in the live environment, your pods start terminating en masse. Requests to your critical endpoints begin failing with 503 errors. Panic sets in as your service, the backbone of your transaction pipeline, is effectively brought down by an invisible foe.

In our recent migration to a cloud-native architecture, the culprit was a hidden memory configuration issue involving how the Java Virtual Machine interacts with Kubernetes container limits. A tiny mismatch in resource allocation, something that went unnoticed during development, led to a chain reaction of OOMKilled events in production.

22 Apr 2026 2:00pm GMT

The outage happened during our biggest sales event of the year. Our order processing system ground to a halt. Customers could add items to their carts, but checkout failed repeatedly. The engineering team scrambled to check the logs. We found a chain of synchronous REST API calls that had collapsed under load. Service A called Service B, which called Service C. When Service C slowed down due to database locks, the latency rippled back up the chain. Service A timed out. Service B timed out. The entire order pipeline froze. We were losing revenue by the minute. This incident forced us to rethink our architecture. We realized that synchronous APIs were not suitable for every interaction. We needed to decouple our services. We needed an event-driven system.

In this article, I will share how we migrated from a tightly coupled API architecture to an event-driven design using Java and Kafka. I will explain the specific challenges we faced during the transition. I will detail the code changes required to handle asynchronous communication. This is not a theoretical discussion about microservices. It is a record of the practical steps we took to stabilize our platform. Building resilient backend systems requires more than just choosing the right tools. It requires understanding the trade-offs between consistency and availability.

20 Apr 2026 5:00pm GMT

Most developers don't have a problem writing code. They have a problem understanding the platform they are building on.

And that difference shows up later - in architectural decisions, debugging complexity, vendor lock-in, and, ultimately, career growth.

20 Apr 2026 3:30pm GMT

Training, exporting, and using a TensorFlow model is a great way to gain a low-level understanding of the building blocks of the LLMs fueling the AI revolution.

Since I am comfortable with using Java, I will use it to define a neural network (NN) model, train it, export it in a language-agnostic format, and then import it into a Spring Boot project. Now, doing all this from scratch would not be advisable, since there are many advances in the field of NN that would take a long time to properly understand and implementing them would be difficult and error-prone. So, to both learn about NNs and make implementation easy, we will use a proven software platform: TensorFlow.

17 Apr 2026 6:00pm GMT

Multithreading has always been one of core strengths of Java over years. From the early days of the JVM, Java was designed with built-in support for concurrent programming. But for many years, writing scalable multithreaded applications required careful tuning, thread pool management and constant attention to synchronization.

In the latest Java versions, the concurrency model has evolved significantly. Modern Java introduces improvements such as Virtual Threads, better executors, improved fork-join performance and more structured concurrency approaches. These features allow developers to build highly concurrent applications with simpler code and fewer scalability limitations.

17 Apr 2026 5:00pm GMT

The dashboard turned red at weekday. Our order processing API latency jumped from fifty milliseconds to five seconds. Customer support tickets flooded in. Users reported timeouts during checkout. The infrastructure team scaled up the Kubernetes pods, but the issue persisted. CPU usage sat at 100 percent across all nodes. We were throwing hardware at a software problem. This approach failed miserably.

In this article, I will share how we diagnosed the bottleneck. I will explain the profiling tools we used. I will detail the code changes that restored performance. This is not a theoretical guide. It is a record of a real production incident and the steps we took to resolve it.

16 Apr 2026 12:00pm GMT