Java is still worth learning

I had same experience with c#

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

> Solving problems became more about handling the language than understanding the logic.

I've worked with Java for 25 years and have a love/hate relationship.

Java garbage collection is both great, and terrible. Sometimes objects are instantiated in a method, and should be marked for GC when you leave the method but aren't. There isn't logic or reason, and it trips up juniors hard and reworking "new" features like streams into basic for loops fixes it, even though there isn't any really good reason why.

When it works first time you never even need to think about it, and its awesome. When it doesn't, there is no escape hatch to fix it. Its probably for the best, I would probably prefer someone switched a stream to a loop to fix a GC bug than to keep the stream and add additional code for flagging objects.

Funny I had the exact opposite reaction to Java when I needed to use it in college. So many abstractions, forced design patterns and boilerplate. Absolute soul sucking joyless development.

Similar story - did half the university courses in C or C++, then picked up this new language called Java for next semestral project. I made 3D map of my home country from a set of 3D points in something called Java3D, long-abandoned effort that could make 3D objects and interactions ie in desktop UI but also on web via applets (I told ya long time ago, this was early 21st century).

Working under it, apart from usual initial pains was marvelous - the language itself somehow forced me to make much cleaner code compared to C, which as a beginner became horrible mess pretty quickly. Suffice to say, debugging was trivial, no pointers just easy life.

25 years later, Its close to 100% of all work I ever done professionally and I don't mind surfing that wave till retirement, Java is so spread into corporate sphere that there will be enough work especially for seasoned experts for decades to come.

Stuff juniors often complain - OO bloat, EE megabloat etc become invisible pretty quickly, and you just work with the code, however you like it. Its a great platform to see that premature optimization is really not something to worry about during initial implementation (unless you do N-th rewrite of some performance-critical app, which most of us rarely if ever do). It doesn't mean any spaghetti code is fine, just that following normal design principles is normally good enough and one can focus on things like security, clustering and actual features.

Especially sentences like these:

"This wasn’t just about type safety – it was about reducing the mental burden of programming."

The "x wasn't just about n — it was about m" carry a strong LLM smell.

Off topic: Lacks... personal touch. That's exactly what I find wrong with AI writing. Good writing has the author's voice. Corporate writing has no personal voice; that's why everybody hates reading it.

AIs train on all the text of all the web (that they can get, at least). A lot of that text is "corporate voice" (that is, written by nobody). But even the rest, the AI blends it all together. As a result, in the output, there's no voice - or rather, all the voices all blended together, which doesn't sound like anybody.

I hate that I have to second-guess whether or not something has really been written by a human nowadays. Especially with these blogs that have sprung up in the past couple years.

Quote from the article:

> Java has been my companion through:

> Learning object-oriented programming > Building enterprise applications > Navigating the transition to cloud computing > Exploring microservices and distributed systems > Mentoring other developers > Speaking at international conferences

Yeah this is literally what 90% of senior programmers have done regardless their favorite languages. Either AI-slop or human-slop.

Java can be compiled into a single binary. You can use for instance Graal VM for that: https://www.graalvm.org/latest/reference-manual/native-image...

Java has Maven and Gradle that serve as package managers. I'd say they are not any more complex than npm, except if you need complexity to do something very specific.

Like for about 25 years now, small sample (there are others),

https://en.wikipedia.org/wiki/Excelsior_JET

https://en.wikipedia.org/wiki/GNU_Compiler_for_Java

https://www.aicas.com/products-services/jamaicavm/

https://www.ptc.com/en/products/developer-tools/perc

The difference being that those projects required $$$$ that only big corps were willing to shell out.

Now you get free beer via GraalVM (evolution from MaximeVM efforts at Sun Labs), and OpenJ9, IBM's AOT compiler that traces back to Maestro realtime JVM for embedded development.

So complaining about $$$$ in AOT toolchains is no longer a reason.

Then we have the Android cousin that does a mix of JIT and AOT since Android 7.

I think you might need to look into java (or better kotlin) then. Is gradle not a package manager on top of a build system, just like npm? Is a fatjar/shadowjar not a "single binary"?

Seconded on operator overloading, but being restricted to the limited set of "primitive" (value) types is horrible too. Complex numbers are table stakes. The idea that I need to dynamically allocate an object holding two floats and hope the JIT can optimize that into a stack value is awful.

I think with value types we may see some support of operator overloading eventually. Done carefully, Java way, covering most important use cases, but leaving extremes outside of the scope.

No operator overload, I think it was a wise decision to not allow it after seeing the bizarro world of Ruby, Scala, C++, and others.

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.

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".

This is why whenever someone asks me what language they should learn first (if they want to be a professional and not just a hobbyist), I say C. Don't learn a high level language first.

Learning Java before C is like learning to ride a bicycle before you learn to walk. You will need to learn C eventually, but learning C once you already have a high level language under your belt will make the experience frustrating. Having to manage your own memory, build your own data structures, it can be fun, but it's less fun once your brain is already wired to expect these things to be done for you.

I refuse to jump on this oh-so-popular bandwagon of (seemingly) everybody complaining how java is uncool ad nauseum. You can make cool stuff in literally any language, and syntactic sugar around and how to express it are details. That's junior dev thinking, chasing fads, repeating others and not forming one's own opinions. This is mine.

Only ART, .NET, Erlang, and V8 are on part, with similar engineering efforts.

Which when coupled with the great IDE tooling, graphical debuggers and libraries, is the reason why with exception of Erlang, they remain my main tools.

With the occasional dip into C++ for native libraries.