Modern Java

Past | Present | Future

Nicolai Parlog

nipafx.dev

HKA

Developer Advocate

Java Team at Oracle

Modern Java

Past

Present

Future

Our story begins in 1991

Then, in 1995

Flying high ⇝ 2004

Vale of tears ⇝ 2011

Which brings us to 2014

Java 8 gets released:

lambda expressions
streams, date/time, Optional

Begins Java’s revival.

Revival ⇝ 2023

Too many improvements in Java 9-21 for the time we have!

Language:

modules, var, text blocks, records, sealed types
pattern matching with instanceof and switch

APIs:

collection factories, sequenced collections
PRNG, HTTP/2, VarHandle, ProcessHandle
uncountable small additions

Runtime:

virtual threads, compact strings
big strides for G1 and ZGC
performance gains across the board

Tooling:

jshell, jlink, jpackage, jwebserver

Revival ⇝ 2023

Organizational changes:

move to Git & GitHub
mailing list update 🙈
six-month release cadence
two-year LTS cadence

Which reminds me…

🎥 Java 21 is no LTS Version

Going from Java 17 to 21:

Modern Java

Past

Language Features

New APIs

Runtime Improvements

Better Tooling

Present

Future

🎥 Java 25 is ALSO no LTS Version

🎥 How to Upgrade to Java 25

Modern Java

Past

Language Features

New APIs

Runtime Improvements

Better Tooling

Present

Future

Flexible Constructor Bodies

class ThreePartName extends Name {
	private final String middle;

	ThreePartName(String full) {
		// split "first middle last" on space
		var names = full.split(" ");
		// assign fields before `super`
		this.middle = names[1];
		// call `Name(String first, String last)`
		super(names[0], names[2]);
	}
}

Unnamed patterns

Use _ to mark a (pattern) variable as unused, e.g.:

BiConsumer<String, Double> = (s, _) -> // use `s`

Object obj = // ...
if (obj instanceof User(var name, _))
	// use `name`

switch (obj) {
	case User _ -> userCount++;
	case Admin _ -> adminCount++;
}

Module Imports

import module $mod;

imports public API of $mod
your code does not need to be in a module

Simplified Main

Get started quicker:

// entire source file
// implicit `import module java.base`
void main() {
    var name = IO.readln("Please enter your name: ");
    IO.println("Nice to meet you, " + name);
}

(Execute with: java Main.java)

🎥 All New Java Language Features Since Java 21

Modern Java

Past

Language Features

New APIs

Runtime Improvements

Better Tooling

Present

Future

Stream Gatherers

Create custom stream operations:

Stream.of("A", "C", "F", "B", "S")
	.gather(groups(2))
	.forEach(IO::println);

// [A, C]
// [F, B]
// [S]

Scoped Values

Simpler, more scalable, one-way alternative to ThreadLocal:

static final ScopedValue<Integer> ANSWER =
	ScopedValue.newInstance();

void main() {
	ScopedValue //      ⬐ VALUE
		.where(ANSWER, 42)
		//  |<---------- SCOPE ----------->|
		.run(() -> IO.println(ANSWER.get())); // "42"

	// OUT OF SCOPE
	ANSWER.get(); // ⚡️ NoSuchElementException
}

FFM API

Allows interaction with

native libraries (foreign functions)
off-heap memory (foreign memory)

Replaces JNI, ByteBuffer and parts of Unsafe
with a better, safer, and supported API.

Class-file API

A modern, on-board bytecode manipulation API:

allows frameworks and libraries
to drop dependency on ASM et al.
removes a big reason for:

~~Update all dependencies before updating the JDK.~~

🎥 All API Additions From Java 21 to 25

Modern Java

Past

Language Features

New APIs

Runtime Improvements

Better Tooling

Present

Future

Multi-File Execution

Small programs can expand:

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

Run with:

java -cp 'Lib/*' Main.java

Compact object headers

Reduce object headers from (usually) 12 bytes to 8 bytes:

-XX:+UseCompactObjectHeaders

reduces heap size by 5-30%
can reduce garbage collections
can improve or deteriorate
overall performance

Report observations to hotspot-dev.

Generational ZGC

Less virtual thread pinning

Virtual threads:

execute on a platform thread
usually unmount from PT when waiting
pinning prevents that
caused by native calls, class initialization, and
~~object monitors (e.g. synchronized)~~

Object monitors were reimplemented.

⇝ No more pinning for synchronized.

Performance improvements

Every Java release improves performance, e.g.:

+10%/+5% critical/max jOPS in SPECjbb 2015
+70-75% requests/s on Helidon

(JDK 25 vs 21)

Security enhancements

Many enhancements between Java 21 and 25:

improved security configurations
(JDK-8051959, JDK-8281658, JDK-8311596, file inclusion)
quantum-resistant cryptography
(JEP 486, JEP 496, JEP 497, JEP 510)
various improvements in cryptographic algorithms

🎥 How to Handle Security Changes in Java 25

Modern Java

Past

Language Features

New APIs

Runtime Improvements

Better Tooling

Present

Future

JFR improvements

JDK Flight Recorder got better:

cooperative sampling (JEP 518)
method timing & tracing (JEP 520)
CPU-time profiling (JEP 509, experimental)

🎥 Java 21 ⮕ 25: Performance and Runtime Enhancement

Markdown in Javadoc

/// Returns `true` if, and only if,
/// [#length()] is `0`.
///
/// @return `true` if [#length()] is `0`,
//          otherwise `false`
/// @since 1.6
@Override
public boolean isEmpty() { /* ... */ }

Going from Java 21 to 25:

🎥 Road to 25

Generally:

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

HTTP client

Java’s HTTP API:

HttpClient client = HttpClient.newBuilder()
	.version(HTTP_2)
	.build();

HttpRequest request = HttpRequest.newBuilder()
	.uri(URI.create("https://dev.java"))
	.build();

var response = client
	.send(request, BodyHandlers.ofString());

HTTP/3

It now supports HTTP/3:

HttpClient client = HttpClient.newBuilder()
	.version(HTTP_3)
	.build();

HttpRequest request = HttpRequest.newBuilder()
	.uri(URI.create("https://dev.java"))
	.version(HTTP_3)
	.build();

Connection upgrades

Network stacks:

HTTP/1.1 and 2 use TCP
HTTP/3 uses QUIC over UDP

⇝ Can’t upgrade a connection to /3.

Check documentation for version selection.

HTTP/3 is final in JDK 26.

📝 JEP 517: HTTP/3 for the HTTP Client API
🎧 HTTP/3 in Java 26 - Inside Java Podcast 48

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

Quantum computers

The fusion reactors of computer science

Today:: Can barely factor 35 into 5*7 (source).
Soon™:: Can factor numbers in polynomial time and space
(and thus break many encryption algorithms).
In the meantime:: Harvest now, decrypt later.

Post-quantum encryption

NIST standardized module-latice based algorithms:

ML-KEM to secure symmetric keys (FIPS 203)
ML-DSA for digital signatures (FIPS 204)

IETF developed a framework for
hybrid key exchange schemes for TLS 1.3 (RFC 9954).

PQC in Java

Java implements:

ML-KEM (JEP 496) ㉔
ML-DSA (JEP 497) ㉔
hybrid key exchange for TLS 1.3 (JEP 527) ㉗

Oracle announced backports to
Oracle JDKs 25, 21, 17, 11, 8.

🎥 Java Gets Post-Quantum TLS
📝 Cryptographic Roadmap

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

Performance

Continuous performance improvements, e.g.:

reduced virtual thread pinning (JDK-8369238) ㉖
G1 across the board (particularly JEP 522) ㉖㉗
G1 becomes true default GC (JEP 523) ㉗
compact object headers by default (JEP 534) ㉗

And many, many more: JDK 26, JDK 27.

characteristics

Java has really good peak performance,
but also tends to have:

slow startup time
slow warmup time

This is due to a lot of early work
(e.g. class loading, profiling, JIT).

AOTCache

Project Leyden introduces the AOTCache:

observe the JVM
capture decisions in an AOTCache
use as "initial state" during future run
fall back to live observation/optimization
if necessary and possible

AOT computation

Creating and using the AOTCache:

# training run (⇝ AOTCache)
$ java -XX:AOTCacheOutput=app.aot
       -cp app.jar com.example.App ...
# production run (AOTCache ⇝ performance)
$ java -XX:AOTCache=app.aot
       -cp app.jar com.example.App ...

Class loading & linking

Improve startup time by making the classes of an application instantly available, in a loaded and linked state, when the HotSpot JVM starts.

Spring PetClinic benchmarks:

up to ~40% startup time reduction
AOT cache size of ~130 MB

Method profiling

Improve warmup time by making method-execution profiles from a previous run of an application instantly available, when the HotSpot Java Virtual Machine starts.

Benchmark of a 100_000x loop over a simple stream:

~20% run time reduction
AOT cache size increased by ~2.5%

Streaming cached objects

Making it possible to load cached Java objects sequentially into memory from a neutral, GC-agnostic format.

allows use of any garbage collector
does not block when initializing heap
takes longer for warm starts and
requires a CPU core

(Note: The cache contains no application instances.)

Code Compilation

Improve startup and warmup time by making optimized native code for an application instantly available when the HotSpot JVM starts.

Benchmarks with javac:

~15% startup time reduction
~75% fewer warmup iterations

AOT limitations

for code compilation: AArch64 or x64
training vs production:
- same JDK release / architecture / OS
- for code compilation: same CPU features & GC
- consistent class path
- consistent module options
limited use of JVMTI agents

Otherwise, unsuitable portions are ignored.

📝 JEP 483: AOT Class Loading and Linking ㉔
📝 JEP 515: AOT Method Profiling ㉕
📝 JEP 514: AOT CLI Ergonomics ㉕
📝 JEP 516: AOT Object Caching with Any GC ㉖
📝 JEP 544: AOT Code Compilation ㉘

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

PEM texts

Representations of cryptographic objects
(keys, certificates, certificate revocation lists):

-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj
0DAQcDQgAEi/kRGOL7wCPTN4KJ
2ppeSt5UYB6ucPjjuKDtFTXbgu
OIFDdZ65O/8HTUqS/sVzRF+dg7
H3/tkQ/36KdtuADbwQ==
-----END PUBLIC KEY-----

PEM API

PEM API encodes and decodes cryptographic objects:

X509Certificate cert = // ...

// encode
PEMEncoder encoder = PEMEncoder.of();
String pem = encoder.encodeToString(cert);

// decode
PEMDecoder decoder = PEMDecoder.of();
BinaryEncodable cert2 = decoder.decode(pem);

assert cert.equals(cert2);

Encodable

All implementations of BinaryEncodable can be encoded:

AsymmetricKey
(DH, DSA, EC, RSA, etc.)
KeyPair
PKCS8EncodedKeySpec
X509EncodedKeySpec
X509Certificate
X509CRL
EncryptedPrivateKeyInfo
PEM

Decoding

For decoding:

if the object type is known, call
decode(String, Class<T extends BinaryEncodable>):
```
KeyPair kp = decoder.decode(pem, KeyPair.class);
```
otherwise, switch over return value of decode(String)

The PEM API is final in JDK 28.

📝 JEP 542: PEM Encodings of Cryptographic Objects
🎥 Java 25 Encodes PEM

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

Structured concurrency

When the flow of execution splits into multiple concurrent flows, they rejoin in the same code block.

Term coined/refined by:

Martin Sustrik, Structured Concurrency
Nathaniel J. Smith, Notes on structured concurrency […]

Structured concurrency

String executeTasks() throws InterruptedException {
	// implicitly short-circuits on error
	try (var scope = StructuredTaskScope.open()) {
		Subtask<String> taskA = scope.fork(this::doA);
		Subtask<String> taskB = scope.fork(this::doB);

		// wait explicitly for success
		// (throws errors if there were any)
		scope.join();

		// all tasks succeeded
		return taskA.get() + taskB.get();
	} catch (FailedException ex) {
		return ex.getMessage();
	}
}

Properties

Threads are short-lived:

start when task begins
end on completion

⇝ Establishes parent-child/sibling relationships
and logical grouping of tasks/threads.

Completion

Use Joiner to configure success/failure policy:

how are results collected?
when are subtasks cancelled?
when does join throw?

Pass to StructuredTaskScope.open(Joiner).

Any successful

try (var scope = StructuredTaskScope.open(
		Joiner.<String> anySuccessfulOrThrow())) {
	// no need to grab the `Subtask` instances
	scope.fork(this::taskA);
	scope.fork(this::taskB);

	// returns the first successful result
	return scope.join();
} catch (FailedException ex) {
	// TODO: handle task errors
}

Structured concurrency

Benefits:

defines a scope for concurrency
simplifies control flow
simplifies grouped result/error handling
makes thread relationships visible
(in thread dumps and soon🤞 debuggers)

The structured concurrency API will probably finalize in JDK 28.

📝 JEP 543: Structured Concurrency
📝 Structured Concurrency
📝 Notes on structured concurrency […]
🎥 Structured Concurrency Revamp in Java 25

Modern Java

Past

Present

HTTP/3

PQC

Performance

PEM

Structured Concurrency

Deprecations & Removals

Future

Cleaning house

Already removed:

macOS/x64 port ㉘ (JEP 541)
applet API ㉖ (JEP 504)
32-bit x86 ports ㉕ (JEP 503)
security manager ㉔ (JEP 486)
biased locking ⑱ (JEP 374, JDK-8256425)
RMI activation ⑰ (JEP 407)
Nashorn ⑮ (JEP 372)
concurrent mark sweep GC ⑭ (JEP 363)

Cleaning house

Deprecated (for removal)

finalization ⑱ (JEP 421)
memory access via Unsafe ㉔ (JEP 498)

Integrity by default

Disallow by default:

mutating final fields ㉖ (JEP 500)
JNI ㉔ (JEP 472)
dynamic agents ㉑ (JEP 451)

📝 JEP draft: Integrity by Default
🎥 Why Is Integrity by Default So Important?
🎥 Future Java - Prepare Your Codebase Now!
🎥 How to Upgrade to Java 21 and Java 25

Modern Java

Past

Present

Future

Amber’s Arc

Leyden’s Arc

JSON (no Arc)

Valhalla’s Arc

Babylon’s Arc

Patterns so far…

In instanceof and switch, patterns can:

match against reference types
deconstruct records
nest patterns
ignore parts of a pattern

In switch:

refine the selection with guarded patterns

Patterns so far…

That (plus sealed types) are
the pattern matching basics.

This will be:

built up with more features
built out to re-balance the language

Case in Point

The x instanceof Y operation:

meant: "is x of type Y?"
now means: "does x match the pattern Y?"

For primitives:

old semantics made no sense
⇝ no x instanceof $primitive
new semantics can make sense

Bound Checks

Example A: int x = 0;

x can’t literally be an instance of byte
but its value can be a byte

Example B: int y = 16_777_217;

y can’t literally be an instance of float
it can be cast to a float but not losslessly

Conversion checks

Primitive patterns for simpler conversion checks:

int x = 0;
if (x instanceof byte b)
	IO.println(b + " in [-128, 127]");

int y = 16_777_217;
if (y instanceof float f)
	IO.println(f + " is a float (lossless)");

(Probably sixth preview in JDK 28.)

Strawman syntax

Everything coming next is speculative,
particularly the syntax!

⚠️

Constant checks

Constant patterns for simpler primitive checks:

record Point(int x, int y) { }

var point = // ...
switch (point) {
	// primitive pattern
	case Point(var x, _) when x == 0 -> // ...
	// constant pattern (probably)
	case Point(0, _) -> // ...
}

Currently, only records can be deconstructed.

Deconstructible interfaces

Expand deconstruction to other types:

// ↙ INTERFACE   ↙ state description
interface Point(int x, int y) {
	// state description implicitly requires:
	// int x();
	// int y();
}

// would allow
var point = // ...
switch (point) {
	case Point(var x, var y) -> // ...
}

Deconstruction on assignment

Often, there’s no need for the conditional.

Deconstruction on assignment is unconditional:

// `Point` is a type with state description
Point nextPoint() { /* ... */ }

// if you only need `x`
Point(int x, _) = nextPoint();

Reconstruction

If the type has a symmetrical construction protocol
(like records):

record Point(int x, int y) { }

var p0 = new Point(0, 0);
var p1 = p0 with { x = 1; };

Patterns and deconstruction:

📝 JEP 532: Primitive Types in Patterns
🎥 Restoring the Balance with Primitive Patterns
📝 JEP draft: Enhanced Local Variable Declarations
📝 JEP 468: Derived Record Creation
📝 mails #1, #2 on deconstruction of classes

Other endeavors:

string templates (yes, still)
🎥 talks #1, #2 on serialization 2.0
📝 JEP draft: Concise Method Bodies

Modern Java

Past

Present

Future

Amber’s Arc

Leyden’s Arc

JSON (no Arc)

Valhalla’s Arc

Babylon’s Arc

Project Leyden

Introduced the AOTCache in JDK 24
and has expanded it ever since.

But is not done yet!

Project Leyden

Specific explorations:

allow tradeoff between
portability and peak performance
iterative training
better inspectability of training data

General goals:

more startup/warmup improvements
better usability

📝 project page
🎧 AOT Caching - Netflix' Practice vs OpenJDK’s Theory (September 2026)
📝 Thoughts on Training Runs (September 2024)

Modern Java

Past

Present

Future

Amber’s Arc

Leyden’s Arc

JSON (no Arc)

Valhalla’s Arc

Babylon’s Arc

JSON API

A simple API to parse, traverse, and format JSON:

var jsonDoc = """
	{
		"users": [
			{ "name": "John Doe" },
			{ "name": "Jane Doe" }
		]
	}
	""";

JsonValue json = Json.parse(jsonDoc);

JsonValue

public sealed interface JsonValue permits
		JsonObject, JsonArray, JsonNull
		JsonString, JsonNumber, JsonBoolean {

	// ...

}

JsonValue API

String asString();
double asDouble();
long asLong();
int asInt();
boolean asBoolean();

List<JsonValue> asList();

Map<String, JsonValue> asMap();
JsonValue get(String name);
JsonValue get(int index);

Optional<JsonValue> tryGet(String name);
Optional<JsonValue> tryValue();

Using JsonValue

JsonValue json = Json.parse(jsonDoc);
// if structure is known
var name = json
	.get("users")
	.get(0)
	.get("name");
var names = json
	.get("users")
	.asList().stream()
	.map((JsonValue user) -> user.get("name"))
	.toList();

Using JsonValue

JsonValue json = Json.parse(jsonDoc);
// if structure is unknown
switch (json) {
	case JsonString string -> // ...
	case JsonNumber number -> // ...
	// ...
}

Advanced features

This API is a "JSON starter set":

no parsing configuration
no streaming
no data binding

Advanced features are left to ecosystem projects.

The JSON API is incubating for the first time in JDK 28.

📝 JEP 540: Simple JSON API (Incubator)

Modern Java

Past

Present

Future

Amber’s Arc

Leyden’s Arc

JSON (no Arc)

Valhalla’s Arc

Babylon’s Arc

Valhalla reset

You’ve probably heard a lot about Project Valhalla:

indirection and flattening
object headers and density
identity and custom primitives
universal and specialized generics
performance benefits

Forget all that for now!

Identity

Current state:

all reference types have identity
identity distinguishes objects
many equal immutable objects are interchangeable
(e.g. two LocalDate.of(2026, 7, 31))

For many immutable classes:

identity is meaningless
identity can cause confusion
identity comes with a run-time cost

Wouldn’t it be nice to be able to opt out of identity?

Value classes

Enter JEP 401 in JDK 28 with --enable-preview:

We introduce value objects to model simple immutable data. A value object is an instance of a value class, declared with the value modifier. Classes without the value modifier are identity classes, and their instances are identity objects.

Platform value classes

With previews enabled, 30 JDK classes are value classes:

primitive wrappers
Optional types
many date/time API types

Custom value classes

You can create your own by adding value:

value class ComplexNumber {
	// ...
}

value record Point(int x, int y) {
	// ...
}

(Fun fact: The only new syntax is value.)

Business as usual

In most respects, value objects work the way that objects have always worked in the language: They have fields and methods, they are handled by reference, and their references can be null.

Declaration differences

Declaration site restrictions:

fields and class are final
can’t extends identity classes
(except java.lang.Object)
by default, construction code runs
during early construction

Behavioral differences

Behavioral differences vs identity classes:

new may not allocate a fresh object
== does a field-wise comparison

Behavioral restrictions:

no deep reflection
no object monitor interaction
no finalization
limited serialization (records or proxies)
no GC interaction

What other benefits can we get?

Optimizations

Optimization of value objects:

JVM can flatten and scalarize some references
flattening is limited to small values
scalarization is more universally applicable

But, as (almost) always in Java:

write maintainable code
use constructs semantically
rely on JVM for optimization

Future work

Project Valhalla has a long way to go:

manage nullity and atomicity to increase flattening
introduce type classes for limited operator overloading
add universal and specialized generics
for a better language and more flattening

Value classes have their first preview in JDK 28.

📝 JEP 401: Value Objects (Preview)
📝 State of Valhalla
🎥 Valhalla - Java’s Epic Refactor (Dec 2024)
🎥 Growing the Java Language (Aug 2025)

Modern Java

Past

Present

Future

Amber’s Arc

Leyden’s Arc

JSON (no Arc)

Valhalla’s Arc

Babylon’s Arc

Motivation

Java is adjacent to other programmable systems:

GPUs and FPGAs
SQL databases
differentiable functions

Allow programming them with Java code.

Project Babylon

Don’t adapt to each realm in a separate project.

Instead:

make Java code accessible
provide API to read and transform it
let ecosystem provide adaptions

Code Reflection

Babylons’s central mechanism is code reflection:

enhancement of "regular" reflection
reaches down into methods/lambdas
symbolic representation of (Java) code

These are called code models.

NIH?

Abstract syntax tree:

constructed during compilation
closely aligned with Java grammar
too much syntactic info

Bytecode:

created by compiler
specified by JVM Specification
too little important info

Code Models

The code model design is heavily influenced by the design of data structures used by many modern compilers to represent code. These data structures are commonly referred to as Intermediate Representations (IRs). The design is further influenced by Multi-Level Intermediate Representation (MLIR), a sub-project of the LLVM Compiler Infrastructure project.

Code Models

Identify code (e.g. with annotation):

@CodeReflection
static double sub(double a, double b) {
   return a - b;
}

Then:

compiler creates code model
stored in class files
accessible via reflection API
can be transformed by Java code

📝 JEP draft: Code Reflection
📝 Optimizing GPU Programs from Java using Babylon and HAT January 2026
📝 Code Models (Dec 2025)
📝 Accelerating Java on Parallel Architectures (Oct 2024)
🎥 Java for AI (Oct 2025)
🎥 Writing GPU-Ready AI Models in Pure Java (Oct 2025)
🎥 ONNX Based Generative AI LLMs in Java (Nov 2025)

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: Martin Martzs, Unsplash license
question-mark: Milos Milosevic (CC-BY 2.0)

Modern Java

Past | Present | Future

Modern Java

Our story begins in 1991

Then, in 1995

Flying high ⇝ 2004

Vale of tears ⇝ 2011

Which brings us to 2014

Revival ⇝ 2023

Revival ⇝ 2023

More

Modern Java

Modern Java

Flexible Constructor Bodies

Unnamed patterns

Module Imports

Simplified Main

Modern Java

Stream Gatherers

Scoped Values

FFM API

Class-file API

Modern Java

Multi-File Execution

Compact object headers

Generational ZGC

Less virtual thread pinning

Performance improvements

Security enhancements

Modern Java

JFR improvements

Markdown in Javadoc

More

Modern Java

HTTP client

HTTP/3

Connection upgrades

More

Modern Java

Quantum computers

Post-quantum encryption

PQC in Java

More

Modern Java

Performance

characteristics

AOTCache

AOT computation

Class loading & linking

Method profiling

Streaming cached objects

Code Compilation

AOT limitations

More

Modern Java

PEM texts

PEM API

Encodable

Decoding

More

Modern Java

Structured concurrency

Structured concurrency

Properties

Completion

Any successful

Structured concurrency

More

Modern Java

Cleaning house

Cleaning house

Integrity by default

More

Modern Java

Patterns so far…​

Patterns so far…​

Case in Point

Bound Checks

Conversion checks

Strawman syntax

Patterns so far…

Patterns so far…

So long…