Java on dplabs — Software Engineering & Technology Consultancy

Java Performance: Stop Guessing, Start Measuring

Mon, 23 Jun 2025 00:00:00 +0000

Most Java performance work starts in the wrong place. An engineer identifies “the application is slow,” forms a hypothesis based on code familiarity, and makes changes based on intuition. Sometimes it works. More often, the actual bottleneck was elsewhere and the optimized code is now more complex with no performance benefit.

The methodology matters: measure, identify the bottleneck, optimize, measure again. In that order. Not “optimize the thing that looks suspicious, then measure.”

Structured Concurrency in Java: Fixing Unstructured Concurrent Code

Mon, 28 Apr 2025 00:00:00 +0000

Java’s concurrency model has been functional for decades. ExecutorService, Future, CompletableFuture — these tools work. They also have a persistent problem: when you submit tasks to an executor, the relationship between the spawning thread and the spawned tasks is not represented in the code. Errors are easy to lose. Cancellation doesn’t propagate automatically. Resources leak when tasks outlive their intended scope.

Structured concurrency, finalized in Java 24 (JEP 505 after multiple preview rounds), fixes this. The core principle: concurrent tasks should have lifetimes that are scoped to the block of code that spawned them, just as try-with-resources scopes resource lifetimes.

Records and Sealed Classes: Better Domain Models in Java

Mon, 27 Jan 2025 00:00:00 +0000

Java domain modeling has historically been verbose and error-prone. Entity classes with dozens of getter/setter pairs, boolean fields that encode state (isActive, isCancelled, isPending), and null fields used to represent the absence of a value all create code that’s hard to understand and easy to misuse.

Records and sealed classes address this. They’re not cosmetic improvements — they change what kinds of mistakes the compiler can catch for you.

Records: Immutable Data Carriers

A record is a class defined by its components. The compiler generates the constructor, accessors, equals, hashCode, and toString automatically:

Pattern Matching in Modern Java: Records, Switch, and Exhaustiveness

Mon, 20 Jan 2025 00:00:00 +0000

Pattern matching in Java 21 is the culmination of several interconnected features: instanceof patterns (Java 16), sealed classes (Java 17), switch expressions (Java 14), and switch patterns (Java 21). Understanding them individually is useful. Understanding how they compose is where the real power is.

The Baseline: Pattern Matching for instanceof

Before Java 16, checking and casting looked like this:

Object shape = getShape();
if (shape instanceof Circle) {
    Circle c = (Circle) shape;  // Redundant cast
    return c.area();
} else if (shape instanceof Rectangle) {
    Rectangle r = (Rectangle) shape;
    return r.area();
}

Java 16 introduced pattern variables in instanceof:

Java 17 to 21: Modern Java Is a Different Language

Mon, 16 Dec 2024 00:00:00 +0000

Java 21 is the current long-term support release as of late 2024, and it represents something unusual: a Java that looks substantively different from Java 8. Not just faster or more convenient — different in how you model domains and reason about concurrency.

This article focuses on the features that arrived between Java 17 and Java 21 (covered separately) and the cohesive picture they form together.

Pattern Matching for Switch (Finalized Java 21)

Pattern matching for instanceof arrived in Java 16. Java 21 extended pattern matching to switch — and this is where the power becomes apparent.

Modern Spring Boot Architecture: Beyond the Three-Layer Application

Mon, 02 Dec 2024 00:00:00 +0000

The three-layer architecture — controllers, services, repositories — is how most Spring Boot tutorials present application structure. It’s a reasonable starting point. It’s also a pattern that breaks down as applications grow.

The problems are predictable: services become God classes with hundreds of methods, repository calls leak into controllers, domain logic spreads across multiple layers, and changing anything requires understanding the entire application at once. The layered architecture doesn’t enforce boundaries — it suggests them. Suggestions decay under deadline pressure.

Virtual Threads in Java 21: What They Solve and What They Don't

Mon, 04 Nov 2024 00:00:00 +0000

Virtual threads were the most anticipated Java feature in years. Project Loom’s promise was simple: write blocking code that scales like non-blocking code. Java 21 delivered them as a finalized, production-ready feature. They work. The caveats matter.

The Problem Virtual Threads Solve

Traditional Java concurrency has a fundamental constraint: platform threads are expensive. Each platform thread maps 1:1 to an OS thread. OS threads consume roughly 1MB of stack space by default and are expensive to create and context-switch.

Java 9 to 17: The Language Features You Should Actually Be Using

Mon, 07 Oct 2024 00:00:00 +0000

Java 8 was a turning point. Lambdas and streams changed the language substantially. Then came a long stretch where each release felt like maintenance work — modules in 9 were important but painful, and the subsequent releases improved the language incrementally without a clear headline.

That changed with Java 14–17. The features that landed in this window — records, sealed classes, pattern matching for instanceof, text blocks, switch expressions — are not conveniences. They change how you model domains and reason about code.