Core Java on JAVAPRO International

Are Classic Design Patterns Still Valid With Modern Java?

Thu, 23 Jul 2026 07:00:03 +0000

The classic GoF design patterns helped developers build maintainable object-oriented software for a long time. In the past years the languages, like Java, have changed a lot; they evolved! What was a design pattern back then became a language feature today. This article analyses which patterns are still needed and which became obsolete.

Once upon a time…

Object-Oriented Programming

Object-oriented programming emerged with the invention of Simula 67. Ole-Johan Dahl and Kristen Nygaard invented Simula 67 while working at the Norwegian Computing Center in Oslo to run simulations. A few years later Alan Kay et al. invented Smalltalk as a purely object-oriented programming language. In the 80s, C++ brought the breakthrough in the mainstream for object-oriented programming. The first large-scale object-oriented systems were developed. In the 90s, object-oriented programming was the dominating programming paradigm.

Lazy Constants in Java 26: Deferred Immutability and JVM Trust

Wed, 22 Jul 2026 07:00:02 +0000

Java developers have long lived with an awkward trade-off. If you want the clarity and optimization benefits of final, you must initialize eagerly, in a constructor or static initializer. If you want to defer expensive setup until first use, you usually fall back to mutable lazy-initialization patterns, nullable fields, or double-checked locking. Those techniques work, but they also make code harder to reason about and harder for the JVM to optimize.

UNDERSTANDING AOT

Tue, 21 Jul 2026 07:00:01 +0000

What is AOT?

Ahead-of-Time (AOT) compilation in Java is a crucial technique that translates Java bytecode into native machine code before the application is executed. In traditional Java execution, source code is compiled into bytecode that the Java Virtual Machine (JVM) loads and runs. By performing the translation to native code beforehand, AOT allows direct execution by the operating system, which eliminates the initial need for the JVM to interpret bytecode or wait for standard compilation paths during runtime. This proactive process significantly optimizes resource utilization right from the start.

Serverless Functions Reimagined with Java 25

Wed, 15 Jul 2026 07:00:02 +0000

Serverless computing whether on AWS Lambda, Azure Functions, or Google Cloud Functions plays a vital role in modern distributed systems. By abstracting infrastructure away from application code, serverless platforms allow developers to focus on business logic. These functions scale automatically and can be highly cost-efficient when applied to the right use cases.

In serverless platforms, applications may be started many times a day and often run only for a few seconds. They are scaled up and down automatically and may be paused or frozen between requests. This behavior does not only affect performance; it also directly impacts cost, since billing is often based on execution time and allocated memory.

The Foundations of Data-Oriented Programming in Java

Wed, 24 Jun 2026 07:00:01 +0000

Introduction

Java has traditionally been an object-oriented language, urging developers to structure code around objects, encapsulate state and behavior, hide implementation details, and extend functionality through inheritance. This method has advanced modularity and reusability. However, with recent enhancements, Java has evolved, revolutionizing how systems are developed and offering powerful tools for developers.

Have you ever been in the midst of debugging a complex Java application, only to find that the mutable state across various objects left you tangled in a web of unexpected behaviors and racing conditions? These frustrations are common among Java developers accustomed to Object-Oriented Programming (OOP), where mutable objects often lead to more complex, less predictable systems. Fortunately, with recent language enhancements, Java developers now have capable tools to treat data as a first-class citizen.

1BRC - The First 80% of the Journey

Tue, 23 Jun 2026 07:00:02 +0000

The One Billion Row Challenge (1BRC) started as a way to kill time during the 2023/2024 holidays, asking a simple question: How fast can Java crunch temperature values from a text file and calculate the min, mean, and max per weather station? The catch is that the file contains one billion rows, totaling approximately 13.8 GB.

Thomas Wuerthinger, Quan Anh Mai, and Alfonso Peterssen achieved the best result of 1.5 seconds on 8 cores. That was insanely and unexpectedly fast. But when you take a closer look at the code, you will see that it is beyond your daily dose of Java. It is a complex, single-use-case-oriented implementation, skipping safety features, and most of the tunings applied cannot be easily reused.

Structured Concurrency in Java 26 (JEP 525 Deep Dive)

Tue, 09 Jun 2026 07:00:01 +0000

The Java 26 Evolution of Safer, Predictable Multi-threading

Java has long provided powerful concurrency primitives. Threads, executors, futures, and more recently virtual threads allow applications to scale across cores and I/O boundaries. Yet many production failures are not caused by insufficient parallelism, but by insufficient structure.

Tasks outlive the operations that spawned them. Failures are detected but not propagated consistently. Interrupts are delivered but not observed in time. Thread dumps reveal activity, but not ownership or intent.

Virtual Threads Meet AI: Java Concurrency in the Age of Intelligent Systems

Tue, 02 Jun 2026 07:00:00 +0000

AI workloads change how Java applications scale and behave. This article explains how Java 26 and virtual threads simplify concurrency in AI-heavy systems, replacing complex reactive setups with clearer and more efficient designs. It shows when virtual threads outperform traditional async models and how concurrency choices impact system architecture.

Introduction: Java, AI, and the New Concurrency

The rapid growth of AI-driven systems is reshaping how we design and scale Java APIs. RAG systems, LLM inference, and recommendation pipelines bring thousands of simultaneous requests with heavy network I/O, vector databases, and external services.

JCON EUROPE 2026: Why the Java Community Still Meets in Person

Mon, 01 Jun 2026 07:00:00 +0000

Every year, when we start planning JCON EUROPE, one question always guides us:

How do we create a conference that developers genuinely enjoy attending?

Not just another event with slides and sponsor booths. Not a place where people passively consume information and leave. We wanted to create an environment where developers actively connect, discuss, challenge ideas, and solve real-world problems together.

Looking back at JCON EUROPE 2026, I believe this spirit was visible everywhere.

Unlocking Developer Productivity with Java 25: Features You’ll Actually Use

Thu, 28 May 2026 07:00:02 +0000

Summary

Java 25 features for developers bring practical enhancements you can use daily. From improved switch expressions and record patterns to simplified error handling, these Java 25 features reduce boilerplate, improve clarity, and simplify your code. Discover practical, real-world examples you can drop directly into your codebase.

Introduction: A Java Release that makes a difference

For many developers, Java release cycles blur together. Each version arrives with a list of JEPs, often full of improvements that, while important for the platform, they don’t immediately translate into productivity gains for everyday coding.

Destructoring is the future of Javas Encapsulation

Tue, 26 May 2026 07:00:00 +0000

Encapsulation in Java has been broken since the Java Development Kit (JDK) 5. Objects should guarantee that their inner state matches what we cast into code, but at runtime any private and final state can be set from the outside to any value — bypassing any checks and asserts. This is possible through the Reflection Api, which allows to setAccessible any private field and then set the value of any final field. This specific use of the Reflection Api to mutate an immutable final field is called deep reflection.

Open-Core with Core Java and Vaadin — Part 2

Sat, 23 May 2026 11:33:42 +0000

Editions, runtime, and quality assurance.

All source code presented here is published on GitHub and available at https://3g3.eu/naityh.

Recap of part one

The first part of this article developed the abstract mechanics of the open-core application. From two independent Maven projects with strictly asymmetric dependency direction, a deliberately slim extension API with the contribution types RouteContribution, MenuContribution, NavbarContribution, and CounterEventListener, a FeatureRegistry that discovers its contributions via the Java standard library’s ServiceLoader, and a Vaadin integration consisting of MainLayout and OpenCoreRouteInitializer, an apparatus is now in place that can accept arbitrary contributions in ordered form, without the core needing to know their identity.

Open-Core with Core Java and Vaadin — Part 1

Fri, 22 May 2026 11:33:04 +0000

Architecture, extension API, and Vaadin integration.

1. Introduction and motivation

The open-core model is often reduced in discussion to questions of licensing or commercial positioning. An open-source variant of a piece of software is complemented by a commercially distributed variant that brings additional features. Anyone who actually wants to implement such a separation in an existing codebase quickly discovers that the real difficulty lies neither in the licence text nor in the choice of repository, but in the code’s architecture.

OpenJ9 GC Policies: How to Choose the Right Collector

Thu, 21 May 2026 07:00:02 +0000

For many OpenJ9 users, garbage collection tuning starts with the wrong question.

They ask, “Which collector is the fastest?” or “Which one is best for cloud?” In practice, the better question is: what does my application actually need from the heap?

That is the right starting point because OpenJ9 gives you several distinct GC policies, each designed around a different balance of throughput, pause time, heap geometry, and operational behavior. The default is gencon, and for a broad spectrum of Java applications that is still the right place to start. But once heaps grow, pause spikes become operationally expensive, or throughput becomes the dominant goal, a different policy may be the better fit.

Java 26 in Practice: How the JVM Is Changing the Way We Write Code

Wed, 06 May 2026 07:00:02 +0000

Java 26 in practice shows a fundamental shift in how modern Java systems are built. Virtual threads, modern GC, AOT caching, and the Vector API are shifting long-standing responsibilities from the application into the JVM — forcing developers to rethink everyday design decisions.

Introduction

Java 26 in practice changes how we think about new Java features. When we think about new Java, we usually look first at syntax. Pattern matching, records, new JDK APIs grab attention. With Java 26 in practice, however, the most profound impact is different. It is not in language constructs.

Final Is No Longer a Hint in Java 26

Wed, 29 Apr 2026 07:00:02 +0000

Java 26 (JEP 500) warns when code mutates final fields via deep reflection and introduces explicit controls to scope or deny that behavior. This article breaks down what changes, why it matters for JIT optimizations, and a migration loop you can put into CI.

JEP 500 and the Performance Runway Behind Final Means Final

For years, Java has carried a quiet contradiction: the language treats final fields as immutable after initialization, but deep reflection could still mutate them. That single escape hatch forces the JVM to be conservative about both correctness and optimization, because a final value might not actually be final.

Pattern Matching in Java 25: Writing Cleaner, Safer, Faster Code

Tue, 28 Apr 2026 07:00:02 +0000

Summary

Java Pattern Matching Updates in Java 25 make pattern matching a core tool in your developer toolbox. This article walks through the latest improvements, including record patterns, guarded patterns, and deconstruction in switch statements. Through practical examples, you’ll learn how to refactor old verbose code into concise, expressive logic with safety and proper type control at every step.

Introduction: Pattern Matching Has Grown Up

Java Pattern Matching Updates in Java 25 bring a major shift in how developers handle type checks, record deconstruction, and switch statements. These updates make code more concise, type-safe, and easier to maintain.

Java 26 Is Boring

Fri, 17 Apr 2026 07:00:03 +0000

Which Is Why It Is Brilliant

When people hear “boring tech”, they usually mean old, slow, or not innovative. But in production, boring implies something very different. Boring means predictable, with no surprises. Boring means your system still works at 3 a.m. when nobody wants to debug a memory leak. And boring also means that you can understand your system years after you wrote it.

Many platforms try to impress developers with significant changes, shiny rewrites, or breaking updates. Java took another path. Java optimizes for trust.

A Big Screen Experience for Java Developers & Architects

Wed, 08 Apr 2026 12:00:02 +0000

JCON EUROPE 2026 | April 20–23, 2026 | Cinedom Cologne

Anyone talking about modern software development today can hardly avoid Java. Few technologies have shaped the enterprise world as sustainably, and few communities are as vibrant, diverse, and innovation-driven. This is exactly where JCON comes in: as a meeting point, a platform, and an experiential space for developers from all over the world. With participants from more than 70 countries, JCON has long since become an international gathering. Openness, knowledge sharing, and a strong sense of community remain at its core.

Architect Your Own Experience: Creating Your Individual JCON 2026 Journey

Tue, 31 Mar 2026 12:00:03 +0000

The JCON EUROPE 2026, taking place from April 20 to 23 at the Cinedom Multiplex Cinema in Cologne, consistently focuses on a format that offers participants maximum flexibility. Instead of a fixed schedule, the individual design of one’s own conference experience takes center stage.

With a wide range of sessions, formats, and networking opportunities, visitors can decide for themselves which content, conversations, and contacts they want to focus on.

The central foundation for this is the JCON Schedule: participants can create their personal agenda, bookmark relevant sessions, and organize targeted 1:1 meetings with speakers or exhibitors. This turns the conference into something that is not just consumed, but actively shaped—depending on individual interests, projects, and professional priorities.

Effective Pattern Matching 2026 Edition

Tue, 24 Mar 2026 16:58:41 +0000

Since Java 14, the Java switch and instanceof statements have been enhanced, in multiple phases, to support pattern matching and a “data-oriented” programming style. In this article, I explore when this programming style is beneficial, and why. I describe the syntax of pattern matching, as it has evolved, and show how it will be further enhanced in upcoming versions of Java. I warn of corner cases of the switch syntax where modern usage clashes with legacy behavior. I conclude with a set of rules when to use pattern matching and “data orientation” now, how to prepare for future enhancements, and when to stay away.

Java 26 + Spring Boot 4: From Certification Skills to Production-Ready Apps

Fri, 13 Mar 2026 07:00:00 +0000

Most Spring developers don’t fail in production because they forgot an annotation. They fail because the “non-feature” parts of the system were treated as optional: observability that comes too late, security added at the end, data access built under deadline pressure, APIs that can’t evolve without breaking clients, tests that don’t protect upgrades. This article argues that Spring certification

Java 25 and the New Age of Performance: Virtual Threads and Beyond

Thu, 05 Mar 2026 07:00:01 +0000

Summary

Project Loom continues to reshape how we handle concurrency in the JVM, and Java 25 makes virtual threads more accessible to developers than ever. In this article, we’ll take a closer look at how virtual threads work, how they differ from platform threads, and where they provide the most benefit in real-world applications. We’ll also include performance benchmarks and a step-by-step guide for refactoring blocking I/O services to use virtual threads.

Java 25: The tl;dr Version

Thu, 26 Feb 2026 07:00:01 +0000

Here’s a quick, no-fluff rundown of the new features landing in Java 25.

WP-BLOCK-VERSE

JDK 25 packs 18 new features: 12 delivered, 4 in preview, 1 experimental, and 1 incubator. In this article, we’ll walk through all of them, show live code examples you can run immediately, and highlight 🪄 the most impactful piece inside the code.

Finalized Features

JEP 503: Remove the 32-bit x86 Port

CODE

# Java won’t work at all if you are on a 32-bit x86 OS
# This command will produce errors
java -version

The official removal of the 32-bit x86 architecture support from the OpenJDK HotSpot JVM:

Java's Productivity Trifecta: Compact Sources, Flexible Constructors, and Advanced Pattern Matching

Tue, 24 Feb 2026 07:00:01 +0000

Java 25 is here, offering increased productivity through three features that are set to transform how we write Java applications. These include Compact Source Files and Instance Main Methods, which eliminate the boilerplate that has confused many Java beginners for decades. Now, Java developers can write streamlined, single-file programs. Flexible Constructor Bodies liberate constructors from the 30-year-old restriction of placing super() or this() first, enabling more natural initialization logic. Meanwhile, Advanced Pattern Matching brings a superpower to switch expressions, which in turn makes it a very elegant, data-oriented programming approach.

Virtual Threads, Structured Concurrency and Scoped Values: Putting it all together

Thu, 19 Feb 2026 07:00:01 +0000

In this article we are going to discuss Virtual Threads, Structured Concurrency and Scoped Values, the three main features of Project Loom and see how we can put them all together, in a web application. We will create a Spring Boot application and then add these features one by one to see how these features fit together nicely enabling us to write readable concurrent programs.

What is Project Loom?

Project Loom is one of the most important projects at Open JDK. The purpose of Project Loom is to provide high throughput, lightweight concurrency, which is also easy to use. It does so by providing three features: virtual threads, structured concurrency and scoped values. Virtual threads are lightweight, high-throughput threads that scale effortlessly. Structured concurrency is a streamlined approach to managing concurrent tasks as a single unit of work and scoped values are a modern alternative to ThreadLocal, designed for virtual threads.

the runtime illusion: what Java really runs

Wed, 18 Feb 2026 07:00:02 +0000

Introduction

Java’s bytecode is made abstract to be portable and neutral from specific hardware. Yet in production, it performs with the precision of native code. How? The secret lies in the JIT compiler, a near magical blend of static analysis and real-time insights. It reinterprets, restructures and often reinvents the code based on the runtime behaviour. This article traces that silent transformation using the Semeru (OpenJ9) JIT, following a method from source to bytecode to intermediate representation and ultimately to highly optimised machine code. You will be amazed to see how your logic is optimized beyond recognition. What you write is not always what runs, and what runs is often much better version of what you imagined.

PEM files as an alternative to keystores

Tue, 17 Feb 2026 07:00:02 +0000

JDK 25 introduces the preview of JEP 470 - PEM encodings of cryptographic objects. The JEP introduces new classes and methods to handle keys and certificates stored in so-called PEM files. It was possible to load / store files in this format before this JEP, but the handling was far from easy. This JEP simplifies the handling of and allows programmers to easily work with the widely used PEM file format in their applications.

Here's Java 25, Ready to Perform to the Limit

Thu, 12 Feb 2026 07:00:01 +0000

It’s been six months since Java 24 was released, so it’s time for a fresh set of new Java features. And the feature that immediately grabs the attention this time is stable values, taking Java’s support of immutability to the next level. Also, Java’s focus on improving performance intensifies, as more JEPs emerge from Project Leyden. On top of that, the Java Flight Recorder is now more equipped than ever to tackle performance issues!

Mastering Memory Efficiency with Compact Object Headers in JDK 25

Tue, 10 Feb 2026 07:00:01 +0000

Compact Object Headers are introduced in JDK 25 through JEP 519, marking a significant step forward for memory optimization in the JVM. First introduced experimentally in JEP 450 with JDK 24, this feature, authored by Roman Kennke, reduces the per-object memory footprint without slowing down performance.

The payoff is especially clear in object-heavy workloads and memory-constrained environments, such as those found in containers and cloud-native deployments.

In JDK 25, Compact Object Headers graduate from experimental to standard. However, they’re not enabled by default. Developers must turn them on using JVM flags to see the benefits.

The Open Source, Deterministic Engine Maintaining Java’s Next 30 Years

Wed, 04 Feb 2026 07:00:01 +0000

Java is entering its fourth decade as one of the world’s most important programming languages. From banks to telecom to retail, Java still powers systems that billions of people depend on daily. The language’s stability and portability are legendary, but so is the technical debt that has accumulated over thirty years of upgrades, frameworks, and shifting best practices.

Large enterprises often face sprawling portfolios of hundreds or even thousands of Java applications, many built atop older frameworks and outdated APIs. Banks still rely on Java 8 systems to process trades. Healthcare systems depend on decade-old Spring applications. Telecom providers run on Java servers written before cloud-native architectures became the norm.

JCON Meets Enterprise AI - From Basics to Production

Thu, 29 Jan 2026 12:00:01 +0000

From April 20–23, 2026, the European Java community will once again gather in Cologne for JCON EUROPE 2026. Taking place at the Cinedom multiplex cinema, the conference brings together developers, architects, and Java enthusiasts for four days of knowledge sharing, inspiration, and real-world experience — all on the big screen.

Under the motto “Big screen. Big community. Big AI.”, JCON EUROPE 2026 offers an in-person program running daily from 9:00 to 18:00 (CEST), combining technical depth with a strong community focus.

How To Do Structured Concurrency in Java 25

Wed, 28 Jan 2026 07:00:02 +0000

It was a Friday night and we’d gone out for some drinks with a few colleagues. We ended up at one of those places where the drinks aren’t listed on the menu, so when the waiter asked us what drink we wanted we just asked if he could list a few. He was being very thorough, because he started listing all the options, and by the time he got to the 25th item some of us were like: “What was the first option again?” 🙈 We could tell he was trying to be patient, but his list recital had been for nothing and he couldn’t completely hide his disappointment. Concurrent programming with Java can sometimes be exactly like that. When you configure a few threads to do work in parallel, some of the work you let them do could potentially be for nothing. Java 25 previews a feature called ‘structured concurrency’, allowing you to prevent unnecessary work like this.

What I (Still) Miss: My Most Wanted Java Features

Tue, 27 Jan 2026 07:00:01 +0000

Overview

Java, the grandfather of JVM languages, continues to evolve and is becoming richer in features with each update, thus steadily improving the productivity of developers. In parallel with this evolution, other languages have popped up with their own sets of features (and often with more freedom to experiment than Java). Some of these features have made their way into Java, others will be added eventually, and others may continue to be debated for quite some time.
This article is written from the perspective of a Java programmer (and teacher) who also writes plenty of Scala (and a few other languages). Through code examples, it discusses a few of the features I miss the most when returning to Java, namely inferred semicolons, tuples, named arguments, local functions, tail-recursion optimization, type aliases, opaque types, and variance annotations.

25 Versions in 30 Years: A Brief History of the Java Language

Tue, 20 Jan 2026 07:00:01 +0000

In an interesting alignment of events, the twenty-fifth version of Java, JDK 25, is being released in 2025, which also happens to be the 30^(th) anniversary of the platform’s launch.

This seems like an opportune time to have a look back at how the Java language has evolved and what new features are included in this latest release.

The launch of Java officially happened on May 23^(rd), 1995. As we all know, Java’s popularity took off and, even today, continues to be one of the three most popular programming languages.

Java 25: JEP 512, JBang, Notebooks, GraallPy and Raspberry Pi for Interactive Learning

Thu, 15 Jan 2026 07:00:03 +0000

When most people think of Java, their minds jump immediately to enterprise software, Android applications, or large back-end systems that power banking, insurance, and healthcare platforms. Rarely does Java come up in the context of exploratory learning, lightweight experimentation, or interactive notebooks that data scientists and educators love to use.

The world of programming education is rapidly evolving, with tools that prioritize interactivity, accessibility, and hands-on experience gaining prominence. JEP 512, JBang, Jupyter Notebooks, GraalPy, and the Raspberry Pi form a dynamic ecosystem that empowers students, educators, and hobbyists to explore programming concepts in an engaging and practical way. Together, these technologies bridge the gap between software and hardware, making them ideal for learning Java and hardware programming on a budget-friendly platform like the Raspberry Pi. This article explores how these tools converge to create an innovative environment for interactive learning, fostering creativity and problem-solving in educational settings.

LEARNING Java Automation the SOLID Way: A Beginners Guide to Learn Page Object Model with Java SOLID principles

Tue, 06 Jan 2026 07:00:03 +0000

Introduction:

Java is one of the most popular programming languages in the test automation field. A solid grasp of core Java concepts provides a foundation for building robust and maintainable automated tests. This article will explore how key Java programming concepts — including Object-Oriented Programming (OOP) principles (inheritance, polymorphism, abstraction, encapsulation) directly support tasks in software automation. We will see how Java SOLID principles are beginner’s footprints for learning test automation through Page Object Model (POM).

Security in the Age of Java 25: New Language Tools for Safer Code

Tue, 30 Dec 2025 07:00:03 +0000

Security is more than just encryption - it’s also about how you write code. There are several Java security features that can help prevent logic bugs, misuse of types, and unexpected state mutations. Learn how sealed classes, pattern matching, and records can reinforce domain modeling, reduce null checks, and prevent injection-prone scenarios.

Introduction: Why Java security features Matters More Than Ever

Application security has never been a static field. Over the past two decades, the Java platform has evolved not just as a runtime for enterprise applications but as a trusted foundation for industries ranging from finance and healthcare to government systems. Security breaches, once attributed primarily to poor encryption or missing authentication, now more often stem from subtler flaws: unchecked input, leaky abstractions, and poorly modeled domain logic.

Code. Collaboration. Community.

Wed, 24 Dec 2025 07:00:02 +0000

JCON USA @ IBM TechXchange 2025 – where the spirit of Java found a new home in Orlando.

When the JCON team announced they were bringing their renowned Java conference series across the Atlantic, expectations were high. Known for its lively spirit and deep technical content, JCON Europe has become a must-attend event for Java developers. Its first U.S. edition – JCON USA @ IBM TechXchange 2025 – not only met those expectations but exceeded them, uniting Java professionals from around the world under one roof in Orlando.

Java 25: Getting the Most Out of Virtual Threads with Structured Task Scopes and Scoped Values

Tue, 23 Dec 2025 07:00:01 +0000

With Java 21, the Java platform completely reinvented how threads work by introducing virtual threads alongside traditional platform threads.
Virtual threads let us create millions of concurrent tasks without worrying about creation time or memory usage. This makes it possible to handle vastly more requests than before, but it doesn’t solve every problem that once led developers to reactive programming.

In this article, we’ll explore how StructuredTaskScope and ScopedValue, two powerful features that complement virtual threads, help us write safer, faster, and more maintainable concurrent code.

Behind the Bytecode: Exploring Java Features with javap tool

Thu, 27 Nov 2025 07:00:01 +0000

When we develop applications, we often rely on a robust set of tools that the language’s development environment provides, which saves us from reinventing the wheel. In the case of Java also, the⁣ Java Development Kit (JDK) plays a vital role. It offers a comprehensive suite of tools, utilities, and commands that simplify the process of building, testing, and running Java applications, making our development faster and more efficient.

As a Java developer, I’m always fascinated by what happens behind the scenes when we compile my code into bytecode. This bytecode reveals how we represent and manage our code internally through the different components of the⁣ Java Virtual Machine (JVM). Exploring this process offers us deeper insights into Java’s architecture and helps us better understand memory management, performance, and runtime behavior.

Best Practices for Writing Clean Code in Java

Tue, 25 Nov 2025 07:00:01 +0000

Introduction

Writing clean, maintainable code isn’t just a good idea; it’s a non-negotiable imperative for any professional Java developer. In today’s complex software landscape, code gets read far more often than it’s written. Clean code isn’t merely about functionality; it’s fundamentally about readability, simplicity, efficiency, and adaptability. Whether you’re contributing to an open-source project, developing a critical enterprise application, or collaborating within a large team, clean code ensures your work is not only easy to understand but also readily extensible and modifiable for everyone involved.

Java Streams Evolution: From Java 8 to Today

Thu, 13 Nov 2025 07:00:02 +0000

The Java Streams evolution, starting from Java 8, has significantly transformed how we process data collections with a clean, declarative style. What began as straightforward map, filter, and reduce operations has expanded into sophisticated stream pipelines and advanced features like Gatherers. Gaining a solid grasp of this evolution empowers you to write more elegant and efficient Java code.

This article takes you through the journey of Java Streams, tracing their development from Java 8 to the present. Along the way, we’ll highlight important enhancements, practical use cases, and best practices to help you leverage Streams to their fullest potential.

Writing Readable Code with Algebraic Data Types and Pattern Matching in Java

Tue, 11 Nov 2025 07:00:01 +0000

Writing readable code is essential for the maintainability of any application. There are many techniques we can use to be able to write readable code. This article discusses one such technique that uses Algebraic Data Types and Pattern Matching, a few of the important features from Project Amber [1]. We will first discuss what Algebraic Data Types are, and then we will discuss some Pattern Matching features from Java. Finally, we will see an example where we can use them to write readable code.

Async IO with Java and Panama: Unlocking the Power of IO_uring

Thu, 16 Oct 2025 07:00:03 +0000

When I first started exploring Virtual Threads in Java, I wanted to understand everything about them—their yielding behavior,
performance characteristics, and limitations. This journey led me to an interesting challenge: file I/O operations cause
Virtual Threads to become “pinned” to platform threads, limiting their effectiveness for I/O-heavy applications.

This pinning issue has been widely acknowledged across the Java community. It’s mentioned in the Virtual Threads JEP,
discussed on Reddit threads, debated on mailing lists,
and highlighted in the “State of Loom”. The consistent message: File I/O and Virtual Threads don’t play nicely together.

TRANSFORMING POJOS AND JAVA RECORDS WITH FROPOREC: DEEP IMMUTABILITY AND BEYOND

Tue, 07 Oct 2025 07:00:02 +0000

Java has been evolving, with major improvements over the years, especially in the area of data handling. One of the latest advancements, introduced in Java 14, is the Record class, a special type of class aimed at reducing boilerplate code for immutable data carriers. While records offer many advantages, they come with certain limitations, especially regarding immutability and extensibility. Froporec, a Java annotation processor, offers a robust solution to these issues by simplifying the migration from POJOs (Plain Old Java Objects) to records while also providing deep immutability and the ability to extend records in ways Java doesn’t natively support.

State management explained

Wed, 24 Sep 2025 07:00:03 +0000

State causes a lot of complexity, is the main source of (weird) bugs and introduces high cognitive load to software engineers so it is important to handle it with care. In this article we go into the problems of (mutable) state, how and when to use mutable and immutable state, and how we can use our type system to prevent us from making mistakes.

Why State Management Matters

Most bugs out there are in one way related to state. Some examples are things like race conditions, null pointer exceptions and inconsistent behavior. And let’s not forget the famous quote “Have you tried turning it off and on again” that seems to fix most problems. This tends to work because resetting the device or software causes it to start with a new fresh state. Mutable state can also cause headaches when doing concurrent programming, but because most developers do not write multi-threaded software on a day to day basis, let’s focus for now on problems that are always present: complexity and high cognitive load.

Navigating the Waves of Concurrency: Exploring Jakarta Concurrency

Tue, 02 Sep 2025 07:00:02 +0000

“In a concurrent world, imperative is the wrong default!”

In the vast ocean of software development, concurrency stands as a formidable wave to be mastered. With the ever-increasing demand for high-performance, scalable applications, understanding and effectively implementing concurrency becomes crucial. Among the many tools and frameworks available, Jakarta Concurrency shines as a beacon, offering developers a robust set of tools to navigate the complexities of concurrent programming in Java. In this blog post, we’ll explore Jakarta Concurrency through practical code examples, demonstrating its key features and best practices.

Java 24: A Story of Code, Conflict, and Conquer

Wed, 27 Aug 2025 07:00:03 +0000

In a digital world far away from here, runs a Java application without problems. The logs are quiet, the servers are stable, and Emma and her team live in peace. But then, the first attack arrives! First innocent. A little spike in the memory use. But than another, and another. Within a couple of days, it turns into a disaster. Garbage collectors are going wild. The latency rises. The servers are shaking. The memory realm is flooded by invisible enemies: unnecessarily inflated object headers. They hide in every object, wasting valuable bytes and creating chaos in the heap.

Crafting Nimble Java: Strategies for Optimal Performance and Agility

Fri, 15 Aug 2025 07:00:02 +0000

“Who says you cannot be Big and Nimble?”

Numerous online enterprises rely on application servers, with platforms like Liberty and JBoss being prominent examples, all leveraging Java technology. Java presents users with many advantages, including a comprehensive class library, impressive throughput performance, robust debugging and tooling features, and additional benefits.

A typical JVM execution begins with class loading and initialization, followed by initial interpretation of methods until they are compiled by the Just-In-Time (JIT) compiler into machine code. The outcome? Lengthier start-up times and an initial phase of increased memory usage as the system ramps up. In this blog post, we will discuss some of the key strategies to make a nimble Java.