Java is still worth learning

our world literally runs on the JVM.

however - the "Java" ecosystem used to suffer from architecture astronauts & complexity merchants. Certain things like Quarkus & SpringBoot have helped reduce that.

if you keep Java simple, don't ingest too much OOP Kool-aid. You can literally make anything that will work today, 10 years from now, 20 years from now. that's reliability you won't get from Python, Ruby & Javascript.

Remember the JVM offers alternatives - Clojure, Kotlin. with a Kotlin a nice compromise.

You focus on algorithms and solving problems instead of fighting with language, building systems, linker errors, solved problems being annoying, etc

In general the joke is real:

How much c# is faster than cpp?

By a few months at least

stream on collections (the local functional implementation of map/reduce/…),

interfaces everywhere,

and more importantly safe function extraction by your favorite IDE.

Let me elaborate the last one: you write an horribly long spaghetti code (because you are a junior, or you are in a hurry). That’s ok because the “Extract method” instant feature of your IDE will help you safely extract each piece of code AFTERWARDS into its own small function (that can be tested in isolation, where local variables stays internal to the function, where the interface contract in term of input/output/sideEffect is clear, where the function naming is meaningful).

The IDE can even tell you that this code you are extracting as a function appears at several other locations that should also be replaced with a call to that new function.

I don’t know if Typescript support in IDEs reaches the same level of simplicity/safety in term of function extraction.

But that feature is absolutely critical to go from spaghetti code to clean modular code, when you are a junior/work with juniors.

It had abstractions but you were never forced to use them. Ditto with design patterns - you could use them, but none were forced, unless you _had_ to use a framework (like spring), but that's a choice! May be it wasn't your choice, but it was a choice someone made.

If you used java like you used C, java is much easier and less mentally demanding, and therefore less prone to mistakes.

and i do argue that maven has the complexity correctly silo'ed - you need to write a maven plugin to do anything complex and custom, and fit that plugin into the maven ecosystem/api/framework (however deep you need to go).

As opposed to the 'normal' Makefile style build, where you add instructions and scripts (which i think both Ant and gradle inherited the idea from, and thus neither really makes for better builds imho).