In two weeks, #Java19 will be released with some of Java's most anticipated features: virtual threads and structured concurrency! 🤩

To make the best use of virtual threads, servers/frameworks need to support them - here's a list of those that do (reply with those I missed). 🧵 📣 All of this is still experimental!

Virtual threads and the new APIs are (you need `--enable-preview` and the incubator module `jdk.incubator.concurrent` to use them) and so is support in these projects. You can help them mature over the next months by testing with your app.

#Java18 comes out later today - what can you expect from Java's newest release? Here's a 🧵 with one tweet per feature - short and sweet.

For more details and links, read this blog post: nipafx.dev/inside-java-ne…
For questions, join our #JDK18 AMA later today. 👇🏾

https://twitter.com/BillyKorando/status/1505597399275876359

Pattern Matching for `switch` (2nd preview)
openjdk.java.net/jeps/420

Changes:
* constant case labels must now appear before guarded patterns of the same type
* exhaustiveness checking is now more precise when sealed classes and generics mix

Another preview is expected in #JDK19.

#ProjectLoom's virtual threads will make high performance in concurrent systems attainable with much simpler code. But Loom aims for even more and wants to make the code clearer and more robust by introducing *structured concurrency*.

Here's what that's all about. 🧵 Important: This is about concurrency, not parallelism. See yesterday's thread 👇🏾 for a more detailed distinction, but the gist is that concurrency is about processing lots of tasks that the environment throws at your system at the same time, ideally with high throughput.

https://twitter.com/nipafx/status/1472906786650959884

What's it called when multiple threads execute at the same time? Parallelism? Concurrency? 🤔 Is there a difference? (Spoiler: Yes!)

Let me explain in a few tweets, ripping off @pressron's #InsideJava blog post "On Parallelism and Concurrency". 🧵

inside.java/2021/11/30/on-… Parallelism:
Taking a task and splitting it up, so multiple CPUs can compute partial solutions in parallel to solve the task in less wall-clock time.

Concurrency:
Having a number of tasks that need to be arranged in a way that solves as many of them per $time_unit as possible.

I'm no security expert and don't know how ubiquitous this vulnerability is, but if you use Log4J 2.x, you should probably update to 2.15.x and read these:

logging.apache.org/log4j/2.x/secu…
lunasec.io/docs/blog/log4… Here's something else you can do until the updates are rolled out.

https://twitter.com/volker_simonis/status/1469256987196100608

From compact record constructors to pattern matching, from generic wildcards to chaining predicates and comparators, from jpackage to jlink - here are 11 #Java tricks handpicked from dev.java. 🧵

(Musical version of this thread: )

0/11 A #record's *canonical* constructor has one arg per component but in its *compact* form, you don't have to list them. You also don't have to (in fact, can't) assign fields, just do the checks/reassignments you need, rest happens automatically.

More: dev.java/learn/using-re…

1/11

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*

"Towards better serialization!"

That's a guiding light of #ProjectAmber and record serialization is the first step. The Inside Java Podcast episode on that topic with Julia Boes and @chegar999 (inside.java/2021/03/08/pod…) gives great insight into how it achieves that. 🧵

1/10 First, what's wrong with regular serialization? In short:

* extralinguistic mechanism (aka "magic")
* undermines encapsulation
* causes security issues
* hinders evolving code
* holds back new Java features

In long (and why it turned out that way), see attached thread.

2/10

https://twitter.com/nipafx/status/1359835273992019969

Do you dream of "value types" in Java? So do I! Hence I was thrilled to see that Project Valhalla is slowly coming out of exploration with two draft JEPs.

Here's what they currently propose. 🧵👇🏾

(If you prefer video: https:/www.youtube.com/watch?v=WBvTilbh8S0&t=344s)

1/10 First, why value types? To bridge the divide between

* primitives (fast, no memory overhead) and
* reference types (abstraction, safety, identity)

As is, we sometimes have to choose between performance and design. And we often choose wrongly.

2/10

"When people ask me what feature do I most regret, serialization is the easy answer" - @BrianGoetz

Let's talk about serialization in Java: Why does it exist? What are the problems (even today)? Would Java have been better off without it? Can it be fixed?

1/11 NB: What follows is mostly quotes or paraphrasing from a conversation I had with Brian during my 25-hour live stream. If you want to watch the full discussion about serialization, nullability, primitives, and more, you can find it here:

2/11

Project Amber is making progress on pattern matching in #JavaNext. Here are three recent developments that I'm very excited about and I think you will be as well.

(Caveats: these are ongoing discussions; none of this is final; speculation and strawman syntax ahead) 1. "Array patterns" allow matching and destructuring arrays. The `if`-line does three things:

a) is `objects` a `String` array with length 2?
b) if so, cast it to `String[]` and extract the two elements
c) declare `a` and `b` and assign the two elements to them

Yesterday evening, we spent about two hours digging through the German #Corona app and I'm thoroughly impressed. This is a modern project, developed out there as free software (APL 2.0) on GitHub, and it has stellar documentation.

github.com/corona-warn-app

Let's have a look! 1/🧵 Android and iOS apps use Google's/Apple's Exposure Notification Framework (ENF; google.com/covid19/exposu…, apple.com/covid19/contac…). Android app is written in Kotlin, iOS app in Swift. (Can't tell you much more because I'm clueless about mobile.)

2/22

The electoral swing analysis ("Wählerwanderung") of yesterday's state elections in Germany (e.g. @diezeit, zeit.de/politik/deutsc…) is pretty interesting and I want to comment on who switched to the radical right-wing #AfD.

🖗 Thread All numbers are relative swing from [voters of $party in 2014 who voted in 2019] to [voters of AfD in 2019] for Sachsen / Brandenburg, i.e. "the usual numbers" normalized by 2019 voters.

In order of their share lost to #AfD, here are the big parties and then former non-voters...

I just got my (electronic) copy of #EffectiveJava3E and am reading the new parts. Will tweet a little about it... Nothing spectacular going on with Optional (of course I started with that, what did you think?!) until close to the end. "Optional fields are a smell, but here's an example, where it's justified".

HarHar, I'm just gonna leave this here: blog.codefx.org/java/stephen-c…

#EffectiveJava3E