I can give perspective as someone who enjoys modern Java, writes Kotlin at their dayjob (and loves it), and also likes Scala 3. Here are the things that if Jav

I can give perspective as someone who enjoys modern Java, writes Kotlin at their dayjob (and loves it), and also likes Scala 3. Here are the things that if Java had, I probably wouldn't see a reason for other languages: 1. Lack of first-class lambda syntax. In Kotlin/Scala you can write something like: fun doSomething(handler: (String, Int) -> Foo): Blah In Java, all you have are the "Function<>" and related interfaces, which are clunky to use. 2. Opaque types (Scala 3). These have been one of the most impactful programming features I've ever used, and I sorely miss them in languages that lack them. object Foo: opaque type UserId = Int opaque type Email = String def mkEmail(s: String): Email = s def findUserIdByEmail(email: Email): UserId = 42 import Foo.* val email: Email = mkEmail("foo") val valid: UserId = findUserIdByEmail(email) val invalid1: UserId = findUserIdByEmail("bar") // error: can't use String as Email val invalid2: UserId = 123 // error: can't use Int as UserId 3. Union types (Scala 3). You can emulate them in Java/Kotlin with Sealed Types but it's much more verbose. type JsonScalar = String | Int | Boolean type Json = JsonScalar | Map[String, JsonScalar] | List[JsonScalar] // Makes writing functions that take multiple argument types much easier: def handle(it: String | Int | Boolean): Unit = ... 4. Context-oriented programming with "given/using" in Scala 3 and "context-receivers" in Kotlin. This one is harder to explain succinctly but essentially it allows you to decorate methods/classes with required "contextual" args. Instead of passing them as regular function arguments, you must invoke the function inside of an "environment"/"context" where the requirements are satisfied. This makes threading dependencies through your code much easier, and eliminates the need for dependency injection frameworks in many cases. interface Logger { fun log(message: String) } object ConsoleLogger : Logger { override fun log(message: String) = println(message) } ctx(Logger) fun doSomething(): Int { log("Hello") return 42 } fun main() { val logger = ConsoleLogger with (logger) { doSomething() } } 5. First-class support for asynchronous programming. With "suspend" in Kotlin and a current prototype being done in Scala 3: - REPO: https://github.com/lampepfl/async https://github.com/lampepfl/async | SLIDES: https://github.com/lampepfl/async/blob/main/scalar-slides.pdf https://github.com/lampepfl/async/blob/main/scalar-slides.pd... | YOUTUBE TALK: https://www.youtube.com/watch?v=0Fm0y4K4YO8 https://www.youtube.com/watch?v=0Fm0y4K4YO8 6. Passing arguments by name, rather than positionally. fun doSomething(a: Int, b: Int, c: Int): Int = ... doSomething(a = 1, b = 2, c = 3) 7. Tuples (Scala). They're like anonymous data classes/records. val t: (Int, String) = (1, "foo") val (a, b) = t