Java 21 💣💥

Nicolai Parlog

nipafx.dev / @nipafx

JUG München

Developer Advocate

Java Team at Oracle

Let’s get started!

this session covers Java 18-21
this is a showcase, not a tutorial
⇝ go to youtube.com/@java for more
slides at slides.nipafx.dev/java-x
(hit "?" to get navigation help)
ask questions any time

Lots to talk about!

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Why upgrade?

Costs of running on old versions:

support contract for Java
waning support in libraries / frameworks

Why upgrade?

Costs of not running on new versions:

lower productivity
less observability and performance
(more on that later)
less access to talent
bigger upgrade costs

Why upgrade?

Resistence is futile.

How to upgrade?

Preparations:

stick to supported APIs
stick to standardized behavior
stick to well-maintained projects
keep dependencies and tools up to date
stay ahead of removals (jdeprscan)
build on many JDK versions

How to upgrade?

Prepare by building on multiple JDK versions:

your baseline version
every supported version since then
latest version
EA build of next version

How to upgrade?

It’s not necessary to build …

… each commit on all versions
… the whole project on all versions

Build as much as feasible.

What about LTS?

Within OpenJDK, there is no LTS.

⇝ has no impact on features, reliability, etc.

It’s a vendor-centric concept
to offer continuous fixes
(usually for money).

You’re paying not to get new features.

What about LTS?

Java 21 💣💥

Pattern Matching

A New Dynamic Dispatch

Data-Oriented Programming

Virtual Threads

String Templates

New & Updated APIs

Performance & More

A simple app

Features:

scrapes GitHub projects
creates Page instances:
- GitHubIssuePage
- GitHubPrPage
- ExternalPage
- ErrorPage
further processes pages

A simple app

Features:

display as interactive graph
compute graph properties
categorize pages by topic
analyze mood of interactions
process payment for analyses
etc.

A simple architecture?

How to implement features?

methods on Page 😧
visitor pattern 😫
pattern matching 🥳

Pattern Matching

Ingredients:

switch expressions ⑭ (JEP 361)
type pattern matching ⑯ (JEP 394)
sealed types ⑰ (JEP 409)
patterns in switch ㉑ (JEP 441)

Approach:

make Page sealed
implement features as methods outside of Page
accept Page parameters and switch over it

Sealed Page

Sealed types limit inheritance,
by only allowing specific subtypes.

public sealed interface Page
	permits GitHubIssuePage, GitHubPrPage,
			ExternalPage, ErrorPage {
	// ...
}

Switch over Page

public void categorize(Page page) {
	switch (page) {
		case GitHubIssuePage issue
			-> categorizeIssue(issue);
		case GitHubPrPage pr
			-> categorizePr(pr);
		case ExternalPage external
			-> categorizeExternal(external);
		case ErrorPage error
			-> categorizeError(error);
	}
}

Maintainability

Unlike an if-else-if-chain,
a pattern switch needs to be exhaustive.

Fulfilled by:

switching over a sealed types
a case per subtype
avoiding the default branch

⇝ Adding a new subtype causes compile error!

Dynamic dispatch

Dynamic dispatch selects the invoked method by type.

As language feature:

via inheritance
makes method part of API

What if methods shouldn’t be part of the API?

Dynamic dispatch

Without methods becoming part of the API.

Via visitor pattern:

makes "visitation" part of API
cumbersome and indirect

Via pattern matching (new):

makes "sealed" part of type
straight-forward

Java 21 💣💥

Pattern Matching

A New Dynamic Dispatch

Data-Oriented Programming

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Data-Oriented Programming

Use Java’s strong typing to model data as data:

use types to model data, particularly:
- data as data with records
- alternatives with sealed types
use (static) methods to model behavior, particularly:
- exhaustive switch without default
- pattern matching to destructure polymorphic data

Data-Oriented Programming…

… isn’t funtional programming

but it’s similar (data + functions)
first priority is data, not functions

… doesn’t kill object-oriented programming

use OOP to modularize large systems
use DOP to model small, data-focused (sub)systems

Java 21 💣💥

Pattern Matching

Virtual Threads

Unlimited Threads

Under The Hood

String Templates

New & Updated APIs

Performance & More

A simple web request

Imagine a hypothetical HTTP request:

interpret request
query database (blocks)
process data for response

Resource utilization:

good for 1. and 3.
really bad for 2.

How to implement that request?

Synchronous

Align application’s unit of concurrency (request)
with Java’s unit of concurrency (thread):

use thread per request
simple to write, debug, profile
blocks threads on certain calls
limited number of platform threads
⇝ bad resource utilization
⇝ low throughput

Asynchronous

Only use threads for actual computations:

use non-blocking APIs (futures / reactive streams)
harder to write, challenging to debug/profile
incompatible with synchronous code
shares platform threads
⇝ great resource utilization
⇝ high throughput

Conflict!

There’s a conflict between:

simplicity
throughput

Enter virtual threads!

A virtual thread:

is a regular Thread
low memory footprint ([k]bytes)
small switching cost
scheduled by the Java runtime
requires no OS thread when waiting

Think of them like you
think about virtual memory.

Example

try (var executor = Executors
		.newVirtualThreadPerTaskExecutor()) {
	for (int i = 0; i < 1_000_000; i++) {
		var number = i;
		executor.submit(() -> {
			Thread.sleep(Duration.ofSeconds(1));
			return number;
		});
	}
} // executor.close() is called implicitly, and waits

Example

This laptop:

Intel i7-1165G7 (11th Gen)
8GB for JVM (32 GB total RAM)
Gentoo Linux (kernel v6.5.10)

Extremely rough measurements:

#threads

10k

100k

500k

run time

1.0s

1.1s

1.3s

20s

Effects

Virtual threads:

aren’t "faster threads"
remove "number of threads" as bottleneck
match app’s unit of concurrency to Java’s

Virtual threads increase throughput:

when workload is not CPU-bound
when number of concurrent tasks is high

⇝ simplicity && throughput

Server how-to

For servers:

request handling threads are started by web framework
frameworks will offer (easy) configuration options

We’re getting there.

Spring Boot

Set property on 3.2 (Nov 2023):

spring.threads.virtual.enabled=true

(Source)

Quarkus

Annotate request handling method on 3.?:

@GET
@Path("api")
@RunOnVirtualThread
public String handle() {
	// ...
}

(Source)

Helidon

Just works on 4.0 (currently RC1).

(Source)

📝 JEP 444
📝 On Parallelism and Concurrency
🎥 Java 21 new feature: Virtual Threads (Sep 2023)

Java 21 💣💥

Pattern Matching

Virtual Threads

Unlimited Threads

Under The Hood

String Templates

New & Updated APIs

Performance & More

Preparing your code

Virtual threads:

always work correctly
may not scale perfectly

Code changes can improve scalability
(and maintainability, debuggability, observability).

Avoid thread pools

Only pool expensive resources
but virtual threads are cheap.

⇝ Replace thread pools (for concurrency),
with virtual threads plus, e.g., semaphores.

With thread pools

// limits concurrent queries but pools 👎🏾
private static final ExecutorService DB_POOL =
	Executors.newFixedThreadPool(16);

public <T> Future<T> queryDatabase(Callable<T> query) {
	return DB_POOL.submit(query);
}

With semaphore

// limits concurrent queries without pool 👍🏾
private static final Semaphore DB_SEMAPHORE =
	new Semaphore(16);

public <T> T queryDatabase(Callable<T> query)
		throws Exception {
	DB_SEMAPHORE.acquire();
	try {
		return query.call();
	} finally {
		DB_SEMAPHORE.release();
	}
}

Caveats

To understand virtual thread caveats
we need to understand how they work.

(Also, it’s very interesting.)

Under the hood

The Java runtime manages virtual threads:

runs them on a pool of carrier threads
on blocking call:
- internally calls non-blocking operation
- unmounts from carrier thread!
when call returns:
- mounts to (other) carrier thread
- continues

The simple web request

Remember the hypothetical request:

interpret request
query database (blocks)
process data for response

In a virtual thread:

runtime submits task to carrier thread pool
when 2. blocks, virtual thread unmounts
runtime hands carrier thread back to pool
when 2. unblocks, runtime resubmits task
virtual thread mounts and continues with 3.

Compatibility

Virtual threads work correctly with everything:

all blocking operations
synchronized
Thread, currentThread, etc.
thread interruption
thread-locals
native code

But not all scale perfectly.

Caveat #1: capture

Despite lots of internal rework (e.g. JEPs 353, 373)
not all blocking operations unmount.

Some capture platform thread:

Object::wait
file I/O (⇝ io_uring)

⇝ Compensated by temporarily growing carrier pool.

⚠️ Problematic when capturing operations dominate.

Caveat #2: pinning

Some operations pin (operations don’t unmount):

native method call (JNI)
foreign function call (FFM)
synchronized block (for now)

⇝ No compensation

⚠️ Problematic when:

pinning is frequent
contains blocking operations

Avoid long-running pins

If possible:

avoid pinning operations
remove blocking operations
from pinning code sections.

With synchronization

// guarantees sequential access, but pins (for now) 👎🏾
public synchronized String accessResource() {
	return access();
}

With lock

// guarantees sequential access without pinning 👍🏾
private static final ReentrantLock LOCK =
	new ReentrantLock();

public String accessResource() {
	// lock guarantees sequential access
	LOCK.lock();
	try {
		return access();
	} finally {
		LOCK.unlock();
	}
}

Caveat #3: thread-locals

Thread-locals can hinder scalability:

can be inherited
to keep them thread-local,
values are copied
can occupy lots of memory

(There are also API shortcomings.)

⇝ Refactor to scoped values (JEP 446).

With thread-local

// copies value for each inheriting thread 👎🏾
static final ThreadLocal<Principal> PRINCIPAL =
	new ThreadLocal<>();

public void serve(Request request, Response response) {
	var level = request.isAdmin() ? ADMIN : GUEST;
	var principal = new Principal(level);
	PRINCIPAL.set(principal);
	Application.handle(request, response);
}

With scoped value

// immutable, so no copies needed 👍🏾
static final ScopedValue<Principal> PRINCIPAL =
	new ScopedValue<>();

public void serve(Request request, Response response) {
	var level = request.isAdmin() ? ADMIN : GUEST;
	var principal = new Principal(level);
	ScopedValue
		.where(PRINCIPAL, principal)
		.run(() -> Application
			.handle(request, response));
}

Preparing your code

Most importantly:

replace thread pools with semaphores

Also helpful:

remove long-running I/O from pinned sections
replace thread-locals with scoped values
replace synchronized with locks

Deprecations

Cleaning house

Already removed:

RMI activation ⑰ (JEP 407)
Nashorn ⑮ (JEP 372)
concurrent mark sweep GC ⑭ (JEP 363)

Cleaning house

Deprecations (for removal):

allowed-by-default dynamic agents ㉑ (JEP 451)
Windows 32-bit x86 port ㉑ (JEP 449)
finalization ⑱ (JEP 421)
security manager ⑰ (JEP 411)
applet API ⑰ (JEP 398)
primitive wrapper constructors ⑯ (JEP 390)
biased locking ⑮ (JEP 374)

Agents

What it is:

a component that transforms byte code
uses java.lang.instrument or JVM TI
launches with JVM or attaches later ("dynamic")

Dynamic agents

What you need to know:

all mechanisms for agents remain intact
nothing changed yet
in the future, dynamic attach will be
disabled by default
enable with -XX:+EnableDynamicAgentLoading

Dynamic agents

What you need to do:

run your app with -XX:-EnableDynamicAgentLoading
observe closely
investigate necessity of dynamic agents

Finalization

What it is:

finalize() methods
a JLS/GC machinery for them

Finalization

What you need to know:

you can disable with --finalization=disabled
in a future release, disabled will be the default
in a later release, finalization will be removed

Finalization

What you need to do:

search for finalize() in your code and
replace with try-with-resources or Cleaner API
search for finalize() in your dependencies and
help remove them
run your app with --finalization=disabled and
closely monitor resource behavior (e.g. file handles)

Security Manager

What it is:

a system of checks and permissions
intended to safeguard security-relevant
code sections
embodied by SecurityManager

Security Manager

What you need to know:

barely used but maintenance-intensive
already disallowed by default
enable with java.security.manager=allow
in a future release, it will be removed

Security Manager

What you need to do:

observe your app with default settings
(⇝ security manager disallowed)
if used, move away from security manager

Primitive constructors

What it is:

new Integer(42)
new Double(42)
etc.

Primitive constructors

What you need to know:

Valhalla wants to turn them into value types
those have no identity
identity-based operations need to be removed

Primitive constructors

What you need to do:

Integer.valueOf(42)
Double.valueOf(42)
etc.

📝 all the aforementioned JEPs
🎥 Future Java - Prepare Your Codebase Now!
🎥 How to Upgrade to Java 21

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

String composition

Composing strings in Java is cumbersome:

String property = "last_name";
String value = "Doe";

// concatenation
String query =
	"SELECT * FROM Person p WHERE p."
		+ property + " = '" + value + "'";
// formatting
String query =
	"SELECT * FROM Person p WHERE p.%s = '%s'"
		.formatted(property, value);

Comes with free SQL injection! 😳

String interpolation

Why not?

// (fictional syntax!)
String query =
	"SELECT * FROM Person p "
		+ "WHERE p.\{property} = '\{value}'";

Also comes with free SQL injection! 😳

String interpolation

SQL injections aren’t the only concern.

These also need validation and sanitization:

HTML/XML
JSON
YAML
…

All follow format-specific rules.

String templates

[Preview in Java 21 — JEP 430]

String query = STR."""
	SELECT * FROM Person p
	WHERE p.\{property} = '\{value}'
	""";

Template expression ingredients:

template with embedded expressions
~> StringTemplate
template processor (e.g. STR):
transforms StringTemplate into String*

Template procesor STR

String form = STR."""
	Desc     Unit   Qty   Amount
	\{desc} $\{price} \{qty} $\{price * qty}

	Subtotal  $\{price * qty}
	Tax       $\{price * qty * tax}
	Total     $\{price * qty * (1.0 + tax)}
	""";

Desc     Unit   Qty   Amount
hammer   $7.88  3     $23.64

Subtotal  $23.64
Tax       $3.546
Total     $27.186

Template processor FMT

String form = FMT."""
	Desc        Unit      Qty   Amount
	%-10s\{desc} $%5.2f\{price} %5d\{qty} $%5.2f\{price * qty}

	Subtotal  $%5.2f\{price * qty}
	Tax       $%5.2f\{price * qty * tax}
	Total     $%5.2f\{price * qty * (1.0 + tax)}
	""";

Desc        Unit      Qty   Amount
hammer      $ 7.88      3   $23.64

Subtotal  $23.64
Tax       $ 3.55
Total     $27.19

Why strings?

Often, strings are just exchange format, e.g.:

start with: String + values
validate / sanitize (i.e. parse)
dumb down to: String 🤔
parse to: JSONObject, Statement, …

Why the detour?

Custom templating

STR is a singleton instance of
a Processor implementation:

public interface Processor<RESULT, EX> {
	RESULT process(StringTemplate s) throws EX;
}

RESULT can be of any type!

Custom templating

// prevents SQL injections
Statement query = SQL."""
	SELECT * FROM Person p
	WHERE p.\{property} = '\{value}'
	""";

// validates & escapes JSON
JSONObject doc = JSON."""
	{
		"name": "\{name}",
		"year": "\{bday.getYear()}"
	}
	""";

Summary

String templates:

simplify string concatenation
enable domain-specific processing
incentivize the "right way"

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Sequenced Collections

Address Resolution SPI

Misc. Improvements

Performance & More

Order

Collections with order and indexed access:

List

Collections with order without indexed access:

SortedSet (sort order)
Deque (insertion order)
LinkedHashSet (insertion order)
and more

Sequence

New interfaces capture the concept of order:

SequencedCollection
SequencedSet
SequencedMap

Use as parameter or return type
and enjoy new methods.

Get first

Getting the first element:

list.get(0)
sortedSet.first()
deque.getFirst()
linkedHashSet.iterator().next()

Now for all:

sequencedCollection.getFirst()

Remove last

Removing the last element:

list.remove(list.size() - 1)
sortedSet.remove(sortedSet.last())
deque.removeLast()
linkedHashSet.🤷🏾‍♂️()

Now for all:

sequencedCollection.removeLast()

Reverse order

Reversing order:

list.listIterator() ⇝ ListIterator
navigableSet.descendingSet() ⇝ NavigableSet (view)
deque.descendingIterator() ⇝ Iterator
linkedHashSet.🤷🏾‍♂️()

Now for all:

sequencedCollection.reversed()

Reversed collection

sequencedCollection.reversed() returns
a SequencedCollection view:

for (E element : list.reversed())
	// ...

sortedSet
	.reversed().stream()
	//...

deque.reversed().toArray();

Reversed view

sequencedCollection.reversed() returns
a SequencedCollection view:

var letters = new ArrayList<>(List.of("A", "B", "C"));
	// ⇝ letters = ["A", "B", "C"]
letters.reversed().removeFirst();
	// ⇝ letters = ["A", "B"]

New operations

void addFirst(E);
void addLast(E);
E getFirst();
E getLast();
E removeFirst();
E removeLast();

SequencedCollection<E> reversed();

(Analoguous for maps.)

New ops vs sort order

What happens when addFirst|Last is used
on a sorted data structure?

SortedSet<String> letters = new TreeSet<>(
	List.of("B", "A", "C"));
	// ⇝ letters = ["A", "B", "C"]
letters.addLast("D");

Options:

works always ⇝ breaks SortedSet contract
works if value fits ⇝ hard to predict
works never ⇝ UnsupportedOperationException

Using types

Use the most general type that:

has the API you need/support
plays the role you need/support

For collections, that’s often: Collection
(less often: List, Set).

⇝ Consider new types!

📝 JEP 431: Sequenced Collections
🎥 Java 21’s New (Sequenced) Collections (Mar 2023)

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Sequenced Collections

Address Resolution SPI

Misc. Improvements

Performance & More

Built-in resolver

The JDK has a built-in resolver for host names:

relies on OS’s native resolver
typically uses hosts file and DNS

Desirable improvements:

better interaction with virtual threads
support for alternative protocols
support for testing/mocking

(While being backwards compatible.)

Pluggable resolver

Solution: Allow plugging in a custom resolver.

Two new types:

InetAddressResolverProvider
InetAddressResolver

Old resolver implements these,
and acts as default.

Pluggable resolver

// registered as a service
public abstract class InetAddressResolverProvider {
	InetAddressResolver get(Configuration config);
	String name();
}

public interface InetAddressResolver {
	Stream<InetAddress> lookupByName(
		String host, LookupPolicy lookupPolicy);
	String lookupByAddress(byte[] addr);
}

A transparent custom resolver

// in module declaration
provides InetAddressResolverProvider
	with TransparentInetAddressResolverProvider;

// class
public class TransparentInetAddressResolverProvider
		extends InetAddressResolverProvider {

	@Override
	public InetAddressResolver get(
			Configuration config) {
		return new TransparentInetAddressResolver(
			config.builtinResolver());
	}

}

A transparent custom resolver

public class TransparentInetAddressResolver
		implements InetAddressResolver {

	private InetAddressResolver builtinResolver;

	public TransparentInetAddressResolver(
			InetAddressResolver builtinResolver) {
		this.builtinResolver = builtinResolver;
	}

	// ...

}

A transparent custom resolver

@Override
public Stream<InetAddress> lookupByName(
		String host, LookupPolicy lookupPolicy) {
	return builtinResolver
		.lookupByName(host, lookupPolicy);
}

@Override
public String lookupByAddress(byte[] addr) {
	return builtinResolver.lookupByAddress(addr);
}

Custom resolvers

Possible resolvers:

support for QUIC, TLS, HTTPS, etc.
redirect host names to local IPs for testing
more ideas?

📝 JEP 418

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Sequenced Collections

Address Resolution SPI

Misc. Improvements

Performance & More

Collections

How do you create an ArrayList that
can store 50 elements without resizing?

new ArrayList<>(50);

How do you create a HashMap that
can store 50 pairs without resizing?

new HashMap<>(64, 0.8f);
new HashMap<>(128);

🤔

Collections

Right-sizing hashing data structures:

HashMap.newHashMap(int numMappings)
HashSet.newHashSet(int numElements)
LinkedHashMap.newLinkedHashMap(int numMappings)
LinkedHashSet.newLinkedHashSet(int numElements)

Math

Lots of new methods on Math:

for int/long division with different modes for:
- rounding
- overflow handling
for ceiling modulus (5 ⌈%⌉ 3 = -1)
for clamping

Strings and builders

"String".indexOf(
	String str, int beginIndex, int endIndex)

On StringBuilder and StringBuffer:

repeat(int codePoint, int count)
repeat(CharSequence cs, int count)

💣💥

On Character (all static):

isEmoji(int codePoint)
isEmojiPresentation(int codePoint)
isEmojiModifier(int codePoint)
isEmojiModifierBase(int codePoint)
isEmojiComponent(int codePoint)

Localizing DateTimes

Options for formatting dates/times with DateTimeFormatter:

with a fixed pattern: ofPattern
with a localized style: ofLocalizedDate
(FULL, LONG, MEDIUM, SHORT)

What about a localized result with custom elements?

⇝ DateTimeFormatter.ofLocalizedPattern

Localized patterns

DateTimeFormatter.ofLocalizedPattern:

you include what you want to show up
(e.g. year + month with "yMM")
result will depend on locale
(e.g. "10/2023" in USA)

Pattern comparison:

var now = ZonedDateTime.now();
for (var locale : List.of(
		Locale.of("en", "US"),
		Locale.of("be", "BE"),
		Locale.of("vi", "VN"))) {
	Locale.setDefault(locale);

	var custom = DateTimeFormatter
		.ofPattern("y-MM-dd");
	var local = DateTimeFormatter
		.ofLocalizedDate(FormatStyle.SHORT);
	var customLocal = DateTimeFormatter
		.ofLocalizedPattern("yMM");

	// pretty print
}

Pattern comparison

locale custom local both

locale	custom	local	both
en_US	`2023-10-02`	`10/2/23`	`10/2023`
be_BE	`2023-10-02`	`2.10.23`	`10.2023`
vi_VN	`2023-10-02`	`02/10/2023`	`tháng 10, 2023`

en_US

2023-10-02

10/2/23

10/2023

be_BE

2023-10-02

2.10.23

10.2023

vi_VN

2023-10-02

02/10/2023

tháng 10, 2023

Localized patterns

Analogue methods were added to DateTimeFormatterBuilder:

DateTimeFormatterBuilder appendLocalized(
	String requestedTemplate);

static String getLocalizedDateTimePattern(
	String requestedTemplate,
	Chronology chrono, Locale locale)

More AutoCloseable

These types now implemnet AutoCloseable:

HttpClient
ExecutorService
ForkJoinPool

A better future

Additions to Future<T>:

T resultNow()
Throwable exceptionNow
State state()

New:

enum State {
	RUNNING, SUCCESS, FAILED, CANCELLED
}

There are many more additions like this.

Find a few more in
🎥 Java 21 API New Features (Sep 2023)

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Generational ZGC

Class-Data Sharing

Usability

On-Ramp

Generational ZGC

Compared to other GCs, ZGC:

optimizes for ultra-low pause times
can have higher memory footprint or higher CPU usage

In Java 21, ZGC becomes generational.

Generational Hypothesis

most objects die young
those who don’t, grow (very) old

GCs can make use of this by tracking
young and old generations.

ZGC didn’t do this, but can do it now with:
-XX:+UseZGC -XX:+ZGenerational

Some Benchmarks

A Cassandra 4 benchmark of ZGC vs GenZGC showed:

4x throughput with a fixed heap or
1/4x heap size with stable throughput

(Probably not representative but very promising.)

📝 JEP 439: Generational ZGC
🎥 Generational ZGC and Beyond (Aug 2023)
🎥 Java’s Highly Scalable Low-Latency GC: ZGC (Mar 2023)

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Generational ZGC

Class-Data Sharing

Usability

On-Ramp

Class-Data Sharing

Use CDS to shave off 10-25% of your boot times.

Recent improvements:

default CDS archives ⑫ (JEP 341)
dynamic CDS archives ⑬ (JEP 350)
auto-generated CDS ⑲ (JDK-8261455)

And more to come from Project Leyden.

🎥 Java’s Startup Booster: CDS

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Generational ZGC

Class-Data Sharing

Usability

On-Ramp

Usability

JFR view command ㉑ (JDK-8306704)
JFR scrubbing ⑲ (JDK-8271585)
code snippets in Javadoc ⑱ (JEP 413)
UTF-8 by default ⑱ (JEP 400)
simple web server ⑱ (JEP 408)

Java 21 💣💥

Pattern Matching

Virtual Threads

String Templates

New & Updated APIs

Performance & More

Generational ZGC

Class-Data Sharing

Usability

On-Ramp

Starting (with) Java

Java 21 makes life easier
for new (Java) developers.

Why do we care?

We all know Java, IDEs, build tools, etc.

do we all?
what about your kids?
what about students?
what about the frontend dev?
what about ML/AI folks?

Java needs to be approachable!
Java needs an on-ramp for new (Java) developers!

Running Java

To write and run a simple Java program, you need:

a JDK
an editor (IDE?)
javac (build tool? IDE?)
java (IDE?)
some Java code

Writing Java

Minimal Java code:

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello, World!");
	}
}

visibility
classes & methods
static vs instance
returns & parameters
statements & arguments

Approachability

That’s a lot of tools and concepts!

Java is great for large-scale development:

detailed toolchain
refined programming model

This make it less approachable.

Let’s change that!

jshell

Java 9 added jshell:

all you need:
- tools: JDK, jshell
- concepts: statements & arguments
but:
- not great for beginners (IMO)
- no progression

More is needed.

Single-file execution

Java 11 added single-file execution (JEP 330):

java Prog.java

removed: javac
but: no progression

Much better for beginners,
but just a section of an on-ramp.

On-Ramp

Expand single-file execution in two directions:

simplify code: reduce required Java concepts
ease progression: run multiple files with java

Simpler code

Remove requirement of:

String[] args parameter
main being static
main being public
the class itself

// all the code in Prog.java
void main() {
	System.out.println("Hello, World!");
}

[Preview in Java 21 — JEP 445]

Running multiple files

Say you have a folder:

MyFirstJava
 ├─ Prog.java
 ├─ Helper.java
 └─ Lib
     └─ library.jar

Run with:

java -cp 'Lib/*' Prog.java

[Preview in Java 22 — JEP 458]

Progression

Natural progression:

start with main()
need arguments? ⇝ add String[] args
need to organize code? ⇝ add methods
need shared state? ⇝ add fields
need more functionality? ⇝ explore JDK APIs
even more? ⇝ explore simple libraries
need more structure? ⇝ split into multiple files
even more ⇝ use visibility & packages

Doesn’t even have to be that order!

Summary

Java’s strengths for large-scale development
make it less approachable:

detailed toolchain
refined programming model

There are new features that:

make it easier to start
allow gradual progression
entice the future dev generation

📝 JEP 445 for a simpler main
📝 JEP 458 for launching multiple source file
🎥 Script Java Easily in 21 and Beyond (May 2023)

So long…

37% off with
code fccparlog

bit.ly/the-jms

Slides at slides.nipafx.dev
⇜ Get my book!

Follow Nicolai

nipafx.dev
/nipafx

Follow Java

inside.java // dev.java
/java // /openjdk

Image Credits

modern colors: Pawel Czerwinski, Unsplash license
random generator API diagrams:
Nicolai Parlog (CC-BY-NC 4.0)
question-mark: Milos Milosevic, CC-BY 2.0