This is definitely a big release! Lots of changes and improvements in this language.

Lots of possibilities in the JVM to monkey-patch some behavior. Most of them are a bit involved though.

This is definitely a big deal for the Java type system and its ergonomics.

This would be an interesting extension to the Java Stream API. Maybe one day it'll make its way to the standard...

Is the graphics community warming up to the JVM? Or is it the other way around? Let's see if it makes progress in any case.

Very interesting study on dependencies. This is specific to the Maven ecosystem so too early to generalize the findings to other similar ecosystems. This indicates at least the difficulties of managing dependencies, especially the transitive ones. Also tries to define the "dependencies bloat" problem.

Need to update your Java knowledge because it evolved quite a bit? Here is a little list of the features to focus on.

Looks like a nice Faker alternative for Java projects. Turns out I was looking for something like that.

There are nice mechanism in the Java type system nowadays to no rely on Optional all the time. This is a good reminder of the main alternative.

Indeed, in some type of projects people tend to turn to Dependency Injection Frameworks a bit blindly (especially true in the Java world). Still there are other patterns which give similar benefits without less headaches. That's worth investigating if this fits your context before picking up a framework.

Not earth shattering benchmark, kind of confirms what we can expect on the concurrency and REST side of things: Rust, Go > .NET > JVM

I think it's the single one reason which makes Kotlin tempting to me every time I dabble in the Java ecosystem.

Interesting move. Looks like Java will get value types at last. Coming from C++ this feels long overdue.

Don't underestimate performance of the generated code when a JIT is in the picture. Very good example with the JVM just there.

Interesting new concurrency model in Java. Probably a good inspiration in other situations.

Illustrated with Java, still this highlight fairly well the caveats of mutable collections in multithreaded code.

OK, this is funny. Clear over-engineering non sense for the sake of it.

Interesting Java history put in perspective. Indeed it's been stagnant and have been picking up again... reminds me of another famous language.

This is not done often, but when you need it... you need it.

This looks like an interesting set of extensions for Java projects. Unsure if it's been properly battle tested yet. Likely need that before being really advisable.