fidzu : Java

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

Within the discipline of software engineering, practitioners are frequently encumbered by the monotonous ritual of initializing identical project scaffolds - configuring dependencies, establishing directory hierarchies, and reproducing boilerplate code prior to engaging in substantive problem‑solving. Although indispensable, such preliminary tasks are inherently repetitive, susceptible to human error, and inimical to efficiency.

Maven, a cornerstone of the Java build ecosystem, furnishes an elegant mechanism to mitigate this redundancy through the construct of archetypes. An archetype functions as a canonical blueprint, enabling the instantaneous generation of standardized project structures aligned with organizational conventions. By engineering bespoke archetypes, development teams can institutionalize consistency, accelerate delivery, and reallocate intellectual effort toward innovation rather than procedural repetition.

28 Nov 2025 3:00pm GMT

REST Assured is a popular API test automation framework in Java. Software teams widely use it for efficiently validating RESTful web services with minimal setup. It simplifies the process of sending requests, verifying responses, and handling JSON or XML paåyloads.

With its rich syntax and integration support for tools like TestNG and Maven, REST Assured enables robust, maintainable, and scalable API testing.

25 Nov 2025 4:00pm GMT

Retrieval-augmented generation (RAG) is quickly becoming one of the most powerful design patterns for AI applications. It bridges the gap between general-purpose large language models (LLMs) and your specific enterprise data. In this article, we'll walk through how to build a complete RAG pipeline in Java using Spring Boot, Vertex AI's Gemini embeddings, Apache PDFBox, and BigQuery Vector Search.

You will see how to do the following, wrapped in a Spring Boot app with a simple web UI:

24 Nov 2025 6:30pm GMT

One subtle challenge in software architecture is that architectural thinking can feel detached from the codebase. We draw diagrams, define layers, identify responsibilities, and craft a coherent structure - yet the moment implementation begins, those architectural ideas fade into the background. Over time, systems drift not because developers ignore design, but because the code itself provides almost no way to express that design.

This tension is well documented. In Just Enough Software Architecture, George Fairbanks argues that programming languages lack constructs for directly representing architectural concepts. Java lets us model types, fields, methods, and packages, but offers no native way to encode ideas such as "presentation layer," "domain logic," "aggregate root," or "infrastructure boundary." Without these cues in the code, architecture becomes optional, verbal, and fragile.

24 Nov 2025 3:30pm GMT

In a three-article series published recently on this site (Part 1, Part 2, Part 3), I've been demonstrating the power of the AWS Cloud Development Kit (CDK) in the Infrastructure as Code (IaC) area, especially when coupled with the ubiquitous Java and its supersonic/subatomic cloud-native stack: Quarkus.

While focusing on the CDK fundamentals in Java, like Stack and Construct, together with their Quarkus implementations, this series was a bit frugal as far as the infrastructure elements were concerned. Indeed, for the sake of clarity and simplification, the infrastructure used to illustrate how to use the CDK with Java and Quarkus was inherently consensual. Hence, the idea for a new series, of which this article is the first, is a series less concerned with CDK internals and more dedicated to the infrastructure itself.

18 Nov 2025 3:00pm GMT

Troubleshooting memory problems, such as memory leaks and OutOfMemoryError, can be an intimidating task even for experienced engineers. In this post, we would like to share simple tips, tools, and tricks so that even a novice engineer can isolate memory problems and resolve them quickly.

What Are Common Signs of a Java Memory Leak That Might Lead to OutOfMemoryError?

Before your application throws an OutOfMemoryError, it usually gives you a few warning signs. If you catch them early, you can prevent downtime and customer impact. Here's what you should keep an eye on:

18 Nov 2025 2:00pm GMT

In Spring, the ApplicationContext is the central container object that manages all beans (i.e., components, services, repositories, etc.).

Its tasks include reading the configuration (Java Config, XML, annotations), creating and managing bean instances, handling dependency injection, and running the application lifecycle.

13 Nov 2025 5:00pm GMT

It isn't seldom when software products need to easily and efficiently manage the direct storage and handling of JSON content directly into the underlying database. The purpose of this article is to exemplify how such tasks can be conveniently accomplished via the asentinel-orm, a lightweight ORM tool built on top of Spring JDBC, which possesses most of the features one would expect from such a project.

We will start by defining a simple entity that contains a JSONB column. Then, we will configure a sample application that uses the asentinel-orm to handle its data access towards a PostgreSQL database that stores such entities. Lastly, we will exemplify and emphasize how the actual JSON data can be queried and stored properly.

12 Nov 2025 5:00pm GMT

High-scale, real-time services live under unforgiving economics. Ad tech and similar platforms push millions of requests through Java web services, where a handful of milliseconds either unlock profitable throughput or sink margins under excess compute. Regressions in latency and resource usage rarely arrive with sirens; they slip in alongside routine refactors, dependency upgrades, or subtle shifts in traffic shape. What looks like a harmless tweak in a unit test can magnify into elevated CPU, long garbage collection pauses, or thread starvation once it meets production load. The work of debugging these regressions is less about isolated heroics and more about following a disciplined trail from symptoms to causes, correlating signals across the JVM, and validating fixes under real heat.

Industry-wide, the cost of performance regressions is notoriously high, though rarely measured with public precision. In environments like ad tech, where margins are directly tied to throughput and latency, even a minor, sustained performance degradation can translate to significant operational expense and lost revenue. Teams that adopt systematic debugging and profiling practices don't just resolve incidents faster; they build a culture of performance awareness that prevents regressions from being deployed in the first place. The resulting efficiency gains, often manifesting as reduced cloud spend or the ability to handle more traffic on the same hardware, directly improve the bottom line. This article examines how that discipline works in practice for Java services running on Tomcat.

11 Nov 2025 7:00pm GMT