I’ve been working as a backend developer for close to six years now, but reading this brought me right back to college.
Like many others, I started with C. It taught me the basics - memory, pointers, writing data structures from scratch - but most of the time it felt like I was just trying not to break things. Solving problems became more about handling the language than understanding the logic.
Then I came across Java, and something just clicked. It felt structured, readable, and intentional. Almost like reading good English. For the first time, I could focus on the actual problem instead of building the tools to solve it. Collections, built-in libraries, and a reliable runtime made coding feel productive, not just painful.
Even now, years later, Java still feels like home. It’s not perfect, but it gave me the space to learn, grow, and build things that last. I really appreciated this article - it captures that quiet strength Java has, and the care so many people have put into making it better over time. It reminded me why I still enjoy writing Java after all these years.
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.
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.
> 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.
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.
> 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 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.
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"?
I've been hating Java since 1999 for many reasons, yet I'm a Java Developer since then (with episodes of Python, C, C++ and Qt). The language itself got on my bad side when the Java developers said that they will not implement operator overloading (I'm a little bit crazy about the subject) because - EKHM - it would allow writing unclear code, which is bananas.
Things missing in Java:
- .? operator
- operator overloading
And there were a lot more, but most of them are already solved. The language is tidy and usable, the Optional api is not bad, the native function calling is improving.
But what I wanted really say is: the language itself is one thing, but the libraries available are the other. The strongest libraries in Java are the part of the language, especially time handling, character encoding, etc. Java was built with utf-16 in mind and other languages are still trying to cope with it. There are frameworks (outside the language standard) which allow crazy fast web service and DB development. It's all good, it's all standard and it's rarely breaking the backward compatibility. So you get a new developer, just after CS Bachelor and they jump into the project and understand the huge part of it.
When I'm learning new languages, I tend to try writing business applications and usually I cope with the same problems: datetime, string encoding, database connecting, etc. Yeah, golang has great goroutines, but they still import web service library from some guy's github, which can vanish in no time.
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.
As a senior Java developper, I would say the most important things you will learn from Java (beyond types) are:
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.
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).
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".
JVM is probably the most impactful piece of software ever written.
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.
I’ve in university and the classes have been almost exclusively taught in Java. Learning C/C++ definitely felt like a step backwards, as there’s more you have to implement yourself instead of using the standard library. With that said, I think I learnt a lot more about how systems work under the hood by learning C, so perhaps it’s not as good for learning programming concepts IMO
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.
The further away you are from VC money, the more "boring" technologies like Java make sense.
Whole careers have been built on producing CRUD web applications with Java on the backend and Angular on the frontend.
It's not exciting, but so is life without income in countries where this line of work is something to aspire to. I should know, as I live in such a country.
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.
Advocating that people use either Quarkus or Spring is like advocating they build their stuff in COBOL.
Java is an alright language by itself, but the "EE" frameworks and the ecosystem that surrounds them are corrosive to good software. You are actively harming your brain by learning JavaEE. If you do that to new developers you deserve to have your beans turn undiscoverable on Christmas Eve.
These days you'd typically use Spring Boot, which is a layer over Spring that simplifies its use significantly. As others have pointed out, none of this is JavaEE.
Frameworks like Spring are absolutely essential for many kinds of business software. Sure, there are slightly more focused alternatives like Micronaut (and Quarkus for that matter), but they tend to have more specific use cases.
In practice, teams that try to write real-world business systems without such frameworks end up with a spaghettified mess that just illustrates a variation of Greenspun's 10th rule: Any sufficiently complicated Java program without a framework contains an ad hoc, informally-specified, bug-ridden, slow implementation of one-tenth of Spring.
What is corrosive is the enterprise attitude of arquitecture astronauts, and that you will get regardless of the language.
I have been dealing with "EE" frameworks since C was the main enterprise language, or even xBASE.
Because OOP hype frameworks, we had Yourdon Systems Method and nice overblown frameworks written in C, with OS IPC all over the place, aka microservices.
Not only it is one of the best ecosystems, Java bashers keep forgetting that it has a cousin ruling 80% of the world market in mobile phones, via the Java subset it supports, and the whole JVM infrastructure Gradle, Kotlin and Android Studio rely on.
Java had changing its skin: Applets and Security managers, part of the cornerstone of Java 1.102 are gone.
So Java are 2-3 different evolving language nowadays.
JVM has so strong optimization layers which make very difficult for other languages to provide similar performance (Erlang is one of them in my humble opinion).
Yeah C/C++ program are faster but error prone (manual memory allocation...)
PHP is faster for web developing but refactoring is a nightmare.
Python can compete, but I do see few big projects written in it (Zulip,Dropbox,Plone/Zope).
JavaScript is super rapid dev rapid but can become a mess.
Rust is the newcome, I do not know but it seems quite cognitive-complex to code with it (I may be wrong).
I worked with shit-like Java code and i was always able to refactor it in small chunks.
The verbosity of Java is its major strength, but some things added to the language (like default interface implementations, virtual threads) are drawbacks because it create some confusion on basic pattern strategy you can employ with the language.
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.
ravirajx7|7 months ago
Like many others, I started with C. It taught me the basics - memory, pointers, writing data structures from scratch - but most of the time it felt like I was just trying not to break things. Solving problems became more about handling the language than understanding the logic.
Then I came across Java, and something just clicked. It felt structured, readable, and intentional. Almost like reading good English. For the first time, I could focus on the actual problem instead of building the tools to solve it. Collections, built-in libraries, and a reliable runtime made coding feel productive, not just painful.
Even now, years later, Java still feels like home. It’s not perfect, but it gave me the space to learn, grow, and build things that last. I really appreciated this article - it captures that quiet strength Java has, and the care so many people have put into making it better over time. It reminded me why I still enjoy writing Java after all these years.
jajko|7 months ago
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.
rapsey|7 months ago
high_na_euv|7 months ago
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
happymellon|7 months ago
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.
ivan_gammel|7 months ago
theletterf|7 months ago
"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.
AnimalMuppet|7 months ago
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.
booleandilemma|7 months ago
raincole|7 months ago
> 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.
anon-3988|7 months ago
I really want to like Java, or JVM-based languages specifically, but its extremely annoying and complicated to figure out how and why thing works.
misja111|7 months ago
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.
pjmlp|7 months ago
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.
RamblingCTO|7 months ago
unknown|7 months ago
[deleted]
p0w3n3d|7 months ago
Things missing in Java:
And there were a lot more, but most of them are already solved. The language is tidy and usable, the Optional api is not bad, the native function calling is improving.But what I wanted really say is: the language itself is one thing, but the libraries available are the other. The strongest libraries in Java are the part of the language, especially time handling, character encoding, etc. Java was built with utf-16 in mind and other languages are still trying to cope with it. There are frameworks (outside the language standard) which allow crazy fast web service and DB development. It's all good, it's all standard and it's rarely breaking the backward compatibility. So you get a new developer, just after CS Bachelor and they jump into the project and understand the huge part of it.
When I'm learning new languages, I tend to try writing business applications and usually I cope with the same problems: datetime, string encoding, database connecting, etc. Yeah, golang has great goroutines, but they still import web service library from some guy's github, which can vanish in no time.
xscott|7 months ago
ivan_gammel|7 months ago
piva00|7 months ago
lolive|7 months ago
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.
minebreaker|7 months ago
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|7 months ago
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.
saghm|7 months ago
dzonga|7 months ago
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.
parallax_error|7 months ago
zarzavat|7 months ago
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.
Tade0|7 months ago
Whole careers have been built on producing CRUD web applications with Java on the backend and Angular on the frontend.
It's not exciting, but so is life without income in countries where this line of work is something to aspire to. I should know, as I live in such a country.
jajko|7 months ago
delusional|7 months ago
Java is an alright language by itself, but the "EE" frameworks and the ecosystem that surrounds them are corrosive to good software. You are actively harming your brain by learning JavaEE. If you do that to new developers you deserve to have your beans turn undiscoverable on Christmas Eve.
antonvs|7 months ago
Frameworks like Spring are absolutely essential for many kinds of business software. Sure, there are slightly more focused alternatives like Micronaut (and Quarkus for that matter), but they tend to have more specific use cases.
In practice, teams that try to write real-world business systems without such frameworks end up with a spaghettified mess that just illustrates a variation of Greenspun's 10th rule: Any sufficiently complicated Java program without a framework contains an ad hoc, informally-specified, bug-ridden, slow implementation of one-tenth of Spring.
pjmlp|7 months ago
I have been dealing with "EE" frameworks since C was the main enterprise language, or even xBASE.
Because OOP hype frameworks, we had Yourdon Systems Method and nice overblown frameworks written in C, with OS IPC all over the place, aka microservices.
imtringued|7 months ago
ivan_gammel|7 months ago
pjmlp|7 months ago
nick-laptev|7 months ago
Please note that Java is not human friendly. You can learn it for years and still shoot your leg easily.
thibran|7 months ago
Would prefer to use Kotlin or Clojure.
daitangio|7 months ago
Java had changing its skin: Applets and Security managers, part of the cornerstone of Java 1.102 are gone. So Java are 2-3 different evolving language nowadays.
JVM has so strong optimization layers which make very difficult for other languages to provide similar performance (Erlang is one of them in my humble opinion).
Yeah C/C++ program are faster but error prone (manual memory allocation...) PHP is faster for web developing but refactoring is a nightmare. Python can compete, but I do see few big projects written in it (Zulip,Dropbox,Plone/Zope).
JavaScript is super rapid dev rapid but can become a mess.
Rust is the newcome, I do not know but it seems quite cognitive-complex to code with it (I may be wrong).
I worked with shit-like Java code and i was always able to refactor it in small chunks.
The verbosity of Java is its major strength, but some things added to the language (like default interface implementations, virtual threads) are drawbacks because it create some confusion on basic pattern strategy you can employ with the language.
pjmlp|7 months ago
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.
Klaster_1|7 months ago
jimbob45|7 months ago
Great starting place for any language.
vismit2000|7 months ago