public sealed interface Page
permits GitHubIssuePage, GitHubPrPage,
ExternalPage, ErrorPage {
// ...
}Java 21 💣💥
Let’s get started!
this session covers Java 18-21
this is a showcase, not a tutorial
⇝ go to youtube.com/@java for moreslides 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
Pageinstances:GitHubIssuePageGitHubPrPageExternalPageErrorPage
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
Sealed Page
Sealed types limit inheritance,
by only allowing specific subtypes.
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
caseper subtypeavoiding the
defaultbranch
⇝ 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
More
More on pattern matching:
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
switchwithoutdefaultpattern 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
More
More on data-oriented programming:
📝 Data Oriented Programming in Java
(Brian Goetz on InfoQ)🎥 Java 21 Brings Full Pattern Matching (Sep 2023)
🧑💻 GitHub crawler
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
Threadlow 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 waitsExample
This laptop:
Intel i7-1165G7 (11th Gen)
8GB for JVM (32 GB total RAM)
Gentoo Linux (kernel v6.5.10)
Extremely rough measurements:
#threads | 1k | 10k | 100k | 500k | 1m | 5m |
run time | 1.0s | 1.1s | 1.3s | 3s | 6s | 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
Quarkus
Annotate request handling method on 3.?:
@GET
@Path("api")
@RunOnVirtualThread
public String handle() {
// ...
}(Source)
Helidon
Just works on 4.0 (currently RC1).
(Source)
More
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
synchronizedThread,currentThread, etc.thread interruption
thread-locals
native code
But not all scale perfectly.
Caveat #1: capture
Caveat #2: pinning
Some operations pin (operations don’t unmount):
native method call (JNI)
foreign function call (FFM)
synchronizedblock (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 copiedcan 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
synchronizedwith locks
Deprecations
Cleaning house
Cleaning house
Agents
What it is:
a component that transforms byte code
uses
java.lang.instrumentor JVM TIlaunches 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 defaultenable with
-XX:+EnableDynamicAgentLoading
Dynamic agents
What you need to do:
run your app with
-XX:-EnableDynamicAgentLoadingobserve closely
investigate necessity of dynamic agents
Finalization
What it is:
finalize()methodsa JLS/GC machinery for them
Finalization
What you need to know:
you can disable with
--finalization=disabledin a future release,
disabledwill be the defaultin a later release, finalization will be removed
Finalization
What you need to do:
search for
finalize()in your code and
replace withtry-with-resources orCleanerAPIsearch for
finalize()in your dependencies and
help remove themrun your app with
--finalization=disabledand
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 sectionsembodied by
SecurityManager
Security Manager
What you need to know:
barely used but maintenance-intensive
already disallowed by default
enable with
java.security.manager=allowin 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.
More
📝 all the aforementioned JEPs
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
~>StringTemplatetemplate processor (e.g.
STR):
transformsStringTemplateintoString*
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.186Template 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.19Why strings?
Often, strings are just exchange format, e.g.:
start with:
String+ valuesvalidate / 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:
SequencedCollectionSequencedSetSequencedMap
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()⇝ListIteratornavigableSet.descendingSet()⇝NavigableSet(view)deque.descendingIterator()⇝IteratorlinkedHashSet.🤷🏾♂️()
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
SortedSetcontractworks 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!
More
📝 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
hostsfile 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:
InetAddressResolverProviderInetAddressResolver
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?
More
📝 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/longdivision 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:
ofPatternwith 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 |
|---|---|---|---|
en_US |
|
|
|
be_BE |
|
|
|
vi_VN |
|
|
|
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:
HttpClientExecutorServiceForkJoinPool
A better future
Additions to Future<T>:
T resultNow()Throwable exceptionNowState state()
New:
enum State {
RUNNING, SUCCESS, FAILED, CANCELLED
}More
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.)
More
📝 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.
More
Java 21 💣💥
| Pattern Matching |
| Virtual Threads |
| String Templates |
| New & Updated APIs |
| Performance & More |
| Generational ZGC |
| Class-Data Sharing |
| Usability |
| On-Ramp |
Usability
JFR
viewcommand ㉑ (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,
jshellconcepts: 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.javaremoved:
javacbut: 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[] argsparametermainbeing staticmainbeing publicthe 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.jarRun with:
java -cp 'Lib/*' Prog.java[Preview in Java 22 — JEP 458]
Progression
Natural progression:
start with
main()need arguments? ⇝ add
String[] argsneed 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
More
📝 JEP 445 for a simpler
main📝 JEP 458 for launching multiple source file
🎥 Script Java Easily in 21 and Beyond (May 2023)
So long…
More
Slides at slides.nipafx.dev⇜ Get my book!
Follow Nicolai
nipafx.dev/nipafx
Follow Java
inside.java // dev.java/java // /openjdk
Image Credits
random generator API diagrams:
Nicolai Parlog (CC-BY-NC 4.0)
Java 21 💣💥
Nicolai Parlog
nipafx.dev
/ @nipafx
JUG München
Developer Advocate
Java Team at Oracle
Nicolai Parlog
/ nipafx.dev
/ @nipafx
JUG München
/