Looking forward to Loom so that I can stop having to work on these async codebases. I have no idea why people looked at nodejs and thought it was a good framework to copy. (Sure maybe there is some high performance computing unlocked but most people dont need it, and most teams end up with a rats next of complexity)
Recent and related:
Java 21: What’s New? - https://news.ycombinator.com/item?id=37067491 - Aug 2023 (255 comments)
I'm glad Java is returning to its original design with userland threads.
Java users can finally have some decent readable concurrent I/O without the blight of reactive.
This is a huge win.
C# introduced async/await like 20 years ago and java still doesn't have it yet... I hope in the next 20 years they will finally find time to implement this feature.
I trying to decide between Kotlin and Java 21. Please suggest me the advantages of Kotlin over Java 21.
I'm a bit out of the loop on new Java features so I was reading https://en.wikipedia.org/wiki/Java_version_history
And string templates looked exciting to me. But after skimming https://openjdk.org/jeps/430
it sounds like they want to avoid backticks for "safety"? Like we can already use the plus operator to append strings why would it be any less safe to give us an ergonomic way to do that? Oh well, Java isn't exactly known for being ergonomic.
will jdk21 present any opportunities for improvement in Clojure? like any part of core.async's implementation for example?
Can someone please explain how Project Loom and virtual threads in the JVM affect Kotlin’s coroutines?
Features can be found here: https://openjdk.org/projects/jdk/21/
Features listed here: https://openjdk.org/projects/jdk/21/
Beside legacy code, in what context would you start a new project un java?
How much old advice on Java concurrency will virtual threads change?
I'm building a course for people who are new to Java concurrency and I've made the assumption that from September, you will almost always _choose_ virtual threads over platform threads. The default virtual thread management surely matches what most people want most of the time (1 worker thread per CPU core, virtual threads on top). It removes a lot of the old worries about management of thread pools and how OS thread implementation details "leak" into Java.
It's brought it much closer to how I'd written coaching material for multithreading in Go, but the Executor abstractions will still let Java programmers shift over from platform threads at their own pace.