[minebreaker]

I don't know. I started my career as a Java dev, but what made me grow as a software developer was learning Scala. I learned a lot about functional programming, algebraic data types, effects, and so on.

I'd say Java is a great production language, mostly because it's so simple that I don't need to "learn" it (when you know better than using madness like `==` or Serializable).

[misja111]

I went the same route and am still working as a Scala dev. However Scala adoption seems to slowly go down, unfortunately .. Which is a shame because it's a beautiful language and I love using it as FP together with Cats.

However Java has advantages too: the IDE support was miles better than Scala, build times were shorter, most frameworks were more mature and better supported and the language itself was much more stable.

[piva00]

Scala adoption is going down because it's a behemoth of a language with so many features that it takes too long to learn and be proficient with it.

There's beauty in simplicity, and Scala is the antithesis of that, it has not only the kitchen sink but the whole kitchen and some house attachments within it. I fell in love with Scala for a while, worked with it for a couple years, and absolutely hated it whenever I had to train someone new. Nowadays I simply refuse to work with it because I'm not willing to relearn all the stuff it needs to be productive.

[minebreaker]

So true. Scala 3 made it even worse. Hope Jetbrains will improve that, but they seem to fully committed to Kotlin.

[saghm]

I get the point you're trying to make, but there's something ironic about touting a language as "simple" immediately followed by mentioning that using the basic equality operator that's used by pretty much every other mainstream language is "madness". I know every language has warts, but that one is pretty egregious both in terms of how quickly people would run into it for the first time and how easily it could have been avoided (e.g. by using something else for the less commonly needed equality operator, like how Python uses `is`). Having things that look correct and compile fine but then fall for reasons that you have to explicitly learn isn't really "simple".

[minebreaker]

Fair criticism, but it's not really a practical problem. Usually a linter will catch them easily, and even when junior devs ignore the warnings, you can just tell them to use "equals."

The thing is that, equality is the difficult problem. "equals" in JVM languages has a lot of problems. Dynamic languages are much more horrible in this aspect. JavaScript `==` is much worse than Java. Python is guilty too in my view, for using `__eq__` method. The only language I know which solves the problem correctly is Haskell. (Or, `Eq` in Cats)