A N M Bazlur Rahman on foojay.io - Friends Of OpenJDK

A Visual Diff of Java’s Evolution: Inside java.evolved

Fri, 20 Feb 2026 17:48:21 +0000

A community project called java.evolved was recently launched to document how common Java coding patterns have changed across releases. Instead of explaining features in isolation, the site presents “before and after” examples: traditional idioms next to modern alternatives.

The approach targets a practical problem. Most developers work in mixed-era codebases where Java 6, 8, and 17 styles coexist. Rather than memorizing new language features, the site shows what existing code would look like if written today.

Announcing: Sustainability for Java Developers

Mon, 02 Feb 2026 11:04:54 +0000

Java developers from around the world are writing a book about a question that’s becoming impossible to ignore: how do we write software that’s good for both our projects and the planet?

Sustainability for Java Developers: Towards an Understanding of Sustainable Java Software Development is now freely available on Leanpub, bringing together Java Champions, architects, and technical writers to look at sustainability from every angle.

The book covers everything from the environmental footprint of our data centers to the ethics of open source supply chains, from efficient data formats to the often-overlooked topic of career longevity.

AI Applications with LangChain4j Guardrails and Spring Boot

Tue, 29 Jul 2025 11:16:31 +0000

As AI applications become increasingly complex, ensuring that language models behave predictably and safely is paramount. LangChain4j’s guardrails feature provides a powerful framework for validating both the inputs and outputs of your AI services.

This article demonstrates how to implement comprehensive guardrails in a Spring Boot application, with practical examples that you can adapt to your use cases.

📦 Complete source code available at : github.com/rokon12/guardrails-demo

Understanding LangChain4j Guardrails

In LangChain4j, guardrails are validation mechanisms that operate exclusively on AI Services, the framework’s high-level abstraction for interacting with language models. Unlike simple validators, guardrails provide sophisticated control over the entire AI interaction lifecycle.

Java’s Structured Concurrency: Finally Finding Its Footing

Wed, 04 Jun 2025 12:21:07 +0000

The structured concurrency API changed again after two incubations and four rounds of previews.

Ideally, this scenario is unexpected.

However, given its status as a preview API, such changes can occur, as was the case here.

These changes lend considerable maturity to the API, and I am hopeful it will now stabilize without requiring further modifications.

What Actually Changed This Time

When I first started working with structured concurrency back in its incubation phase, I was excited about the promise of cleaner concurrent code.

Building FormPilot

Tue, 06 May 2025 10:00:04 +0000

Disclaimer: This article details an experimental project built for learning and demonstration purposes. The implementation described is not intended as production-grade solution. Some parts of the code were generated using JetBrains’ AI Agent, Junie.

Have you ever found yourself filling out the same information on web forms over and over again? Name, email, address, phone number… it’s tedious and time-consuming. As a developer who values efficiency, I decided to tackle this problem head-on by building FormPilot, an intelligent form filler that leverages the power of Large Language Models (LLMs) to fill out forms with contextually appropriate information automatically.

Enhancing LLM’s Conversations with Efficient Summarization

Mon, 03 Mar 2025 13:16:21 +0000

LLM chat models have become an integral part of many applications today. We are all experimenting and exploring the best ways to utilize them effectively. For Java developers, LangChain4j has been an incredible tool in this journey.

By design, most available APIs, such as ChatGPT and Gemini, operate in a fire-and-forget mode. They don’t retain previous interactions, meaning every request is treated as a completely new one.

However, for a smooth and engaging conversation, maintaining context is crucial—otherwise, the interaction becomes disjointed and frustrating. The common solution is to pass previous messages along with each new prompt, allowing the LLM to infer context. This is where the chat memory concept comes in.

Java Tips # 01 - Writing Shebang Scripts in Pure Java

Tue, 29 Oct 2024 17:06:37 +0000

Did you know you can write a CLI script in Java just as easily as you would in a bash script, and run it directly from the shell?

This is commonly called a shebang script, though we are mostly familiar with writing them in bash. Bash scripts are great, but they can be obscure to developers who aren’t familiar with the syntax. As a Java developer, you’d likely prefer to get things done the Java way. Well, since Java 11, you can do exactly that!

Interview with a Java Champion: Reflections on a Storied Career and Insights for the Next Generation

Mon, 19 Aug 2024 07:52:18 +0000

Introduction:

In the fast-paced world of software development, a few individuals leave a lasting impact through their dedication and contributions. Our guest today is a seasoned developer, a respected author, and a cornerstone of the Java community.

With over two decades of experience, he has played a key role in the evolution of Java from a niche language to a critical tool in various industries. In this interview, he shares his journey, insights, and advice for developers at all stages of their careers.

Creating a Command Line Tool with JBang and PicoCLI to Generate Release Notes

Wed, 24 Jul 2024 09:44:36 +0000

Lately, I have been playing with JBang and PicoCLI, and I am pretty amazed at what we can do with these tools. I needed to create a script that would go to a specified repository on GitHub, check the commit range, and verify if any tickets were associated with them. Additionally, I wanted to check if the ticket is accepted and if the commit was approved or not. The idea was to integrate this script along with the CI/CD pipeline.

Java's Unsafe is Finally Going Away

Thu, 11 Jul 2024 07:52:32 +0000

Java, being a safe language, doesn’t usually allow direct low-level access. Memory is primarily managed on the heap, so developers don’t typically deal with memory directly. However, library developers are occasionally required to manipulate memory outside the heap for performance or specific use cases. This is where the controversial sun.misc.Unsafe comes in.

While undeniably powerful, sun.misc.Unsafe is a double-edged sword. Its improper use can lead to severe consequences, including memory leaks, crashes due to invalid memory access, and even security vulnerabilities like buffer overflows. As the name suggests, it’s inherently unsafe.

Exploring New Features in JDK 23: Simplifying Java with Module Import Declarations with JEP 476

Thu, 20 Jun 2024 16:14:08 +0000

As Java evolves, simplifying code and improving developer productivity remain priorities.

JEP 476 introduces a new feature in JDK 23: Module Import Declarations.

This feature aims to streamline the process of importing multiple packages from a module, enhancing code readability and reducing boilerplate.

What is JEP 476?

JEP 476 proposes the ability to import all packages exported by a module with a single declaration. This is particularly useful for developers who frequently use multiple packages from the same module, as it eliminates the need for numerous individual import statements.

Exploring New Features in JDK 23: Simplifying Java with Primitive Type Patterns with JEP 455

Thu, 06 Jun 2024 10:37:33 +0000

Java continues to evolve, introducing features that streamline coding practices and improve readability. JEP 455 is one such proposal that enhances the switch statement, making it more versatile and expressive.

This article delves into how JEP 455 can be utilized to handle complex decision-making scenarios more efficiently. We’ll examine a practical example to illustrate the benefits of this feature.

What’s New in JEP 455?

This JEP introduces the following key features:

Records for Cleaner and More Expressive Parameterized Tests in JUnit 5

Wed, 03 Apr 2024 09:00:38 +0000

Introduction:

Parameterized testing in JUnit 5 is a potent technique for executing the same test logic with various inputs. While you can use a variety of data structures, such as custom classes, arrays, or collections, Java records offer a compelling advantage in readability, type safety, and expressiveness.

Let’s examine how to leverage Java records for parameterized tests through a concrete example – testing an expression evaluator.

The Expression Evaluator Scenario

Consider a simple expression evaluator capable of handling the following:

Journey of a Java Champion: Bert Jan Schrijver's Path to Mastery and Community Leadership

Wed, 10 Jan 2024 15:50:26 +0000

Bert Jan is CTO at OpenValue and focuses on Java, software architecture, Continuous Delivery and DevOps.

Bert Jan is a Java Champion, JavaOne Rock Star speaker, Duke’s Choice Award winner and leads NLJUG, the Dutch Java User Group.

He loves to share his experience by speaking at conferences, writing for the Dutch Java magazine and helping out Devoxx4Kids by teaching kids how to code. Bert Jan is easily reachable on Twitter at @bjschrijver.

Diagnose and Mitigate Pinning in Java's Virtual Thread Execution

Tue, 10 Oct 2023 09:08:10 +0000

In our last article, we highlighted the impressive performance gains achieved through the use of virtual threads. However, upon diving deeper into the code, we discovered an issue caused by the jsoup library: a phenomenon known as pinning. But before we delve into solutions, let’s take a moment to understand what pinning actually is.

What is Pinning?

In the context of virtual threads, pinning refers to the condition where a virtual thread is “stuck” to its carrier thread (the platform thread on which it runs).

Web Crawling in Java: Classical Threads and Virtual Threads

Fri, 29 Sep 2023 12:23:48 +0000

In today’s fast-paced digital world, web crawling is a cornerstone technology behind search engines, data analysis tools, and various other applications.

Java, a language known for its robustness and scalability, offers intriguing ways to implement web crawling.

Yet, the thread model you choose can make a world of difference.

This article unfolds a compelling narrative around web crawling in Java, contrasting classical threads with their newer counterpart: virtual threads.

Environment Setup

Before diving into the code and its intricate comparisons, ensure you have JDK 21 installed on your system. If you’re using a Unix-based system, SDKMAN! It makes this simple. Just open your terminal and run curl -s "https://get.sdkman.io" | bash to install SDKMAN!, followed by source "$HOME/.sdkman/bin/sdkman-init.sh" to initialize it. Finally, install JDK 21 with sdk install java 21.0.0-<vendor>, replacing <vendor> with your preferred vendor (e.g., zulu, adopt).

Exploring the Impact of Stack Size on JVM Thread Creation: A Myth Debunked

Wed, 20 Sep 2023 06:59:31 +0000

Among Java developers, a prevailing assumption is that the number of native threads that can be created within the Java Virtual Machine (JVM) is linked to the stack size. To scrutinize this widespread notion, an experiment was conducted. The results revealed that stack size plays a less significant role in native thread creation than previously thought.

The Experiment

The experiment utilized the following Java program, which continuously creates threads and counts them using an AtomicInteger.

A Look at Sealed Classes, Pattern Matching, Functional Paradigms

Mon, 11 Sep 2023 08:42:17 +0000

Introduction

The introduction of Sealed Classes in Java and the combination with pattern matching in switch statements has sparked a debate among software developers.

The argument in question raises concerns about the real-life use cases for Sealed Classes and suggests that pattern matching with switch might promote poor coding practices.

This article aims to counter these assertions by examining the principles and practical applications of Sealed Classes and pattern matching.

Unlocking Java Wisdom: A Conversation with Oracle ACE Simon Martinelli

Fri, 01 Sep 2023 16:00:01 +0000

In a recent insightful interview, Simon Martinelli, an Oracle ACE associate and veteran Java developer, shares his career experiences, software development philosophies, and views on mentoring. With over two decades in the industry, Martinelli offers a perspective that combines the wisdom of experience with a focus on simplicity and constant learning.

Profiles:

🌍 Homepage:martinelli.ch
👔 LinkedIn:Simon Martinelli on LinkedIn
🐦 Twitter:@simas_ch on Twitter
📦 GitHub:simasch on GitHub

Fun Fact:

Before starting my IT career, I was working as a traffic controller at Swiss Railways.

Testable Code: A Journey Through Consideration and Refactoring

Wed, 30 Aug 2023 06:47:47 +0000

In an ideal world, every piece of code we write would be easily testable, clearly understood, and perfectly maintainable. However, reality often presents us with complex problems and solutions that aren’t always straightforward. Writing testable code sometimes requires a thoughtful approach, deep consideration of the use cases, and even refactoring to ensure that the code is robust and fully tested.

The Challenge of Testing

Imagine a scenario where you need to create an Amazon S3 client based on different credential providers. At first glance, the implementation might seem simple. However, when it comes to writing unit tests for this code, challenges arise.

Exploring File Storage Solutions in Spring Boot

Wed, 23 Aug 2023 08:07:19 +0000

When building a web application, managing file uploads properly is a common requirement. After receiving, files can be stored in several places: in a file system, in a database or, more commonly, in a cloud storage service.

In this article, we will cover how to store files in a database using Spring Boot and discuss some alternatives.

Introduction

Recently, a fellow developer who I helped in past reached out to me on Slack seeking assistance with handling file uploads in a Spring Boot application. After providing some guidance, I decided to compile this article to assist others facing similar challenges.

Thread-Safe Counter in Java: A Comprehensive Guide

Thu, 17 Aug 2023 06:59:29 +0000

In this tutorial, we will explore the concept of thread safety in Java, specifically focusing on a simple counter.

We will start by understanding why a basic counter is not safe for multiple threads; then, we will progressively enhance its thread safety using different techniques such as synchronization, locks, Unsafe, VarHandle, and finally, AtomicInteger.

We will be referencing the code from this repository throughout the tutorial.

Before we dive into the different implementations, let’s define a Counter interface that all our counter classes will implement.

Sealed Interfaces & Pattern Matching: Java's Modern Capabilities

Wed, 09 Aug 2023 07:01:51 +0000

Sealed classes in Java are a new feature that provides a way to restrict the classes that can inherit from a superclass or extend an interface. This new language feature enhances the encapsulation and provides more control to developers over their codebase.

In this tutorial, we will explore sealed classes, how to use them to find all subclasses, and how to apply pattern matching in a practical context.

Let’s start with a basic interface definition named Shape.

Book Review: "OpenJDK Migration for Dummies"

Fri, 04 Aug 2023 09:02:46 +0000

The subject of Java licensing and OpenJDK migration is complex and vital to many software engineers. I am no different. It’s a topic often shrouded in legal jargon and technicalities, making it difficult to approach.

“OpenJDK Migration for Dummies” bySimon Ritter offers a fresh perspective, breaking down these challenges into digestible segments. (Get it for free here.)

[

](https://www.azul.com/openjdk-migration-for-dummies/)

The book directly speaks to my core expertise in Java, providing clarity and guidance.

Preparing for JDK 21: A Comprehensive Overview of Key Features and Enhancements

Wed, 02 Aug 2023 10:46:28 +0000

As we inch closer to the release of JDK 21 in September (next month!), it’s crucial to familiarize ourselves with the transformative features and improvements this version is poised to bring to the Java ecosystem.

Let’s embark on a comprehensive tour of the noteworthy changes and enhancements in JDK 21.

Revising the Balance of Serviceability and Performance with JEP 451

Let’s begin with JEP 451, “Prepare to Disallow the Dynamic Loading of Agents.” Graduating to Completed status in preparation for JDK 21, this proposal doesn’t ban the dynamic loading of agents into a running JVM outright. Instead, it issues warnings when such loading happens, preparing the terrain for a future JDK release that will disallow such loading by default.

Busting Myths, Building Futures: A Conversation with Cay Horstmann on Java and Machine Learning

Mon, 24 Jul 2023 15:12:00 +0000

In our ongoing series of interviews with the movers and shakers of the software world, we bring you a conversation with Cay Horstmann, a towering figure in the Java community and a respected academic and entrepreneur.

Known for his prolific contributions in the form of textbooks, online content, and courses, Cay has been instrumental in shaping the Java education landscape.

In this insightful conversation, he speaks about a range of topics, including the challenges and potential for Java in the realms of data science and machine learning, the current state of the software development industry, the impact of AI on developers, and his unique perspective on learning by practice with immediate feedback. He also shares some intriguing anecdotes from his journey in academia and the software industry.

Dive into the OpenJDK: Top 10 Reads on Foojay.io

Wed, 19 Jul 2023 07:45:04 +0000

Foojay.io is a community platform dedicated to the needs of Java developers (and beyond, e.g., Kotlin) who use OpenJDK and related technologies.

It serves as a central hub for sharing knowledge, resources, and tools related to Java and OpenJDK.

The platform offers a wide range of content, including articles, tutorials, and insights from industry experts and Java enthusiasts.

Whether you’re a seasoned developer or a beginner in the world of Java, Foojay.io provides valuable information and a supportive community to help you navigate and excel in your Java development journey.

Charting the Course of Java: An Insightful Conversation with Java Champion, Sebastian Daschner

Tue, 11 Jul 2023 15:34:09 +0000

In this insightful interview, renowned Java Champion, Oracle Developer Champion, and JavaOne Rockstar, Sebastian Daschner, shares his journey in the field of Java enterprise software development.

With a vast array of experience from being a self-employed consultant, trainer, and author to his contributions to the open-source community, Daschner provides a unique perspective on Java’s current state and future, especially in the enterprise context.

He delves into his strategies for balancing his varied roles, offers tips for aspiring developers, discusses the challenges in the software development industry, and underlines the importance of continuous learning.

The Evolution of Java: Challenging Stereotypes and Embracing Modernity

Fri, 07 Jul 2023 16:15:56 +0000

On a flight from Zurich to Toronto, I found myself in an engaging conversation with a fellow passenger. Among various topics, our conversation navigated toward our careers and, inevitably, as I am a Java developer, towards the world of Java.

This gentleman, having worked with Java some 15-20 years ago, was surprised to learn that I still actively use the language. “Isn’t it slow?” he questioned. His question echoed a stereotype that I have often encountered, one that has stuck to Java from its earlier days.

Exploring the Depths of Java: A Comprehensive Conversation with Jakob Jenkov, Part-II

Wed, 05 Jul 2023 16:21:30 +0000

Welcome back to the second installment of our in-depth conversation with Jakob Jenkov, a leading figure in the world of Java. If you joined us forPart I, you’ll recall the insightful discussions around the evolving landscape of Java and its continuous improvements. Today, we delve even deeper into the subject. Jakob will share his thoughts on the challenges of modern software development, the impacts of artificial intelligence on developers, and much more. Get ready for another fascinating exploration into the depths of Java with Jakob Jenkov!