> ... and scalac is as slow as a C++ compiler

Scalac is as fast as Javac if you don't overuse Scala-specific features which are known to compile slowly - implicits and macros. But it is unfair to use these features and than complain on compile speed or compare it to a language that doesn't offer similar feature set.

Also, in our Java/Scala project it turned out that Scala+Bloop was way faster (10x-100x) at incremental compilation than Java+Gradle. Bloop is based on SBT libraries so there are some things that SBT does right.

Thanks for the compliment. But, as the author of Bloop, I must say that Bloop is definitely not based on sbt and it departs a lot from the design decisions sbt made.

Android is the worst implementation of Java projects - horrible architecture or lack thereof and really bad api design. If anyone wants to learn Java, focus on modern Java language and micro services based frameworks and you can get best of all.

Interesting, I've only read Scala. Personally I like Clojure but thought I should mention it as I see businesses mixing Scala with Java successfully in my work.

You can, but interoperability is not that great. It can work, but often it takes a lot of massaging/converting even basic data types.

Kotlin has wayyy better interoperability with Java

totally agree about sbt being gratuitously complex.

i wonder if Java is judiciously choosing the non crazily digressive parts of Scala, as they both evolve.

That is what Goetz said is the plan for Java. Move slow, let other languages experiment with language features, and then take the best features and implement them better.

Well, so far the “better” still remains to be seen... waiting for type-classes to represent monoids, functors, applicatives, monads and foldable.

So far I’ve just seen a complex and wild stream API that mimics it in practice, without all the mental model behind it.

Oh, and what’s this nonsense with Java Option?! Really?

We're yet to see if monoids, functors, and monads are worth it :)

For better I'd say you should look at things like virtual threads vs async/await or kotlins when vs switch expressions.

If you program modern Java or Kotlin map and flatMap are everywhere. I'd say the debate whether functors and monads are useful is over.

Java or Kotlin support functors or monads as design patterns, i.e. this is how a map/flatMap works with an Optional or a Stream.

The question is: if this support is enough or should the type system be enhanced so you can abstract over/compose a functor and/or a monad ?

The answer to this question is IMO still open.

No they are. Seriously, the mental effort I had to endure to hold all these wild APIs in my head! In hindsight it’s infuriating; the gatekeeping, the patronizing condescendence when I was struggling with what are mathematical trivialities.

Screw that... I should have been told sooner

Nice : as an ex Scala person for a few years, seems smart.

Sbt optional right? Can use maven or whatever else of you want.