Thread by @nipafx

Here are 11 improvements you get when updating to #Java16 later today: from records and type patterns to `Stream`-additions and Unix domain sockets, from creating installers to more performance and observability. 🧵👇🏾

(Longer form with tons of links: nipafx.dev/java-16-guide/)

#1 Records

Express in a single line that a type is just a collection of data without need for encapsulation and let the compiler do the rest:

record Range(int low, int high) { }

That results in almost the same API as the attached class. *drops mic*

#2 Type Pattern Matching

This is actually two-for-one:

* first step into pattern matching
* type patterns with `instanceof`

With a type pattern you check whether a variable is of a certain type and, if so, create a new variable of that type, so you can use it without casting.

#3 Sealed Classes (Preview)

Want to express that a type can be extended not by all types (as per default) or none (final) but just a select few? With sealed types you can do just that!

Beyond expressing intend, this will come in real handy when we get type patterns in switch.

#4 `Stream` Improvements

Is `flatMap` too slow or doesn't work with a pseudo-collection? Use `mapMulti` instead:

// plus wildcards
<R> Stream<R> mapMulti​(BiConsumer<T, Consumer<R>> mapper)

Also new: `toList`:

// tired
.collect(Collectors.toList())
// wired
.toList()

#5 HTTP/2 Improvements

If you have an `HttpRequest` and want to create a similar one, you can now clone it to a new builder with an overload for `newBuilder`.

If you have several `BodyPublisher`s whose output you want to concatenate, `BodyPublishers::concat` is there for you.

#6 Unix Domain Sockets

The `ServerSocketChannel` and `SocketChannel` classes can now use Unix domain sockets, which are faster and safer (yet limited to connections on the same host). This works on Linux, Mac, and Windows 10 / Windows Server 2019.

#7 Foreign Linker and Foreign-Memory Access (Preview)

I'll just quote the JEPs:

"Replace JNI with a superior pure-Java development model."

"A single API should be able to operate on various kinds of foreign memory (e.g., native memory, persistent memory, managed heap memory)."

#8 Vector API (Preview)

Another Project Panama incubator, this one unlocks SIMD programming in Java for more performance:

"vector computations that reliably compile at runtime to optimal vector hardware instructions on supported CPU architectures"

(Code by @gunnarmorling)

#9 Remote JFR Streaming

It is now possible to stream JFR events over JMX. A remote streaming connection from the server (running the app) to the client (running the JFR tool) writes the same kind of file as an app on the client would, so existing JFR tools require little change.

#10 Packaging Tool

With jpackage, you can create platform-specific packages that can then be installed as is common for each OS:

$ jpackage --name myapp --input lib --main-jar main.jar

Supported formats:

* Linux: deb, rpm
* macOS: pkg, dmg
* Windows: msi, exe

#11 Performance

As each Java version, 16 ships with a lot of performance-related work. All these got better:

* Hotspot
* Parallel GC
* G1
* ZGC
* Shenandoah

If you're in the cloud, more performance equals fewer costs - maybe this convinces your CTO to let you get past 11. 😉

#Bonus - Deprecations and Limitations

Primitive wrapper constructors are deprecated for removal and synchronizing on such instances yields warnings.

The module system now strongly encapsulates internals for code on the class path, i.e. `--illegal-access=deny` becomes default.

PS: I'm throwing a #Java16 release party later today (1800 UTC) on Twitch with code, guests, beet, pizza, and a lot of fun. Maybe I'll see you there.

twitch.tv/nipafx