JDK 23 on foojay.io - Friends of OpenJDK

How to Use Java as a Scripting Language

Mon, 23 Mar 2026 10:00:19 +0000

The Scripting Dilemma

If you’re like me, as a Java developer, you struggle to remember bash or python syntax for quick scripts.

You end up “vibe coding” it, then struggle again when you need to adapt it. If only you could write it in Java!

You might say “Java is not for scripting” and “I don’t want maven or Gradle”.Modern Java has quietly eliminated the traditional barriers that made it unsuitable for scripting.With instant execution, shebang support, and zero-setup automation, Java has evolved into a lean scripting language. Write precise, maintainable code without the “vibe coding” that comes with unfamiliar languages.

Project Loom: Structured Concurrency - Java

Wed, 29 Jan 2025 12:12:38 +0000

In today’s era of cloud computing, where high-performance infrastructure is readily available, developers face a complex challenge in achieving efficient concurrency.

While modern technological advancements have brought us closer to solving these challenges, we must adopt a thoughtful, incremental approach to concurrency.

This principle holds especially true as we strive to design scalable, reliable, and easy-to-maintain systems.

One such advancement in this domain is structured concurrency, a paradigm that simplifies concurrent programming by bringing order and predictability to task management.

Just-Write-And-Run prototyping with JEP-477

Wed, 23 Oct 2024 09:37:04 +0000

It seems like it’s never been easier to start writing a simple program that can be turned into a more advanced one as development progresses. Let’s explore possibilities delivered by JDK 23 release.

From the early days, Java may have struggled with a relatively verbose and sometimes strikingly complicated process of creating a small program. A small program just to validate an idea or assumption. Let’s call that Just-Write-And-Run feature. For example, it’s required to create a trivial solution for reading and parsing data, Oh now what…

Gatherers upgrades pipeline design pattern JEP-461

Tue, 15 Oct 2024 06:18:04 +0000

Source-code flexibility goes hand in hand with maintainability and testability. The Java language benefits not only from its maturity but also from the fact that it is strongly typed. This may initiate possible discussion topics, as each defined variable requires its type to be known, which can lead to unnecessary verbosity in the source code (reduced by JEP-286: local variable type inference[4]).

Since the introduction of the Stream API in Java 8, developers have benefited from the ability to create complex transformations inside pipelines. The Stream API allows a lazily evaluated definition of how a pipeline (Example 1.- 1) should be transformed through one or multiple intermediate functions (Example 1.- 2). The sequence of intermediate functions must be terminated by a terminal function that materializes the output (Example 1.- 3).

Builder Pattern Simplicity with JEP-455 Primitive Types

Thu, 10 Oct 2024 10:54:08 +0000

The runtime initiation of any program requires allocating a given memory and after many additional steps the first object could be created.

In a previous post , we explored how to improve maintainability of complex creation processes by using the factory creational pattern[4] and JEP-482, flexible constructor bodies.

The factory design may be a good fit for many cases but it may also create obstacles due to the pattern code centralized nature.

Java 23 Has Arrived, And It Brings a Truckload of Changes

Tue, 17 Sep 2024 06:45:11 +0000

Java 23 has arrived! It’s been six months since Java 22 was released, so it’s time for a fresh truckload of JEPs.

In this article, we take you on a tour of everything that is part of this release, giving you a brief introduction to each of them.

Where applicable the differences with Java 22 are highlighted and a few typical use cases are provided, so that you’ll be more than ready to start using these features after reading this.

Foojay Podcast #57: Welcome to OpenJDK 23

Mon, 16 Sep 2024 11:34:40 +0000

OpenJDK (Java) 23 is (almost) here!

OpenJDK 23 introduces three new features to the language and runtime and many bug fixes, small improvements, and a longer list of preview features.

What are the most important facts about this release? Let’s find out…

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Java 23: What’s New? | Foojay.io today

Wed, 04 Sep 2024 09:19:35 +0000

As soon as Java 23 is out, it’ll be time to walk through all the functionalities that this version bring to us as developers.

First of all, something has happened that, to my knowledge, has never happened before in a Java release: a preview feature has been removed! The String Templates feature, which appeared as a preview feature in Java 21, has been removed. A global redesign of this feature will be carried out, as it had given rise to much debate and didn’t seem to meet the community’s expectations.

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.