The document outlines the roadmap for Java innovations leading to Java 23, focusing on enhanced features for small application development, improvements in language syntax, and new APIs such as streamlined garbage collection and structured concurrency. Key highlights include project Amber's simplified programming approach and JEPs related to documentation comments, stream enhancements, and memory access. Additionally, it addresses performance challenges and comparisons with other programming languages, emphasizing Java's evolution in efficiency and usability.

1. JAVA 23 AND BEYOND
A ROADMAP OF INNOVATIONS
ANA-MARIA MIHALCEANU
Senior developer advocate at Oracle
ammbra1508 ammbra1508.mastodon.social

2. What Has Been Java Doing?
56
91
12
1…
8 5
16 14 1… 14
9 7 6
15
12 12
0
10
20
30
40
50
60
70
80
90
100
Features
(JEPs)
JDK 8 JDK 9 JDK 10 JDK 11 JDK 12 JDK 13 JDK 14 JDK 15 JDK 16 JDK 17 JDK 18 JDK 19 JDK 20 JDK 21
Mar
2024
Commercial
Support
3 Years 2 Years
JDK 22
Commercial
Support
Sept
2023
Mar
2023
Sept
2022
Mar
2022
Sept
2021
Mar
2021
Sept
2020
Mar
2020
Sept
2019
Mar
2019
Sept
2018
Mar
2018
Sept
2017
Mar
2014
Sept
2024
JDK 23
Commercial
Support
Commercial
Support

3. Inclusive Development Experience
🔗”Paving the On Ramp
As a result, it is easy to forget about the “small" programs
Java has been historically
successful in “big" systems
And we all start small
But, we want Java
to be successful
for small applications too
• OOP concepts should not overwhelm your first (or any
small) program
• The “on ramp" should lead smoothly onto the highway
”Paving the On Ramp”

4. A Simplified Beginning
Project Amber

5. // HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Launch via single file execution (since JDK 11)
java HelloWorld.java
Use jshell for fast prototyping Java code
Towards A Simplified Beginning

6. Paving The On Ramp (In Preview)
// HelloWorld.java
void main( ) {
println("Hello, World!");
}
public class HelloWorld {
public static String[] args
}
System.out.
JEP 477: Implicitly Declared Classes and Instance Main Methods (Third Preview)

7. Effective Scripting with Java
// HelloWorld.java
void main() {
println("Hello, World!");
}
JEP 477: Implicitly Declared Classes and Instance Main Methods (Third Preview)
Class declaration no longer required
main is not necessarily public static
String[] args not declared if not used further
Auto-import useful methods for textual input and output

8. One Command To Launch Them All
// HelloWorld.java
class HelloWorld {
void main() {
Helper.run();
}
}
// Helper.java
class Helper {
static void run() {
println("Hello World!");
}
}
java --enable-preview -HelloWorld.java
JEP 458: Launch Multi-File Source-Code Programs 22

9. Thoughtful Evolution of Java
Language Features
Project Amber

10. Agenda Prototype
• Add chores to do to.
• Delete a chore when is done.
• A chore can have either an URL or an image attached to it.
• The deadline for chore has to be greater than current date.
• The priority is deduced based on deadline.

11. Agenda Entity Modeling
Sealed types limit which subtypes can directly
extend/implement them.
public sealed interface Todo
permits TodoItem {}
public non-sealed class TodoItem
implements Todo {}
public final class URLTodoItem
extends TodoItem{}
public final class ImageTodoItem
extends TodoItem{}

12. Inheritance and Constructor Chaining
public final class URLTodoItem extends TodoItem {
private String url;
public URLTodoItem(String title, String description, String url,
LocalDate createdOn, LocalDate deadline) {
super(title, description, createdOn, validate(createdOn, deadline));
this.url = url;
}
private static LocalDate validate(LocalDate createdOn, LocalDate deadline) {
if (deadline.isBefore(createdOn))
throw new IllegalArgumentException(”Deadline must not be before creation date");
return deadline;
}
}
Constructor chaining is enforced in subclass.

13. Statements before super(…) (in preview)
public final class URLTodoItem extends TodoItem {
private String url;
public URLTodoItem(String title, String description, String url,
LocalDate createdOn, LocalDate deadline) {
if (deadline.isBefore(createdOn))
throw new IllegalArgumentException(”Deadline cannot be before creation date");
this.url = url;
super(title, description, createdOn, deadline);
}
}
Validate superclass constructor arguments
Prepare superclass constructor arguments
Share superclass constructor arguments
JEP 482: Flexible Constructor Bodies (Second Preview)

14. Determine Emergency Based on Priority
private static Highlight findColor(TodoItem item) {
return switch (item.getPriority()) {
case long p when p < 0 -> Highlight.RED;
case 0L -> Highlight.YELLOW;
case 1L -> Highlight.BLUE;
case long _ -> Highlight.WHITE;
};
}
JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview)

15. Primitive Type Patterns in Nested Context
public record Statistic(Highlight highlight, int count) {}
switch (statistic) {
case Statistic(Highlight h, byte b) when h == Highlight.RED && b < -10 -> …;
case Statistic(Highlight h, short s) when h == Highlight.YELLOW -> …;
case Statistic(Highlight h, int i) when h == Highlight.BLUE ->…;
case Statistic(Highlight h, int i) -> …;
}
JEP 455: Primitive Types in Patterns, instanceof, and switch (Preview)

16. Import All Packages Exported by a Module
import java.io.IOException;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
import module java.base;
JEP 476: Module Import Declarations (Preview)

17. So You Want to Know More…
• Java 23: Restoring the Balance with Primitive Patterns - Inside Java Newscast #66
• Clean Application Development with Records, Sealed Classes and Pattern Matching (2022)
• Java Records are "Trusted" and Consequently Faster
• State of Pattern Matching with Brian Goetz (2022)
• Pattern Matching in the Java Object Model
• Patterns: Exhaustiveness, Unconditionality, and Remainder
• Uniform handling of failure in switch

18. Fundamental Changes to
Achieve Your Application Goals
Core Libraries

19. A New Form of Documentation Comment
Markdown in Java documentation comments help with having:
• concise syntax for common constructs,
• reduce the dependence on HTML markup and JavaDoc tags,
• while keep enabling the use of specialized tags when not available in Markdown.
JEP 467: Markdown Documentation Comments

21. Valid Markdown Documentation Comments
Platform rules to identify the content of a Markdown documentation comment:
• Any leading whitespace and the three initial / characters are removed from each line.
• Then, the lines are shifted left, by getting rid of any extra spaces at their start.
• Any spaces that are part of the text itself are kept as those might actually mean something, like
starting a new code block.
JEP 467: Markdown Documentation Comments

22. Extra Capabilities
• Define simple GitHub Flavored Markdown pipe tables.
• Process standalone Markdown files from doc-files subdirectories.
• Standalone Markdown files can have JavaDoc tags , but YAML metadata is not supported.
• Enable syntax highlighting with Javascript libraries through javadoc --add-script.
• Render diagrams (like Mermaid).
JEP 467: Markdown Documentation Comments

23. Unfulfilled Streams Operations
• Streams API has a fixed set of intermediate operations.
List<String> letters = Arrays.asList("A","B","C","D","E","F","G","H");
int size = 3;
// ABC DEF GH
IntStream.range(0, (letters.size() + size - 1) / size)
.mapToObj(i -> String.join("",
letters.subList(i * size, Math.min(size * (i + 1), letters.size()))))
.toList();
Some intermediate operations are missing: sliding windows, take-while-including, fixed grouping,etc.

24. Enter Gatherers API (in preview)
• A generalization for intermediate operations java.util.stream.Gatherer
• A new intermediate stream operation to process elements of a stream: Stream::gather(Gatherer)
• A few implementations, e.g. Gatherers.fold(…), Gatherers.windowFixed(…).
• A way to compose gathererers source.gather(a.andThen(b).andThen(c)).collect(...).
List<String> letters = Arrays.asList("A","B","C","D","E","F","G","H");
int size = 3;
letters.stream()
.gather(Gatherers.windowFixed(3))
.map(window -> String.join("", window))
.toList();
JEP 473: Stream Gatherers (Second Preview)

25. Gatherer Components
Initializer (optional)
• Creates private state object
Integrator (mandatory)
• Accepts (state, element, downstream)
• Integrates element into state
• to update gatherer’s private state object
• to emit 0+ element(s) to downstream
Combiner (optional)
• Can evaluate the gatherer in parallel
Finisher (optional)
• Accepts (state, downstream)
• Invoked when no more elements can be consumed
• Emits element(s) to downstream

26. Compiling And Launching a Java Program
IDE javac java
.java source
file
bytecode .class
file
Program running

27. Bytecode Manipulation
Runtime
JVM
Class
loader .class
javac
jdeps
libraires
agents
frameworks

28. The New Class-file API (in preview)
• A stable Java API for analyzing and manipulating bytecode.
• An API always-up-to-date with the JDK version.
• Frameworks that use this API can easily update to a newer JDK version.
JEP 466: Class-File API (Second Preview)

29. So You Want to Know More…
• JavaDoc Hits the Markdown on Comments - Inside Java Newscast #68
• A Classfile API for the JDK (JVMLS 2023, Brian Goetz)
• New Class-File API will make Java Updates easier - Inside Java Newscast #56
• Teaching Old Streams New Tricks (Devoxx Belgium 2023, Viktor Klang)
• Better Java Streams with Gatherers - Inside Java Newscast #57

30. The Scalable, Low-latency
Generational ZGC
HotSpot

31. ZGC at a Glance
• Delivered in JDK 15 (September 2020)
• A scalable low-latency garbage collector
• ZGC pauses are O(1)
• Scalable: up to TB heaps
• Auto-tuning: requires minimal configuration
• Can handle heaps ranging from a 8MB to 16TB in size

32. Benefits of Generational ZGC
• Withstand higher allocation rates
• Lower heap headroom
• Lower CPU usage
• Now enabled by default when using -XX:+UseZGC
• Automatic Tuning -> Only set the max heap size! (-Xmx)
JEP 474: ZGC: Generational Mode by Default

33. What Changed?
• Did you enable ZGC it with -XX:+UseZGC -XX:+ZGenerational?
• Generational ZGC is used.
Warning that the ZGenerational option is deprecated is issued.
• Do you still need non-generational ZGC?
• You can enable it via -XX:+UseZGC -XX:-ZGenerational.
Warning that the ZGenerational option is deprecated is issued.
Warning that the non-generational mode is deprecated for removal is issued.
JEP 474: ZGC: Generational Mode by Default

34. So You Want to Know More…
• Overview of ZGC
• Deep-dive of zgc's architecture
• JVMLS - generational ZGC and beyond
• Optimizing memory utilization with automated heap sizing in ZGC
• Z garbage collector: the next generation
• ZGC : java’s highly scalable low-latency garbage collector - stack walker #1

35. Safe Concurrent Programming
Project Loom

36. Virtual Threads Adoption

37. Let’s Revisit Our Agenda
• Add chores to do to.
• Delete a chore when is done.
• A chore can have either an URL or an image attached to it.
• The deadline for chore has to be greater than current date.
• The priority is deduced based on deadline.
• Parse csv todo files when starting the application.

38. Structured Concurrency to the Rescue
// Success/failure policy can be defined across all children.
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
var baseTodo = scope.fork(() -> parseCSV(todoFile));
var urlTodo = scope.fork(() -> parseCSV(urlFile));
var mixTodo = scope.fork(() -> parseCSV(mixFile));
scope.join();
scope.throwIfFailed(IllegalStateException::new);
List<List<String>> data = baseTodo.get();
data.addAll(urlTodo.get());
data.addAll(mixTodo.get());
}
JEP 480: Structured Concurrency (Third Preview)

39. Simplify Data Flow Reasoning
public static ScopedValue<String> VALID_FILE = ScopedValue.newInstance();
ScopedValue.callWhere(VALID_FILE, todoFilePath, () ->
TodoFile.processContent(todoFilePath, urlFilePath, mixFilePath));
public static class FileScope extends StructuredTaskScope<TodoFile> {
//...
try (var scope = new FileScope()) {
scope.fork(() -> parseCSV(todoFile));
scope.fork(() -> parseCSV(urlFile));
scope.fork(() -> parseCSV(mixFile));
scope.join();
return scope.processContent();
}
}
JEP 481: Scoped Values (Third Preview)

40. Benefits for High Scaling Applications
Higher throughput with fewer CPU
operations when having high number
concurrent requests.
When having blocking calls, virtual
threads will go in a waiting state until they
receive data.

41. So You Want to Know More…
• Structured Concurrency
• On Parallelism and Concurrency
• Java 20 - From ThreadLocal to ScopedValue with Loom Full Tutorial - JEP Café #16
• Latest news on Project Loom

42. Broadened Ability to Develop
High-Performance Programs

43. Protecting Java Code from the JVM Up
• We rely on the integrity of our code, meaning it is correct and complete.
• There are 4 APIs in JDK that can bypass integrity:
• The AccessibleObject::setAccessible(boolean) method in the java.lang.reflect package
• The sun.misc.Unsafe class with methods that can access private methods and fields
• The Java Native Interface (JNI)
• The Instrumentation API allows agents to modify the bytecode of any method in any class.
• JEP 471 showcases the impact of sun.misc.Unsafe memory-access methods + offers migration examples.
JEP 471: Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal

44. Project Summary Pain point “Obvious"
Competition
Amber Right-sizing language ceremony
“Java is too verbose"
“Java is hard to teach"
C#, Kotlin
Babylon Foreign programming model interop “Using GPUs is too hard" LinQ, Julia
Leyden Faster startup and warmup “Java starts up too slowly" Go
Loom Lightweight concurrency
“Threads are too expensive, don’t
scale"
Go, Elixir
Panama
Native code and memory interop
SIMD Vector support
“Using native libraries is too hard"
“Numeric loops are too slow"
Python, C
Valhalla Value types and specialized generics
“Cache misses are too expensive"
“Generics and primitives don’t mix"
C, C#
ZGC Sub-millisecond GC pauses “GC pauses are too long" C, Rust

45. Learn, Share, and Collaborate

46. Stay Tuned for More
Inside.java
Dev.java youtube.com/java

47. THANK YOU!
Code