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!

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

Thu, 29 Jun 2023 13:33:58 +0000

Welcome to the first part of our deep dive with Jakob Jenkov, a seasoned software developer and AWS solution architect, whose love for coding began with a Commodore 128 in the late ’80s. Over the past decades, Jenkov has navigated the world of programming, with a particular emphasis on Java, making significant contributions to the community through his professional work and informative content on jenkov.com.

In this exclusive interview, Jenkov shares his career journey, his thoughts on the evolving landscape of Java, and how his interest in both low-level and high-level programming intersects in his current role. His unique insights into the future of Java and its significance in today’s increasingly diverse computing environments provide a captivating read for both Java enthusiasts and the broader software development community.

Exploring Java 21's Intriguing Additions (Part 1)

Tue, 20 Jun 2023 13:40:21 +0000

Introduction:

Java 21 is going to introduce several intriguing additions that enhance the language’s capabilities.

This article aims to discuss a few notable features that stand out, providing an overview of their functionalities and potential use cases.

Character Enhancements:

Character.isEmoji(int codePoint): This method determines whether a character is considered an emoji based on its Unicode properties defined in Unicode Emoji (Unicode Emoji Technical Standard #51 ). For example, executing Character.isEmoji(9203) would return true for the character ⏳, which has the code point 9203.
Character.isEmojiPresentation(int codePoint): Similar to isEmoji(), this method checks if a character has the Emoji Presentation property. It helps identify characters that display as emojis when rendered.

Example:

Breaking the Code: How Chris Newland is Changing the Game in JVM Performance!

Mon, 12 Jun 2023 08:44:27 +0000

We’re excited to introduce you to Chris Newland, an industry veteran and dedicated JVM performance specialist.

Chris has a long-standing history of contributing to the Java community with open-source tools aimed at enhancing Java and JVM understanding.

Among his well-known tools is JITWatch, which has gained significant recognition and use in the JVM community.

In this conversation, we delve into Chris’s journey, his motivations, and his thoughts on JVM performance, Java ecosystem changes, and the role of AI in software development.

Cracking Code and Conventions: An Exclusive Interview with Nicolas Fränkel

Mon, 05 Jun 2023 11:06:00 +0000

In this enlightening interview, we explore the unique journey of Nicolas Fränkel, a seasoned professional in the software industry. From an architecture student to a passionate software developer, Nicolas shares his candid thoughts about the current state of software development and the potential impacts of AI.

Profile:

🧑‍💼LinkedIn:Nicolas Fränkel – Head of Developer Experience – API7.ai
🐦Twitter:@nicolas_frankel
👨‍💻GitHub:nfrankel (Nicolas Fränkel)
📝Blog:Nicolas Fränkel - A Java geek
📚Medium:Nicolas Fränkel
💡Hashnode:Nicolas Fränkel

Bazlur: Can you tell us about your background and how you got started in the software industry?

Resilience in Coding: Miro Wengner on Thriving in the Software Industry

Wed, 31 May 2023 16:24:55 +0000

In this insightful discussion, we sit down with Miro Wengner, an accomplished software engineer with a deep-rooted affinity for Java. Miro shares his professional journey, highlights the significant challenges in the field, and reflects on the key moments that shaped his career.

Profile

🐦 Twitter: https://twitter.com/miragemiko
👔 LinkedIn: https://www.linkedin.com/in/mwengner/
💻 GitHub https://github.com/mirage22
🏠Home Page: https://www.wengnermiro.com/

Fun fact: When I was in my early 30s, I took my sister to Amsterdam. We visited almost all the museums, and I realized they kept selling me a student ticket without asking me the whole time. And it happened many more times after that. So finally, when I was 38, my wife told me I should grow a beard and that I didn’t look like a student, so I’ve had a beard ever since. So I could get a beer without showing id.

JConf Toronto 2023 and the Dawn of a New Era of Concurrency

Tue, 23 May 2023 16:52:41 +0000

JConf Toronto , held on May 3rd, 2023, was a memorable gathering of Java enthusiasts and experts from both the local and global communities.

The event took place at the Chestnut Conference Center, Toronto, featuring a wide variety of in-depth sessions, interactive Q&As, and two insightful keynote presentations.

Notable keynote speakers included Venkat Subramaniam and Neal Ford .

Venkat’s keynote, titled “Know Your Java,” was a deep dive into the intricacies of Java, demonstrating that there’s always something new to learn, even in a language that’s over two decades old.

An Industry Expert's Guide to Thriving in Software Development and Security

Tue, 23 May 2023 15:14:55 +0000

In today’s fast-paced tech world, understanding the intricacies of software development and product management is key to success.

In this enlightening discussion, we speak with Erik Costlow, a Senior Director of Product Management at Azul, who shares valuable insights from his journey of transitioning from engineering to product management, current industry trends, challenges in software development, and advice for new programmers.

With a unique perspective and wealth of experience, Erik’s insights are sure to be invaluable for anyone seeking to navigate the complex landscape of the software industry.

Announcing "Java Unscripted: An Asynchronous Exploration of Excellence

Tue, 16 May 2023 10:09:48 +0000

ITL;DR

Introducing “Java Unscripted,” a series featuring interviews with Java industry experts. We aim to inspire and guide new developers with these insights. Interested in participating? Fill out our Interview Participation Form . Let’s share your story with our community!

In a rapidly evolving world of technology, insights from industry luminaries can act as a beacon for those looking to navigate the challenging landscape. Over the years, industry leaders have seen the technological landscape transform. As a result, they possess a treasure trove of experiences and insights that can inspire and guide the upcoming generation of professionals. This idea inspired our new interview series, “Java Unscripted: An Asynchronous Exploration of Excellence. "

Discovering the Secrets to Success: An Exclusive Interview with Michael

Mon, 15 May 2023 17:35:04 +0000

In this interview, we had the pleasure of speaking with Michael P. Redlich, a seasoned software developer with over 30 years of experience in the field.

Michael shares his journey from learning Fortran IV to contributing to major Jakarta EE specifications and provides valuable insights for junior developers looking to succeed in the ever-evolving world of technology.

He emphasizes the importance of continuous learning and adapting to new technologies, and contributing to open-source projects.

A Comprehensive Guide to Java Virtual Threads (Part 1)

Tue, 09 May 2023 08:33:12 +0000

Introduction

Java Virtual Threads, also known as lightweight threads, is an exciting new feature introduced in Project Loom.

Virtual threads aim to simplify concurrent programming in Java by providing an efficient and easy-to-use concurrency model.

In this article, we’ll cover the basics of Java Virtual Threads, how they work, why they are beneficial for developers, and how they overcome the limitations of traditional Java threads.

What are Virtual Threads?

Java is made of threads. When we run a Java program, its main method is invoked as the first call frame of the main thread created by the Java launcher. It gives us many things: sequential control flow, local variables, exception handling, single-step debugging, and profiling.

Unlocking Java Secrets with Frank Delporte Foojay.io Today

Mon, 10 Apr 2023 13:48:51 +0000

Welcome to our exclusive interview with Frank Delporte , a Senior Technical Writer at Azul, Java Champion, and a passionate advocate for all things related to Java and Java on Raspberry Pi .

With extensive experience in the software industry, Frank has dedicated his career to making Java accessible to beginners and experienced developers alike.

In this interview, we will explore his journey in the software world, his work at Azul , his contributions to the Java community, and the valuable advice he has for newcomers who have just started learning Java.

Unlocking the Secrets to a Successful Software Engineering Career: An Interview with Otavio Santana

Mon, 03 Apr 2023 11:55:15 +0000

In this exclusive interview, we had the pleasure of speaking with Otavio Santana , a Java Champion and passionate software engineer and architect dedicated to empowering fellow engineers to deliver efficient, scalable software on the Cloud.

Otavio shares valuable insights from his journey in the open-source world, highlighting the importance of mentorship and open-source contributions for career growth.

With numerous awards and recognitions under his belt, Otavio discusses his current projects, the concept of evolutionary architecture, and the impact of simplicity on software development.

Debate on the Future of Java and Kotlin on Foojay.io Today

Wed, 29 Mar 2023 13:50:29 +0000

Java and Kotlin are two of the most popular programming languages on the Java Virtual Machine. But both languages have pros and cons, and developers often have to choose between them based on the needs of their project, the people on their team, and their own preferences.

Recently, a conversation took place in Foojay’s Slack channel , where participants discussed the comparison of Java and Kotlin. Foojay.io is a central place for the Java community to get daily information.

Navigating the Challenges of Modern Software Development: An Exclusive Interview with Shai Almog

Mon, 27 Mar 2023 16:39:07 +0000

Welcome to our exclusive interview with Shai Almog , an accomplished entrepreneur, author, blogger, and Java expert with over two decades of experience in the software industry.

Shai has been instrumental in developing innovative tools and solutions at Codename One and Lightrun , significantly impacting how Java applications are debugged and monitored in production.

In this fascinating conversation, Shai shares his journey, from his early exposure to programming to his growth as a developer and entrepreneur.

From Assembler to Chat-GPT: Steve Poole on the Shifting Landscape of Programming

Mon, 20 Mar 2023 11:56:20 +0000

Welcome to our exclusive interview with Steve Poole , a seasoned Java developer, leader, and evangelist with a lot of experience in the tech industry.

As a Developer Advocate for Sonatype , Steve has been deeply involved in Java SDKs and JVMs since Java was less than version 1.

In his long and successful career, he has had many roles, such as being a representative or lead on different Java Specification Requests (JSRs), committing to many open-source projects at Apache , Eclipse , and OpenJDK , and actively taking part in the Adopt OpenJDK group to promote community involvement.

Comparing Map.of() and new HashMap() in Java

Thu, 16 Mar 2023 08:16:32 +0000

Java is a popular programming language used for developing a wide range of applications, including web, mobile, and desktop applications.

It provides many useful data structures for developers to use in their programs, one of which is the Map interface.

The Map interface is used to store data in key-value pairs, making it an essential data structure for many applications.

In this article, we will discuss the use of Map.of() and new HashMap<>() in Java, the difference between them, and the benefits of using Map.of().

From Law Degree to Java Champion: Geertjan Wielenga on the Success of Java and Navigating the Software Industry

Mon, 13 Mar 2023 11:07:54 +0000

In this interview, we chat withGeertjan Wielenga , a Java Champion and developer advocate at Azul . Geertjan talks about how he unusually got into the software industry and what it was like to work with Java and its community.

He talks about what has made Java so successful, the problems developers face in a constantly changing industry, and how important it is for people to work together and be involved in the community.

My Adventures at ConFoo Conference in Montreal

Mon, 06 Mar 2023 19:16:06 +0000

I attended the ConFoo conference in Montreal , which covered a range of technologies like cloud computing, Java and JVM technologies, Javascript, DevOps, architecture and design patterns, PHP, security, test and quality, management, UX and UI, and more.

The conference took place over three days at the Bonaventure Hotel in Montreal, but I could only attend on the second day.

To make it possible, I requested the organizers schedule both of my talks on the same day, so I could fly in from Toronto in the morning and leave in the evening. I was grateful to them for accommodating my request.

Java Sealed Classes: Building Robust and Secure Applications

Mon, 20 Feb 2023 11:11:07 +0000

Java sealed classes were introduced in Java 15 as a way to restrict the inheritance hierarchy of a class or interface.

A sealed class or interface restricts the set of classes that can implement or extend it, which can help prevent bugs and make code more maintainable.

Suppose you’re building an e-commerce application that supports different payment methods, such as credit cards, PayPal, and Bitcoin. You could define a sealed class called PaymentMethod that permits various subclasses for each payment method:

Optional in Java: A Swiss Army Knife for Handling Nulls and Improving Code Quality

Wed, 01 Feb 2023 05:29:38 +0000

In Java, dealing with null values can be a real headache. Nulls can cause all sorts of problems in your code, from NullPointerExceptions to convoluted if statements and error-prone logic. Fortunately, Java 8 introduced the Optional class, which offers a simple and powerful way to handle nulls and improve code quality. Optional is a container object that may or may not contain a non-null value and provides a range of practical methods for working with its contents. In this article, we’ll explore the many use cases of Optional in Java and show you how to use this powerful class to write cleaner, more expressive, and more resilient code.

Java Bytecode: Journey to the Wonderland (Part 3)

Tue, 24 Jan 2023 15:27:51 +0000

Our previous article unpacked Bytecode further and discussed ConstantPool, today I’ll go through several resources for working with it now.

Java bytecode is the Java Virtual Machine’s (JVM) intermediate representation of Java code. While Java bytecode is not meant to be human-readable, it may be edited and manipulated for several reasons. This article examines the tools and methods used to change and work with Java bytecode.

Changing Java bytecode is often done to add new features to a Java program that already exists. This can be done with a bytecode injector, a tool that lets you add bytecode to a Java class file that has already been compiled. Bytecode injectors are often used for logging or debugging information and for allowing runtime updates like A/B testing or feature flags.

Why Many Developers Don't Write or Give Talks

Wed, 11 Jan 2023 09:53:10 +0000

I asked on Twitter and LinkedIn why many developers don’t write or give talks, and I was amused by the response I received. This article is about that.

The problems:

It turns out, developers do not write blogs or give presentations for a variety of reasons. Some developers may believe they lack interesting experiences or information to share or that they are not experts in their profession. Others may be shy or fearful of public speaking. Due to their hectic schedules, individuals may not have time to write about or discuss their jobs, which is another reason.

Why Did We Choose JSF for the Eclipse Starter for Jakarta EE?

Tue, 13 Dec 2022 10:27:44 +0000

After being taken care of by the Java Community Process (JCP), Java EE is now supported by the Eclipse Foundation as Jakarta EE .

This means that we can focus more on open standards for governance, open-source development, and testing for compatibility.

It is also a great way to include openness to all vendors, a clear flow of intellectual property (IP), well-defined procedures for defining specifications, and a level playing field.

A Minor But Useful Refactoring Technique That Would Reduce Your Code Footprint (Part 2)

Wed, 26 Oct 2022 15:16:18 +0000

As I keep refactoring, this article will focus on a few more interesting ways to do it. These are pretty much minor yet effective and useful changes.

Stream.noneMatch() and Stream.anyMatch()

In some situations, we need to find a single case among many. For example, we want to do a certain operation if we have a list of items and a certain item is in that list. Usually, we run a for loop and then use a loop inside the for loop to check the value against our case. Check out the following piece of code:

Foojay Podcast #6: Welcome to Foojay!

Mon, 24 Oct 2022 15:50:35 +0000

In this episode of the Foojay Podcast, we want to give you a look behind the curtains of Foojay.io.

The very first post on the website dates from April 25th in 2020, and it was by Geertjan Wielenga.

Let’s look back and what has happened on Foojay during the 2,5 years since that first post, and talk to some of the people behind the project.

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Minor Techniques That Would Reduce Your Code Footprint (Part 1)

Thu, 20 Oct 2022 14:32:52 +0000

Finally, we upgraded to Java 11 from Java 8.

That was a long-awaited move, but I’m pleased that we eventually made it.

The next thing that came to mind when I stated this was, “Why not Java 17 directly?”

Eventually, we will move to 17, but we had to begin someplace.

And the transition to 11 was not easy either.

We had several dependencies with Mockito, which made the journey somewhat tricky, but we were able to manage it.

What Does The JVM Look Like, How Does It Work?

Thu, 29 Sep 2022 05:29:00 +0000

Knowing how to code is fantastic, but it is even more enjoyable if we understand how a specific programming ecosystem works.

I recall the C course I took during my first semester at university. I wanted to learn how C compilers take a program, verify it, and then compile it. As a side project, I wrote a small program that checks another C program to see if there are any syntax errors. I named it Cyntax. It didn’t accomplish much, but I felt euphoria while doing it.

The 5 Most Pivotal and Innovative Additions to OpenJDK 19

Tue, 20 Sep 2022 16:25:12 +0000

Although OpenJDK 19 is not an LTS, it is still a significant release, in my opinion.

It includes several game-changing features that will alter the Java landscape.

Many features intrigue my interest, but there are five in particular that I can’t wait to try out. Let’s break those down and talk about them separately.

JEP 425: Virtual Threads (Preview)

Under the umbrella of Project Loom, JEP 425 introduces virtual threads, which aim to dramatically reduce the effort of writing, maintaining, and observing high-throughput concurrent applications on the Java platform. This is a preview feature . Consider the following example:

Java Thread Programming (Part 15)

Wed, 31 Aug 2022 17:30:53 +0000

This article will discuss how we do asynchronous method invocation with Callable and Future with a practical example.

Look at the code snippet. It doesn’t have anything yet, but as we learned about Java threading , we know anything we put here will run on the main thread unless we spawn a new thread from here.

Now consider a case where you work as a banker, and you need to calculate how much credit you can provide to a person.

Java Bytecode Simplified: Journey to the Wonderland (Part 2)

Tue, 16 Aug 2022 15:15:22 +0000

Our previous article introduced Bytecode and discussed what it includes.

This article will delve a bit deeper into ConstantPool.

Highlights:

Bytecode is a representation that is abstract in nature. They are fictitious codes for a fictitious machine known as the Java Virtual Machine. The Java virtual machine is a piece of software that interprets Bytecode.
The JVM is a stack-based computer. Real CPUs are register-based systems and execute machine code. Java is compiled into Bytecode, an intermediate form, which is then executed by the Just In Time (JIT) compiler, which generates machine code.

Before going any further, let’s explore javap, which is a very handy tool for deconstructing byte code.

Top 7 Features in Jakarta EE 10 Release

Tue, 28 Jun 2022 08:33:31 +0000

Java EE has been a dominant force behind all enterprise development in Java. Lately, it was renamed to Jakarta EE , while transitioning to the Eclipse Foundation.

This transition opened the door to open governance, open compatibility testing (the earlier Technology Compatibility Kit was closed source), and of course, open-source contributions. That means no specific vendor has more influence than any other and it is a more distributed process now.

How to Add an Event to the Foojay Event Calendar

Tue, 07 Jun 2022 09:34:47 +0000

Foojay.io, the place for f riends of O penJDK, is a friendly community of users of the OpenJDK, such as Java developers and Kotlin developers.

It is a collaborative community with tips and insights being shared on a daily basis on Foojay Today .

At Foojay, we maintain a list of past and upcoming Java events. It helps the worldwide OpenJDK community find events and participate in them easily.

You will find all the events in the following link:

Book Review: Monolith to Microservices (Part 2)

Wed, 25 May 2022 09:09:08 +0000

This is the second article of the first one I wrote the other day , “Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith ” by Sam Newman.

In this article, I will summarize chapter two.

Chapter #2: Planning to Migration

In this chapter, the book discusses the goal and mindset. When we are looking for a Microservices, what should be our goal.

It argues that our goal shouldn’t be the Microservices. Something worked for Netflix or Amazon, which means it will work for me as well. This thought process has a major flaw. It makes you fall into a cargo cult mentality.

Book Review: Monolith to Microservices (Part 1)

Wed, 18 May 2022 07:43:41 +0000

I have just finished reading “Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith ” by Sam Newman.

This book is undoubtedly great. It explains the critical aspects applicable when moving away from a monolith to a microservices architecture.

In this article, I will try to summarize some of the key elements from the book that impacted me.

This book contains five chapters, each of which has a great deal of context and explanation.

How to run the Java Incubator Module from the Command Line and IntelliJ IDEA

Tue, 10 May 2022 16:52:15 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. It opens the door to Structured Concurrency. This article isn’t about it, in case you are interested, you can read, the JEP draft: Structured Concurrency (Incubator)

Also, if you are interested in how the incubator module works, please read: JEP 11: Incubator Modules

I downloaded the early access build and wrote the following very simple program that demonstrates structure concurrency.

How to enable java preview feature and run code from IntelliJ IDEA

Sun, 08 May 2022 10:07:50 +0000

JEP 425: Virtual Threads (Preview) has been proposed recently. It has been a long-awaited feature in Java. I wanted to give it a try. So I download the early release of JDK which has the project loom in it. However, it is under preview.

The following snippet was pretty much my first program written for testing virtual threads.

public class Main {
 public static void main(String[] args) throws InterruptedException {
 Thread.startVirtualThread(() -> {
 System.out.println("Hello from virtual thread");
 }).join();
 }
}

It is so simple that I could just run it in the command line using the source code launcher :

How To Submit Your Next Article On Foojay.io

Tue, 03 May 2022 18:32:09 +0000

Foojay, the place for friends of OpenJDK, is a friendly community of Java and Kotlin developers who share tips and insights every day on Foojay Today . We would love to publish your article too!

Since September 2026, Foojay.io moved from a WordPress system to a static site built with Hugo and published from a public GitHub repository, github.com/foojayio/website . Contributing an article means adding a small folder of files (your text and images) to that repository. You don’t need to know Hugo — everything you need is in a ready-made template.

Top 10 Java Language Features

Tue, 12 Apr 2022 17:06:07 +0000

Every programming language provides ways to express our ideas and then translates them into reality.

Some are unique to that particular language and some are common to many other programming languages.

In this article, I will explore ten Java programming features used frequently by developers in their day-to-day programming jobs.

Collection’s factory method

Collections are the most frequently used feature in our daily coding. They are used as a container where we store objects and pass them along.

Three Mistakes Developers Make Preventing Getting Hired On Projects

Wed, 06 Apr 2022 07:46:48 +0000

Being hired is not easy and it is especially somewhat tricky for junior software developers to be taken on to work on amazing projects. The reason is clear: industries always want people with the right skills and a junior software developer does not typically always have those. We get to learn to program and acquire knowledge from universities and colleges, which is not enough to be able to work on unique projects right away.

5 Things You Probably Didn’t Know About Java Concurrency

Fri, 25 Mar 2022 05:51:41 +0000

Threads are at the heart of the Java programming language. When we run a “Hello World” Java program, we run on the main thread. From there, we can create threads easily, as we need to compose our application code to be functional, responsive, and performant, all at the same time.

Think about a web server: it simultaneously handles many thousands of requests at the same time. In Java, we achieve this using multiple threads. While threads are helpful, they are full of dread/thread to many developers.

7 Reasons Why, After 26 Years, Java Still Makes Sense!

Tue, 15 Mar 2022 08:02:48 +0000

Java has been and continues to be the most popular language over the last two decades. It has always been in the top 5 in the TIOBE index in terms of popularity. Besides popularity, Java is especially dominant in the enterprise world.

However, in recent years, with the popularity of microservices and data science, other programming languages, such as Python, have gained in popularity. Some developers may view this as concerning news, as it may indicate the decline of Java, while others would argue differently.

Java Bytecode Simplified: Journey to the Wonderland (Part 1)

Tue, 08 Mar 2022 10:16:36 +0000

There are two ways to see a thing. One, see it as it appears to us; two, see it and appreciate it. For example, we get light when we switch on a lightbulb. We press the button and then get busy with our life. Pretty simple, but boring. On the other hand, if we know how the light gets energy from an electrical power grid far from our home with wires and while travelling through the wires and filament, the filament heats up and starts emitting photons, we get to see in the light; we can then appreciate the blessing.

Java Thread Programming (Part 14)

Tue, 01 Mar 2022 12:03:03 +0000

In our previous article , we discussed the thread pool’s sizing. We stipulated that if work is computational, we don’t need more threads than the available number of processors. We will discuss this idea a bit further in this article.

Let’s think about an example:

We all know how to compute the Fibonacci series. The simple code is given below-

public static long fib(int n) {
 if (n < 2) {
 return n;
 } else {
 return fib(n - 2) + fib(n - 2);
 }
}

Over here, we have used recursion to solve the Fibonacci series. To find the Fibonacci number of n, we must know the previous two. Each of them again will require to calculate the previous two. The process will continue until it reaches to the bases case and then we have a result.

7 Ways to Improve Your Code Reading Skills

Fri, 18 Feb 2022 21:21:56 +0000

Reading source code is in the job description of a software developer. However, this experience is not always pleasant. Not everyone would like to read someone else’s code because they find it boring, sometimes frustrating. There are cases when you start reading someone else’s code but end up getting a bitter feeling because you are not being able to understand it or the code is not well written. Most developers want to focus on writing code rather reading it, not realizing that reading code is also an important skill to have.

Java Thread Programming (Part 13)

Tue, 08 Feb 2022 08:15:29 +0000

Our previous article discussed different ways to create a Java thread pool and put and execute result-bearing tasks to the Pool. This article will go a bit in-depth about how many worker threads we could put in a pool to get the best result.

Using the Executors factory class, we can create our thread pool; however, all the factory methods internally create an instance of ThreadPoolExcutors. This class is the representation of ThreadPool that we use. We can directly create a pool invoking its constructor. The constructor takes 7 arguments:

Java Thread Programming (Part 12)

Tue, 01 Feb 2022 16:02:05 +0000

In our previous article , we introduced ThreadPool through the Executor Framework. This article will discuss the different ways we can create ThreadPool.

The Executors is a factory class, and it has a few static methods ( factory method). Let’s look at them one by one-

Executors.newFixedThreadPool(int nThreads): - this method takes an argument, and with that, we can specify the number of threads we want to have. The threads it creates are called worker Threads. It doesn’t matter how many tasks we put into this ThreadPool; the number of thread will remain the same the whole lifetime of this ThreadPool. If a thread dies for some reason, it will create a new one to keep the number the same.

Java Thread Programming (Part 11)

Wed, 26 Jan 2022 07:58:30 +0000

In the second article of this series , we saw that we can create a functional web server application using Java threads. With that, we could receive multiple requests from many clients and serve them properly.

However, there is a limitation. We cannot just receive an unbounded number of requests simultaneously. The constraint is not on the sockets. The modern OS can handle millions of open sockets at a time. That means, in theory, we should be able to serve that many requests at a time.

Java Thread Programming (Part 10)

Wed, 22 Dec 2021 09:23:41 +0000

In this article, I will discuss BlockingQueue, one of the essential concurrent collections available in the concurrent package in the JDK. In one of our previous articles , we discussed the Producer/Consumer pattern. We will implement the same pattern today using BlockingQueue.

In that implementation, we used a buffer, and when Buffer is full, we put the producer thread in a waiting state. And if Buffer is empty, we put the consumer thread in a waiting state. To coordinate between threads, we had to use, wait(), notify() and notifyAll(), these low-level constructs. However, if we use BlockingQueue, we don’t have to use these low-level details. BlockingQueue was implemented with such details built in, so that we can just rely on it. It has two methods that are important in our discussion:

Java Thread Programming (Part 9)

Tue, 14 Dec 2021 11:14:33 +0000

In our last article , we discussed thread-safety in naive terms and shared a couple of ways to ensure thread safety. We also introduced a package containing thread-safe classes, which we can confidently use without worrying much, e.g., AtomicInteger. This is because they are designed in a thread-safe way.

Today in this article, we will continue the discussion and share a few more thread-safe classes that we can use in our day-to-day coding.

Java Thread Programming (Part 8)

Tue, 07 Dec 2021 18:15:09 +0000

The term thread safety is a frequently and commonly pronounced word among Java developers. However, it is still one of the misunderstood terms as well. In this article, I will try to explain in a very simplified way what it is and how we can achieve it while we write our day-to-day code.

The idea is, when writing a piece of code, it usually contains method and data. If we write a class, it may hold some data in terms of state. For example, if we want to write a Counter class, we will have a variable inside the counter class that holds the current count.

Java Thread Programming (Part 7)

Tue, 23 Nov 2021 10:10:53 +0000

In our previous Java threading articles in this series , we learned a great deal about how we can create threads and how to use them while avoiding the issues that come with them. But what does this leave us with? Can we create as many threads as we want? I wish I could answer this with a straight yes or no. In this article, I will try to come up with an answer via an exercise, so bear with me!

Java Thread Programming (Part 6)

Tue, 16 Nov 2021 15:02:53 +0000

Have you ever wondered what is the purpose of the “wait()”, “notify()”, “notifyAll()” methods that come with each Java object? Well, this article will explain that!

In the previous article , we learned how to use shared variables in a multi-threaded context and ensure thread safety avoiding data race and race conditions. However, in programming, sometimes multiple threads require to coordinate with each other by sending signals. For example -

For a thread, it’s not yet their turn to start work; rather it’s waiting for a signal to start.
A thread is working, but to complete its work, it needs more data; it can send a signal to the Producer to produce more data.
Another thread that are producing data can signal other thread that data is ready.

Basically, there are many similar cases when we need to coordinate among multiple threads. Let’s discuss this in this article.

Let’s Use Optional to Fix Method Contracts

Wed, 10 Nov 2021 11:56:19 +0000

A method is a contract: when we define one, we put thought into it. We specify parameters with their type and also a return type. When we invoke a method, we expect it to behave according to the contract. If it doesn’t, it’s a violation of the contract.

We have been dealing with such violations all the time. We invoke a method with its proper arguments and we get a return. However, sometimes we end up getting a null, which is, in fact, a clear violation. We shouldn’t accept such a violation. If a method cannot return the value of the specified type, it should mention that in the method signature, the method may or may not be returning the value you are expecting. If we know it from the method signature, we then write our code accordingly.

Java Thread Programming (Part 5)

Tue, 02 Nov 2021 08:29:36 +0000

In our previous article , we discussed the “data race” concept and how we can solve it using volatile keywords. However, this is not the only problem we face when dealing with code that runs in multi-threaded environments. In this article, we will discuss another situation called “race conditions” and how we can resolve it.

By now, we know that threads share memory space so that multiple threads can read from and write to the same variable. Unfortunately, although this ability gives us faster memory access, it has an unpleasant side effect which we call “race condition,” and it creates data inconsistency in the program. To understand the problem, let’s see an example.

Java Thread Programming (Part 4)

Tue, 26 Oct 2021 13:04:40 +0000

In the previous article , we discussed the visibility problem while working with multiple threads.

We will discuss another similar situation in this article. However, we will use symbols and pseudocode to explain this.

Symbols

Let’s define the symbols first.

L - Local variable, e.g., L1, L2, etc.
S - Shared variable, e.g., S1, S2, etc. These variables are visible among multiple threads. They can be static as well.

S.X - here X is a field of an object where S is the reference of that Object, e.g., S1.X.

Java Thread Programming (Part 3)

Thu, 21 Oct 2021 13:20:17 +0000

Continuing from part 2 , let’s start this article with a bit of context first (and if you don’t like reading text, you can skip this introduction, and go directly to the section below where I discuss pieces of code).

Context

When we start an application program, the operating system creates a process.
Each process has a unique id (we call it PID) and a memory boundary.
A process allocates its required memory from the main memory, and it manipulates data within a boundary.
No other process can access the allocated memory that is already acquired by a process.
It works like a sandbox, and in that way avoids processes stepping on one another’s foot.
Ideally, we can have many small processes to run multiple things simultaneously on our computers and let the operating systems scheduler schedule them as it sees fit.
In fact, this is how it was done before the development of threads. However, when we want to do large pieces of work, breaking them into smaller pieces, we need to accumulate them once they are finished.
And not all tiny pieces can be independent, some of them must rely on each other, and thus we need to share information amongst them.
To do that, we use inter-process communication. The problem with this idea is that having too many processes on a computer and then communicating with each other isn’t cheap. And precisely that is where the notion of threads comes into the picture.

The idea of the thread is that a process can have many tiny processes within itself. These small processes can share the memory space that a process acquires. These little processes are called a thread. So the bottom line is, threads are independent execution environments in the CPU and share the same memory space. That allows them faster memory access and better performance.

Java Thread Programming (Part 2)

Tue, 12 Oct 2021 09:07:05 +0000

In our earlier article , we explained the background to threading and how to create and start a thread.

In this article, let’s see an example where we can use Threads to our benefit.

Let’s assume we are going to build a web server. For the sake of the example, let’s constrain ourselves to one single use case, which is that the web server will listen to any client, and if it receives a URL, it will return the top five most frequently used words in that website.

Java Thread Programming (Part 1)

Thu, 07 Oct 2021 10:07:29 +0000

What is a Thread?

We write code in a file line by line, and then it gets executed. To be able to execute a piece of code requires an execution environment. In Java, a thread is an execution environment. If a program has only one execution environment, then we call this program a single-threaded program.

Interestingly, in Java, we can create a lot of threads to run different parts of the code of a program executing independently. And when we have achieved that, we call it a multi-threaded program.

Reclaim 25% of Java Heap Memory & Lower Your Cloud Bills

Fri, 24 Sep 2021 09:15:05 +0000

Did you know that you can save up to 25% of your heap memory and your Cloud bills without any effort? Well, it’s true. Many exciting features have been added to the latest releases of Java recently and I’m going to cover one that is often overlooked in this article.

We all know that Strings are the most used Object in any Java application. In fact, they probably take up almost half of the heap size of any Java application. Before delving into this much further, let me answer your obvious question: what are Strings made of?