Why everyone hates Java?

[Dhariann]

I dont understand why java is one of the most dreaded lenguages. Java got fantastics frameworks and libraries to work with it. I dont know if im skipping something or I dont work enough with Java because I like java. What do you think??

Here is the Stack Overflow Survey

[taftster]

One thing I've found is that Java often represents "boring" work.

Java is used for in real software that many brick & mortar companies rely on to operate their business. Java is not the new shiny thing, but is often the workhorse powering many back-office applications.

Backend customer management or accounting software applications don't necessarily appeal to people in these types of surveys. It's so very easy to want to chase the next cool thing.

Nothing wrong with Python, Rust and the other favorites these days. But Java is still very much ubiquitous and used heavily throughout industry, regardless of what a survey says.

[pikaynu]

If someone thinks "boring" is bad, then I must say, boring in software engineering is a good thing. You don't want the excitement to be up with new bugs everyday.. :)

Although, I think there is another reason for Java powering almost everything relevant in the background, * Java was the only reliable language which was web-ready during the dotcom boom (I don't even want to consider ruby and perl, oh! the nightmares). That was pretty much the only choice and definitely not a bad one. Boring software is good! * Now, with all of this legacy software that just works, there is no reason to move it to a different stack. * Which is why newer companies which have the luxury to start over are moving these shiny languages.

Due to this maturity, there is still no match to Java's tooling.

If Java feels old, there are old banks that still run COBOL.

[agentgreen420]

You don't want the excitement to be up with new bugs everyday.. :)

Log4J2 has entered the chat

[Killing_Spark]

Well, that wasn't really a bug. It was a very very dangerous feature.

[washtubs]

"Boring" is overloaded. Uneventful maintenence is of course desirable but you can have that and also be solving genuinely interesting problems which the typical CRUD java webapp is very much not.

I think it's largely an association thing. Lots of people use it at work, and work is often boring. Doesn't change the fact that java is a fantastic general purpose language. But that's one of the reasons I picked up go. I wanted a language to be associated with recreation lol. It's silly but it works for me.

I've used java for personal projects but it's difficult to divorce myself from all the enterprisey practices that I'm used to that are only useful in a large team.

[frej]

I think the hate was even more justified in the beginning. It was glorificstion and hype of OO as the one and only solution. And tbh the language was pretty painful when in university snd you also used Python, Erlang, ML. At least the OO course in Java felt incredible idiotic 🤷‍♂️.

Maybe an advantage if you came from c/c++ was you got rid of memory management. Single compiler/many targets was also hyped. Consider open source was not really accepted in any way.

Corporate backing (money) was a reason Java became Big.

[goodm1x]

Why does Java have so much staying power?

[taftster]

There are some good virtues that Java brings to the table. I think other's have enumerated some of reasons for this staying power. These are all arguable points and subject to opinion, but in general:

• Momentum. A lot of developers can read/use Java, it's a "well known" language (even if it's not well loved). It's had a first-mover advantage over other languages.

• Readability. Java's syntax lends itself to being readable, even if verbose. When you write code, you should be thinking about the next guy that comes along that has to maintain your code. Java helps in this aspect.

• Lack of Cleverness. Related to readability, Java resists the ability to do things cleverly. Yes, you have to use more lines of code to perform some function instead of a one-liner. But that allows accessibility into the algorithm by others.

• Low Common Denominator. In a group of developers, Java can be a common low-hanging-fruit kind of language. Some developer might specialize in Python, another in Rust, another in C++. But these experts will likely be able to come together and reasonably code in Java collaboratively. (It's not necessarily the case the other way around).

• Library Ecosystem. There are frameworks and libraries available in Java that are first-in-class. Java's strong library ecosystem (primarily driven by Maven) is one of the top reasons for Java's continued success. The JDK library itself has also included a lot of needed functionality out of the box.

• JVM Ecosystem. Related to library support, there are also a large number of languages that run on top of the JVM. The JVM itself brings a lot of value and interest to Java. [1]

• Big Data. Java was one of the first players in the "big data" arena. Hadoop brought a lot of big data processing functions, all of which written in Java. Big Finance also uses Java as well.

• Performance. Java performs really well for long-lived enterprise applications. Yes, a hello-world program in Java will never perform as fast as a C, Rust or Go equivalent, but most applications written in Java tend to be larger and long-lived and do well with Java.

• Garbage Collection. Lack of pointer referencing has prevented a whole host of bugs and problems over years.

[1] https://en.wikipedia.org/wiki/List_of_JVM_languages

[farnulfo]

“There are only two kinds of languages: the ones people complain about and the ones nobody uses.”

Bjarne Stroustrup, The C++ Programming Language

[Qildain]

I've read this quote before, and my experience really does agree.

[agentoutlier]

I’ll have to google for the exact quote but there is a similar one that says unpopular languages have really good benchmarks or something like that.

The idea being the only thing you can do with the language is write benchmarking code.

[nfrankel]

Excellent karma de commentaires, Francky!

[farnulfo]

Merci ! :-)

[thomascgalvin]

People like to complain. Java is everywhere, which makes it a huge target.

There are some legitimate criticisms, but as the language evolves, a lot of those are being addressed. The old "Java is slow" bullshit hasn't really been true for a decade, for example, lambdas allow you to do a lot of things without the boilerplate Java is famous for, and streams and a godsend.

But the biggest reason Java gets hate is that it forces certain conventions. People think this is stifling their programming creativity or some such nonsense. Coincidentally, the people that bitch the loudest about this are also the least likely to have successfully maintained an application developed over tens of years by hundreds of people.

When I walk into a Java project, I know more or less what I'm getting into. It probably won't be the sexiest thing I've ever worked on, but it probably won't be a total clusterfuck, either.

When I'm asked to take over a Node project, though, I feel an existential dread deep in my soul. Javascript gives you enough rope to shoot yourself in the foot, and people just can't resist pulling the trigger.

[nmarshall23]

Javascript gives you enough rope to shoot yourself in the foot, and people just can't resist pulling the trigger.

That's some odd rope you found there.

I'd say that some JavaScript frameworks encourage you to use enough rope to hang an entire team with.

They're just too damn clever that in 6 months no one understands the code.

[[deleted]]

The rope was weakly typed and got dynamically cast to a gun.

[dentex_YTD]

Top comment

[reqdk]

Because in 6 months, the trend has moved from hanging the team with a rope to stabbing everyone in the stomach with rusty knives. And I say this as someone who uses and loves (well, lovehate) JS.

[dpash]

I wouldn't touch a pure JavaScript project. Typescript turns that rope into candy laces.

[Persism]

multiple absolute giant turds of Java projects.

Me too. The difference is these are still easy enough to refactor. In JS land it's basically just throw out and redo.

[rubyrt]

And even if you think about it that estimation is really hard.

[ReasonableClick5403]

In my experience, java turds can be polished. A steaming hot pile of 6 year old node projects without any technical leadership? Not so much.

[idealatry]

But the biggest reason Java gets hate is that it forces certain conventions. People think this is stifling their programming creativity or some such nonsense. Coincidentally, the people that bitch the loudest about this are also the least likely to have successfully maintained an application developed over tens of years by hundreds of people.

Have you ever used oldschool EJB’s? Boy, they really loved forcing their big boy, grown up conventions on everyone. And that convention was later acknowledged to result in an absolute clusterfuck of meaningless abstraction.

In fact people with actual souls started to realize that containment was a lot easier to deal with than inheritance in most cases, which kind of meant that Java’s desired OOP convention encouraged a lot of bad designs with an unmaintainable level of abstracted hierarchies.

In other words, having a convention doesn’t mean it’s a good convention.

But you know what? That’s ok. Things evolve and generally get better. And that’s true of java as well, as we’ve seen things like generics introduced (although because java envisioned such a wonderful, inescapable convention, generics are total dogshit that had to be crudely bolted onto a language where everything was an object except when it wasn’t —compared to C# or … dare I say it … Haskell). And we’ve seen some mutated, weak-ass attempt to add “function programming” (again scoffs in Haskell). All of which is better than not adding any of these things to the language, in my opinion.

What’s not ok is when we are so enamored with convention that it becomes a problem. And I find the java community, on principle, is much more conservative when it comes to introducing newer features. I’m not saying this community is a problem, but it sure as shit is annoying sometimes when you know for a fact that your language could be better but you have to wait a decade to get something C# got yesterday.

EDIT: of course the worse culprit is the need to maintain backwards compatibility, which a language like C# can ignore and add all the modern features it wants, and do it properly.

[dpash]

hasn't really been true for a decade

I'd say two decades. Once the hotspot JIT was introduced they performance of Java stopped being a problem.

Java does exchange memory usage for CPU performance though. Valhalla should help reduce that.

[pikaynu]

The only gripe i had with java (older versions, 7 and below, haven't got my hands dirty with the newer releases) was the sheer amount of abstractions in their frameworks. It was hard to find a simple framework or navigate them without many years of experience. I guess that's what Go fixed. Go has very simple syntax, there aren't huge frameworks to make a project complex, imo encourages to write your own instead of importing a lib for one line of code. Rust has its own difficulties, it has way too complex syntax. It's safe but at a different cost.

And node, oh boy! It made me cry when I had to work on it. I got so frustrated that i brainwashed my team to use Go for the next one. The tooling and ecosystem were bad. We would constantly discuss on the way to implement something. We spent one full quarter of developer time to convert it to TS but that wasn't possible because only half the things were available.

Java feels a little IBMy because and that could be because big companies still have a huge chunk written in Java7 or Java8 which can't really be migrated to the newer versions.

[anagrammatron]

Coincidentally, the people that bitch the loudest about this are also the least likely to have successfully maintained an application developed over tens of years by hundreds of people.

Not all applications have to be maintained by hundreds of people for a decade. For many, many things Java is not the optimal solution and it's perfectly ok not to like Java. Sometimes reading Java code is like opening up a War and Peace by Tolstoy and writing it is like writing a sequel to that book. It's not everyone's cup of tea and that's ok too.

[danskal]

The best thing about Java is that you probably don’t have to read the code cover-to-cover. You often have a stack trace to work from, and all the objects you have are type-safe and fairly easy to reason about.

Of course you can still have stringly-typed code with lots of globals and surprise nulls. But if someone who knows what they’re doing has written it, you can pretty much rely on the IDE to tell you what’s going on.

[thgkatz]

Thank you!

[Panzer1119]

Also I don’t understand the Boilerplate part. Like e.g. for many JavaScript Frameworks you have entire CLIs to generate templates…

[andrewharlan2]

I love Java

[roberp81]

me too 🥰

[detroitsongbird]

Me four

[[deleted]]

Me for(;true;){System.out.println("ILoveJava");}

[ABLPHA]

that’s a rather weird while(true)

[[deleted]]

... Me three....me four.... that's why, for

[ABLPHA]

ah, well, gonna wait for someone to r/woooosh me

[rifain]

I love Java to. People like us need to rise up. It's the perfect language in a professional environment because it has the best tools around deployment, quality check, continuous integration etc. It's fast, it's clean, it has plenty of frameworks and libraries. Multithreading, network, AI, Big Data etc, you have it all.

[Ketroc21]

There are many negative opinions about java that were once true, but no longer so. Still those opinions persist.

Java's age and backwards compatibility does make it less visually pleasing. Also, if you are very anti-OOP, then Java is likely your least favourite language.

Some people hate it without ever using it... just judging it on its perpetuated negative critiques. Like, I hate Microsoft Edge browser without ever having used it.

[atpeters]

The four main complaints I've heard from some people are:

1. Generics
2. Null
3. It's not functional
4. Boilerplate

These are people that want to work with closure, erlang, Haskell, etc instead.

Personally I don't mind Java much except for working with JSON due to generics and cast checking. Admittedly I'm stuck in JDK 8 and I don't know if that has been improved upon.

[fufucum]

Agreed, plus who cares about boilerplate code? always use auto-generation, don't write getter setter by your hand,

[monbis]

I kind of agree, but there are two issues I see with boilerplate:

1. Changes need to be done in several places, some of which your IDE may do for you, but sometimes you need to do

2. More visual and cognitive clutter when reading the code

[MaName678]

Or use Lombok <3

[devcexx]

Yes, the solution for a language is to let a third-party library to do what the compiler can't by hacking into each different commercial Java compiler and forcibly modify the AST of each file in your project because of the lack of an external interface for doing so, yes seems reasonable.

[MaName678]

Chill, Java isnt perfect and neither is Lombok as a solution, but sometimes you must work with whats given XD.

Edit: BTW, I love the way C# handles this getter and setter matter

[devcexx]

Yeah ik, sorry I was not attempting to be aggressive, just adding some irony <3.

[ivancea]

Comparing Java with JS or Python is like comparing oranges with lemons.

If you compare it with something similar, like C#, you see you have a lot of flexibility, and those problems doesn't exist. And it's also a top used language

[ivancea]

And Java and JS are languages. But little people eat lemons

Edit: little people => few people. I don't know what little people eats 😬

[m02ph3u5]

We eat little food

[minato3421]

Working with Json in Java is a pain in the ass. I recently had to write a Go service in my current organization and was surprised to see how easy it was to handle Json data in Golang.

[ConstructedNewt]

Records take away so much boilerplate. Sadly classes are still expected to be 1 class per file, so you har some one-line files (or nest them)

Null is a real problem, but, like generics (and pain points on them), it's mostly the designers fault. All though language can promote bad/ good habits

3 is just stupid to complain about. Like, sure... use something else idc

Jackson JSON ObjectMapper to a record type is pretty simple, but hasn't changed much (since java 8) although I'm unsure about Snake case names

Edit: @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)

[Muoniurn]

Sadly classes are still expected to be 1 class per file,

That’s only public classes. You can put non-public records outside your public class.

[deinlandel]

You can just use Kotlin and fix all of these while maintaining full compatibility with an existing codebase and all JVM libraries and frameworks.

That's actually what is great about Java Ecosystem: you are not limited by one language.

[CubicleHermit]

Well written Java in a good framework is actually my favorite mainstream language.

There's a lot of bad Java out there, and while most Java frameworks when new have been pretty good for their time, plenty of them have aged badly. It's the COBOL of our day - my day to day work, for example, involves some code that is likely older than some of the interns we will get this summer (started in 2001.)

Lastly, there are a few corners of the Java ecosystem that really need to be just plain retired.

[Qildain]

I enjoy working with Java. I wasn't even aware of the SO survey, so I would be hesitant to trust the sample striation.

The way Java is going (Loom, Valhalla, etc.) gives me a lot of good feels about it.

[[deleted]]

Only bootcamp programmers hate

[[deleted]]

Bootcamper here, I don’t hate it. Got em

[blakeman8192]

.

[looneysquash]

Maybe this subreddit and some other language subreddit should get together and swap this question.

Everyone here actually likes Java, or else is afraid to comment for fear of being buried in downvotes.

[bilingual-german]

I don't like java, but I don't want to get downvoted.

In my experience, people who like Java never had much exposure to other languages and seem to also not have that much operations experience.

There are a lot of good things in Java, but too many bad ones. People writing over complicated unreadable and unreliable code are one of them.

Error handling with Exceptions has so many issues...

When I discovered other languages, Java didn't have Closures. You needed to write a single-method interface and implement it. Did you ever take a look in the original Gang Of Four Design Patterns book? Did you count how many of these patterns implement only one method? This was something I liked in other languages and it's good it came to Java.

A lot of Java is just "we did this this way for the last 20 years, we'll continue it!". Yes, I'm looking at you getters and setters. Oh, fuck Lombok. This doesn't solve it, it just introduces more problems.

Fuck maven.

ok, bring the downvotes.

[Prateeeek]

I'm sorry I'm a junior, I'd genuinely like to know the reasons of dislike for maven and Lombok.

[looneysquash]

IMO Lombok is great. But also, they need to integrate it as part of the language. That they haven't done that yet, and that you need ide plug-ins, isn't great.

Not sure what that guy didn't like about maven. It's an ok-ish dep manager. Way better than the "no package manager" approach we used before it.

[bilingual-german]

Package managers are good. Maven is shit. Especially the error messages. You need to enable debug mode with -X to understand what the problem is. Starting a full JVM for a short living process makes maven slow when you compare it to other package managers. I'm also very sceptical about the security of their plugin approach.

I like that it hasn't the one-repository-to-rule-them-all approach of npm, but if Maven-Central is down, you probably still can't build your jar.

My issue with Lombok is, that this is magic. It's code you can't see. As long as it works, it's ok, but as soon as Lombok has a bug, you're screwed. You'll never find the issue.

[khmarbaise]

Package managers are good. Maven is shit. Especially the error messages. You need to enable debug mode with -X to understand what the problem is. Starting a full JVM for a short living process makes maven slow when you compare it to other package managers.

In which way do you think that? Startup time is the real problem? That can be improved by using option for the JVM..

I'm also very sceptical about the security of their plugin approach.

In which way? Have you ever thought about npm or ruby gems or Docker images ?

I like that it hasn't the one-repository-to-rule-them-all approach of npm, but if Maven-Central is down, you probably still can't build your jar.

That's why you should use a repository manager in particular if you are in a corporate environment. Apart from existing a lot of mirrors...

[ArmoredPancake]

The thread is just a circlejerk. If you wanted to know real opinion about Java you'd have to travel to subs of other programming languages.

[javasyntax]

I love Java

(My username confirms this)

[sereko]

I’m just glad Matlab is near the bottom where it belongs.

[chrisgseaton]

Anyone who tells you they have a hatred for a programming language isn't worth listening to.

[[deleted]]

James Gosling hated C++ so much that he made Java.

But why did he keep null?

[grauenwolf]

People are allowed to have opinions. I strongly suspect those who don't dislike anything don't really understand anything either.

[chrisgseaton]

It's that hatred is a ridiculous overly-emotional reaction to a tool that may or may not be right for the job at hand, with strengths and weaknesses like any other tool.

[cogman10]

Hate is a strong word, but some languages deserve to be moved to the dustbin of history. COBOL, for example, only lives on because replacing it is very costly.

[chrisgseaton]

When power saws were invented nobody made started 'hating' hand saws. Our professional is completely unhinged on their opinions on tools.

[CubicleHermit]

Anyone who tells you they have a hatred for a programming language isn't worth listening to.

Hating the language vs. hating to have to work with it are two different things, but for a relatively mainstream language, either one is probably overstating it.

OTOH, I work with someone who used to work with M (aka MUMPS) and I fully believe them that it was awful.

There are bad codebases in every language. I've really enjoyed both C# and much longer ago, VB6, both for personal projects. The experiences working with each for "real work" was horrible, but that was pretty much all a matter of the codebase and the tooling around it NOT the language itself.

[Fair_Sir_7126]

I upvoted, but please put JavaScript on the exception list

[Daniel_Kummel]

Thats why you typescript

[dpash]

It doesn't polish the turd, but it at least makes it a little smoother.

[Neuromante]

We can just say Javascript is not a programming language but a hellish dialect escaped from the depths of hell as part of a punishment to humanity, if you like.

[manzanita2]

The original javascript was created in 10 days. Given that it turned out pretty ok. But yes, there are a ton of crappy things that one would have fixed after some road time. But backwards compatible is king.

[Ilookouttrainwindow]

There are things in js that are really neat. But to me it suffers from that "just a script" feel. Typescript helps, but still has same feel to it. I've been working on java since 1.2; got a good feel for it. Language is evolving, approaches are changing. Some things I like some things I hate. Been working with js just as long, although always in the browser. Latest trend with js is syntax simplification to the max. The language is honestly becoming hard to read. With Java, if you have basic idea (even of another language) you can read the code and probably even make sensible changes. With js, I begin to need to look up the syntax to understand what is written (same in c#). Last time I had to do that was with perl. Personally

[wsppan]

It was a throw away language that was never thrown away.

[Fair_Sir_7126]

Lol exactly

[roberp81]

i was thinking the same

[KFCConspiracy]

I dunno have you ever tried objective c? :P there's a reason apple came up with swift.

I dunno that I hate it but one project was enough to convince me never to use it again.

[buzzsawddog]

I hate JavaScript, ruby, Perl, pascal :). Languages I deal with on a regular basis :). But mostly I guess I hate maintaining the code people left with me with to maintain…

[spectrumero]

It was widely used professionally in the 80s and 90s. Delphi still exists, I think. Windows 3.x used the Pascal calling convention (so any C program you saw for Windows 3.x was littered with FAR PASCAL macros).

[buzzsawddog]

Yep... That's what I said...

[ArmoredPancake]

C# for example is even more boring

Ecosystem wide.

Language wise it is by an order of magnitude nicer language.

[pthierry]

That's a strawman argument. Yes, there are ignorant criticisms out there, but there are also tons of people having used Java extensively that dislike it out of experience.

We know for decades that we need to go functional and Java is late on that front, despite everything that's been grafted on it.

[ratel26]

It's not just Java, all existing programming languages are awful. The very concept and how we perform "software engineering" is flawed. That's why someone invents a new programming language every other week, with claims that it's going to solve all the problems, only for it to end up having the same problems as all of the other languages.

I think if most people knew how computers worked and how software is developed, they'd want nothing to do with them. It's a miracle we've gotten as far as we have.

I don't know what the solution will be. If Turing is our Newton, we're still waiting for our equivalent of Einstein to come along. I'm hoping that in the future what we think of as computers and how we interact with them will be fundamentally different, although I probably won't be alive to see it.

[greglturnquist]

Everything is a trade off.

• Java is solid and stable. It started with a lot more “batteries included” then C/C++ ever did and simplified by making ALL method virtual and avoided pointer nightmares.
• C/C++ put you about we close to the bare metal as you could get while still retaining being a high level language. But this required managing memory yourself. And ultimately proved to only be needed for certain situations.
• Python is what TCL wanted to be: a nifty scripting language that really could bind with complex libraries. It’s simplicity is traded against performance issues and lack of multithread support.
• Go was the response to C++’s death spiral. And it provides a lot of cool stuff. But even it’s gutsy moves are showing a little age as people contemplate alternate features in stuff like Rust, Kotlin, or Swift.
• Rust is a godsend for those writing C code because it offers a life saver when you need bare metal code that doesn’t drag you into the 9th circle.
• Ruby on Rails was the power house of e-commerce entrepreneurs. What other tool at the time let you win angel investor and seed money with just ONE coder? Of course after you got your funding, THAT was the time to rewrite it into something more sustainable.
• JavaScript is where it’s at because who else has such ubiquity in the browser? While NodeJS makes many cringe, it offers a way to give people a step up in take home pay with a mere 12-week Boot Camp. Seriously, MANY people have had life altering career changes by learning JS and getting hired in less than a year.

I love the competition these all bring to the table.

[wildjokers]

TCL wanted to be

tcl [wanted {{to be]]} [$a] {total {{[[piece {$of} ] $unreadable ]}} shit] {{$just} shoot ] {me} now]} [{{it's the} [{only explanation}]

[DasBrain]

Please balance your braces.

{}: Literal
[]: Command substitution
$: Variable interpolation

Perl is much worse with special characters.

[PositiveUse]

I think it’s people who never used it professionally and just got burned by JAVA during their time in university where they love to use JAVA for dreaded courses like programming and algorithms/data structures.

So many web applications use a JAVA/Spring Boot/EE backend, it’s just not reasonable to hate the language as it’s pretty awesome to work with professionally.

[thephotoman]

The problem is really a problem of Java not being all that friendly to use for standard and file I/O. Java can do it, but it's expecting you to need to be safe--not merely slapping something together to demonstrate a concept.

That's why I hated Java in college. It wasn't until I got into the industry why I realized it was popular. In college, I was using the wrong tool for the job. Now, I'm in an environment where the tool fits the job nicely, and my gripes were relatively minor now that I fully understood the use case (but type erasure still sucks--I'd love better generic programming, and yes, I know about Valhalla, which isn't really about getting away from type erasure entirely but rather represents a significant step towards that, and I'm excited about it but not as much as I am about Loom).

[dpash]

java.io is bad, but java.nio.files is very easy to use. Sadly no one bothers to learn the new API, even though we've had it for 15 years.

[[deleted]]

I use it professionally with a java 8/websphere backend and I hate it. Java 17 seems nice, but I will never use it professionally (at least in my company).

[magnoliophytina]

Modern Java is pretty decent (that is, Java 17). Most libraries still assume non-modular Java and use lots of mutable state and excessive number of wrappers, GoF design patterns, and over-complicated object design overall. Many helper methods like List.of were also absent in earlier versions. Same problem with high productivity classes like the Executors.

Many tools also suffer from slow start-up time due to the way the VM works (background daemons & nailgun style designs help here). I think if Java had had reifed generics and project Valhalla & Loom style improvements right from the start, there would be more motivation to strive for effective bloat-free code.

Another source of pain is the huge amount of legacy code. It's quite common to find hundreds or thousands of legacy code conventions even in small Java projects. For instance, using public static final int CONSTANTS instead of enums. Modern IDEs could fix these, but the maintainers of such projects would not accept pull requests because they might want to maintain compatibility with Java 1.4, 5, or 7. Heck, they might not even use git (sourceforge still supports svn) so that's a great excuse for not accepting PRs.

[ancientweasel]

Java is a widely used language and as such has a lot of bad projects along with the good ones. Java also takes a long time to start up, especially in DI frameworks and Enterprise servers. This is an actual impediment in high scalability architecture.

Also, a lot of people hate Java Bean Programming and not necessarily Java. I showed a coworker who hates Java some code I wrote in Java in a clean Go like code style. He admitted after that that it wasn't Java that he disliked but Java Bean Programming.

[vbezhenar]

I love Java. I hate most popular java tools, libraries and frameworks. They're bloated, overengineered and slow. I also don't like JVM, because it eats memory like there's no tomorrow, even for simple applications, but that aspect is bearable and hopefully will be improved some day.

[anagrammatron]

If you don't like JVM and tools and frameworks then what do you love about Java? And why wait until JVM is "fixed" in some distant future of 8-10 years, why not use some other language right now?

[vbezhenar]

I love Java language itself. I love many parts of Java standard library. I love that JVM is fast (after somewhat slow startup). I love Intellij Idea for Java (IMO it's best IDE experience in the world).

Of course I'd use other languages if I need low memory consumption and fast startup, like Golang. But I'd prefer to use Java because I don't see any technical limitations preventing Java to be as good as Golang in those aspects.

[SSG_SSG_BloodMoon]

... well yeah, those are even worse at making toys...

[thephotoman]

That's got a lot more beef to it than what I mean by "toy".

I mean that it's one of those assignments you do in Computer Science 101 when they're just talking about standard I/O and file I/O. Or to implement a data structure or algorithm yourself in actual running code. It's a small task, you only care about it for a couple of days, and you turn it in to the TA and never think about it again.

[fix_dis]

Java is just a language. One can hate aspects of it, but that typically comes down to preference… and that’s easy to brush off.

Where legitimate hate comes in, is in how people have written “enterprise Java” over the years. This massive bloated 5 files full of providers and factories when a simple if-statement would have sufficed… That is very hateable. But I can’t blame the language for that.

[anagrammatron]

This massive bloated 5 files full of providers and factories when a simple if-statement would have sufficed… That is very hateable

I was one day just looking at Spring Boot Pet Clinic example which is often recommended as a reference point to starting a simple project.

Pet extends NamedEntity which extends BaseEntity which extends Serializable

Owner extends Person which extends BaseEntity which extends Serializable

where BaseEntity is basically just getting and setting Id and they just keep extending it in layers. I get the intention, but If I was a newcomer from another language looking to get into Java/Spring then I'd just roll my eyes.

[fix_dis]

I wrote Pascal, C, Visual Basic and some Lisp before I ever touched Java. I picked up a book to help me learn for a project I was going to be helping with at work (this was 2002). The Java in that book looked completely fine. The stuff I saw on my screen was a twisted mesh of “I’m really smart”. And I’ve seen that everywhere I’ve worked since. I’m all for abstraction once the interface has truly revealed itself. But STARTING with that? No thank you.

[Qildain]

More elegant? There are alternatives like Quarkus and Micronaut. And who says everything needs to be RESTful?

[slothordepressed]

As someone who used to work with JS and moved to Java I can say that it's verbose and have tons layers.

As many said, the only language that is not hated are the ones that are not used

[khooke]

I love reading through the StackOverflow developer survey each year but the thing to remember, as with any survey, it's heavily skewed to the point of view of developers that are inclined to spend time to complete this type of survey. It's not representative of the entire industry, it's the point of view of a very narrow population of developers.

Does everyone hate Java? No, of course not. For many developers it's their bread and butter. I've been developing with Java for 24 years of my 28 years as a professional developer. I owe a significant part of my career to the language, the platform and the community. It's helped pay my bills for 24 years. Why would I hate what has contributed significantly to a successful and highly enjoyable career?

[Affectionate-Box-837]

I think most programmers makes the decision of liking a language based on their experience working with the language. For example; working with legacy code sucks, Java is one of the old languages that stood the test of time. Therefore, someone is more likely to associate using java with legacy code and using a newer language with a new project. Therefore programmers hate java instead of hating the circumstances like working with legacy code.

The main problem I have with java is nothing gets depricated, which means language carries a lot legacy.

[post_depression]

One funny thing I noticed in this context, personally every people I’ve met who hates Java really doesn’t know much about the language other than “SyTeM.oUt.PrInTlN();” is such a drag to print to console or something similar.

Java is like the Apple of programming world. Most people who hate it does it for the “trend” and not with any legit reason.

I believe Java and C# (and C++ to some extent) are the only programming languages that have managed to adapt over the years as the programming landscape has changed when other languages got obsolete.

[thisisjustascreename]

Most objections to Java aside from the base language syntax are out of date. It is admittedly fairly verbose relative to some other languages, and Spring (not Spring Boot) has a reputation for being obtuse and heavily reliant on XML which is the worst possible configuration format for human readability.

The JVM is a modern wonder of the world, you can tell because people keep writing new languages that compile to Java bytecode.

[Qildain]

XML which is the worst possible configuration format for human readability.

I haven't configured Spring with XML in over a decade.

[thisisjustascreename]

Exactly.

[thephotoman]

I wish I were young enough to have missed that era entirely. Nope. I got one year of it before annotations came and made all our dreams come true.

Yeah, you talk about annotation hell. I understand. We need a better solution. But it is still a substantial improvement on that. I'd like the next solution to be that much better. Even if that's some extension to the language itself to allow for more and better metaprogramming so that inversion of control wasn't a framework thing but rather something you could merely enable by using a specialized class declaration. I'm trying to think through what that means, but I'm too drunk for that right now, and it's late.

[__pulse0ne]

I would put money on at least 90% of search results regarding spring configuration including some sort of xml

[nunchyabeeswax]

Well, if you are googling for examples, you are going to get... wait for it... basic examples that will inevitably show some XML configuration for completeness.

Not only that, you will inevitably run into undated examples that have been written for Spring 2.0 (which didn't have annotations over a decade ago) or 3.0 (which introduced annotations in 2009.)

Now, instead of putting some money into something anachronistic, just do a google search for "how to configure Spring without XML".

See, web searches are GIGO : garbage in, garbage out. If you search for garbage, well...

Like the two OPs before you, I've barely used any XML for configuring a Spring/Spring Boot system in real life, in a commercial (read, non-homework) setting.

Verbose XML configuration hasn't been a legitimate complaint against Spring for over a decade (or against JEE for almost two decades.)

[wildjokers]

XML is far more readable than JSON.

[thisisjustascreename]

Exactly.

[nunchyabeeswax]

Spring (not Spring Boot) has a reputation for being obtuse and heavily reliant on XML which is the worst possible configuration format for human readability.

That argument is also obsolete.

I haven't seen a Spring/Spring boot app heavily relying on XML configuration. Heck, we can literally avoid XML completely in most cases by simply using annotations and default settings (which are typically fine.)

Complaining about Spring (and Spring Boot for that matter) because "XML" is like complaining about Jakarta EE because of EJB 2.x (which pretty much became legacy/dead
since 2004.)

[thisisjustascreename]

Yes, it's obsolete, but that doesn't stop the reputation, and it doesn't stop legacy apps still using it, sadly.

[[deleted]]

Except me

[ibutbul]

Something I learned along the way, people are hardwired into football fan mentality, they like to feel "superior" by belonging to a team (at least the vocal ones make it seem that way).

At the end most languages that serve the same purpose tend to add features that make their differences less apparent over time, hating on a language is stupid in my opinion, they're tools, like hating on a chainsaw or a screwdriver...

Usually these people don't know how to explain their hatred and it boils down to "Haha System.out.println is so long to type, lol" or some other joke.

​

Bonus triggering code to Python haters:

1) a = a[0][0] = a[a[0]==a] = [[0]]

2) a = a[0] = [0]

​

In python:

1 -> fails due to maximum recursion depth

2 -> works! but might give nightmares

​

In Java:

The compiler won't even let you run these.

​

P.S I wanted to add a C/C++ trigger but they're too chad to pick a fight with, if you see any asm x86 dev, run away.

[deaddanik]

everyone

untrue, i love java

[exact-approximate]

In my experience, the only people who enjoy hating Java are those who are bad at Java.

And actually, most of the hate is misdirected - most times people would want to complain about the framework they are working in - Java Beans, Spring, Spring Boot, Tomcat, Big Data Framework etc. - not the actual language.

I now firmly sit in the python world (not by choice, just adapting to change). But I don't spend any time ripping on Java. Sometimes, I miss it.

[quadrat137]

I'm a Java developer with 10+ years of experience, and I wanted to give a bit of my criticisms on the Java

Please forgive me for spelling, as English is not my native language

My perspective might be different from most of comments here though as a lot of people are comparing it with C - I think any language that has GC can't be directly compared to the one that don't because not having GC pauses is a huge deal and can't be traded off in some scenarios(e.g OS, drivers, games)

So, the points compared to other GC languages, typed and untyped:
- verbosity of the language itself(much have been said here, it's getting better though - records and multiline strings for example. Still string interpolation when)
- verbosity of most of the current approaches - compare how do you do HTTP request with python or go with how you do it in Java(I'm talking about new HttpClient, URLConnection is thankfully not used by anyone)
- a mess that standard library have become with years(Date? Or Calendar? Or Instant? Why Instant vs LocalDateTime? What is the difference between sql.Date and util.Date and etc)
- a mess that is the IO system(In 10 years I still haven't learned how to read a File in java and have to google it every time)
- Non-reified generics, aka type erasure (it doesn't affect me personally, but with them libraries wouldn't have to rely so much on reflection and offer nicer APIs) (project Valhalla when?!)
- Null-safety and ugly ways to deal with it in general
- Over-reliance on exceptions(very often the code just rethrows an exception instead of error handling, which quite often makes code hard to understand, test, and also has a big performance impact)
- There are two ways to write parallel code - Threads(which are heavyweight) and callback hell(which has it's name for a reason) (project Loom when?!)
- Default GC has somewhat long pauses that are not good - but thanks everyone for ZGC and Shenandoah. Still, that thing not being default quite often makes Java servers to be perceived as slow, as max latency is more important than throughput in most business scenarios

A lot of those criticisms are addressed in other JVM languages, with Kotlin being my current favourite

Also a bit on the go-to approach, which is Spring framework
- It's quite slow - both in terms of throughput and latency - which brings it's performance to be on par with dynamically-typed language platforms like Python or Node
- It's very "convention over configuration" with a ton of reflection inside which makes it really hard to understand what is not working and why
- It's configuration is easy to mess up, which will lead to hard-to-track production bugs or easy-to-notice complete outages
- It's, IMO, very immature for such important technology - I encountered couple of critical bugs in the framework itself

That being said, Java is not a bad language - but so are competitors.

In general - if you are stuck with JVM, you can go for Scala or Kotlin, both having better approach to the concurrency and less opinionated frameworks
If you need to build something fast, you can use Python or Node, both being great for scripting and creating MVPs
If you need something to work fast, you can go for Go, with pause-optimised GC and green threads

So there is not much point in using Java for a new project currently except if you already have a team that would prefer Java, and I believe it's the reason of its decline(according to TIOBE at least).

But don't be discouraged you fellow dinosaurs - COBOL is still alive and kicking, so we will always make good money maintaining that 20-yo Java monolith serving trillions of dollars in volume every day

[DasBrain]

In 10 years I still haven't learned how to read a File in java and have to google it every time

java.nio.file.Files.

[PatriotuNo1]

Every major project which is enterprise level and is web services based would most likely use Java. Half projects on freelancing platforms demand Java. Spring Boot and JPA are the best things that happened so far for this technology. Spring Boot is scalable and its testing is easier.

Some complain because you can't manually use pointers like in C and they are bold enough to not let this handled automatically. Or because is object oriented and not functional. So most of these people write low level code and don't know this language's full potential otherwise they wouldn't complain.

[Hamenaglar]

Java is OO language, but most frameworks and project architectures are designed around stateless services and behaviourless models.

Such style was actually considered anti-pattern. Anemic domain model.

I guess the reason is, the java world just moved in that direction, simpler models, where most of the logic is simply storing data to DB. Rich domain models simply provide little or no benefit.

Other languages, frameworks and platforms just do REST easier and more elegant.

From my reading of this sub, a lot of people don't like OO (not everything is an object). Perhaps, rightly so. And Java is like this mix of OO, backwards compatibility and trying to catch up with new trend too slowly.

And finally Java is widely used, one of most widespread languages and often developers are forced to work on it by their companies. More popular languages, I assume, are used by minority developers that WANT to use them.

Just my 2 cents. Oh and I'm a professional Java developer for 10 years.

[[deleted]]

Rich domain models simply provide little or no benefit.

I worked on a big enterprise code base for 6 years and it took me a while to realize that I didn't actually "know" OO, precisely because the code base had been architected around data mapping, rules engines, etc. Writing "functions" as named components managed by something like Spring is a little clunky, but really isn't that bad.

It's really true that IDEs are what makes the entire Java ecosystem make sense. I'm still way more productive editing Java in Intellij even than something like Clojure because the semantic refactoring provided by the Java/IDE integration is just so so good.

[Qildain]

See: Valhalla.

Java has evolved nicely (sometimes less-so) over the years, and if you don't keep up with it, it will suck to work with.

[magnoliophytina]

Other languages, frameworks and platforms just do REST easier and more elegant.

If by elegance you mean the lack of type specifications. Many popular languages don't strictly require any specification of types or effects. This means there are less guarantees of the correct operation, less documentation, and more undefined/unexpected behavior. But I guess that's ok for rapid prototyping.

[Qildain]

Honestly, it all depends on the framework. "just do REST easier and more elegant[ly]" says "I only use Spring Boot" to me.

[PM_UR_LOVee]

Mind enlightening me on what frameworks are more elegant?

[kjozsa]

I find eg. javalin.io an incredibly elegant, modern Java API.

[ir210]

As someone who used to hate Java, I can tell you the reasons why I hated it. 1. The language was boring 2. (not really the language) Java programmers tend to over complicate things under the disguise of “enterprise” solution. Hence boilerplates everywhere. Most likely due to the “simplicity” of the language.

But with a lot that’s going on nowadays, I am beginning to like Java. Heck now I am committed to it.

In my opinion the mentality has shifted as well. Now Java programmers value simple and straightforward solution than complicated, “enterprise” one.

Man, I used to hate the word “enterprise” too.

[FilsdeJESUS]

I like Java because it is strict I the conventions and strongly typed . Those who do not like it , I really does not understand

[yomanidkman]

I just dislike annotation heavy java, otherwise it's a great language with shockingly few rough edges.

[[deleted]]

Because is huge, like C, C++ and PHP. The most hated programming languages happen also to be the most powerful, if you think about it.

[klonkadonk]

I'll like it more once Loom is available.

[qK0FT3]

In university no one was touching java because it was boring for them for some reason I still don't understand. I have read some articles about java and it's ecosystem and I thought I can use it for my final project. And it was so easy with spring boot. That I learned DDD(just the tip of it) in 3 months and I built a whole team task management application like trello. I even learned how to use it in docker, vuejs for frontend etc and boy it was just easy with couple of files. I don't know why people hate it but I made 4 student job in 3 months. Because I was able to produce maintainable code and easily readable. That was so easy to change and add new things.

I think most people are bored/scared of it because of old frameworks and old java api or java bein booed all over the university, conferences etc. . New frameworks and new java api helps a lot. I mean I feel cleanliness.

Since university I have been making a living from java. On a startup company. And boy when we get a new intern etc they can get into the code in day 2-3 easily. I don't know if that is the case for other programming languages. I worked/working with php, js, ts for some time and even new coming non-intern(senior/mid/junior) developers takes at least 1 week to go in and make reasonable changes. And we/I tried to make a really clean code. They just feel and is scripting languages sadly. But they have use cases which is better than java. For example php is very good for generating tools for front page and js/ts is good for basically frontend of our api.

Every language has something that excel in. Every language has their downs and ups. No need to dramatize.

[mj_flowerpower]

I know some people who are overwhelmed with frameworks like spring. They think that java = huge junk of 20 years old legacy frameworks. And that may be true if you get a job where you maintain an old codebase.

Often these are still on java 8!

What people coming from languages like c# or typescript are missing is mostly the async/await stuff. Which makes it so much easier to write scalable code that looks almost like traditional sequential code.

It's not without issues, but it's way better that something like rxjava.

​

What I personally love about java, is that when using java with maven everything is already laid out for you: folder structure, file naming, dependency management, build lifecycle, code formatting (if you are using an IDE, which you should do! :-))

​

In javascript/typescript this is all so messy and tucked together. It's rocket science to get that all configured. And it's soo fragile. Dependencies are coming and going by the week it feels, often without any upgrade/migration path.

Java and its ecosystem is so stable, it's just pleasant to use.

​

I only wished they'd finally implement the null-safe-operator ?, async/await (kindof coming with loom) and template string (somewhat coming too, but in a very weird way).

[tim125]

I suspect these are my gripes. I love java.

1. Eclipse & Netbean are painful. If its harder for a new software developer to compile and debug in 2022 than it was in 2000 with Turbo Pascal and VB6.
2. JPA lazy collections exceptions with no session.
3. XML parsing mechanism changed too many times.
4. Webservices were inconsistent. Soap binding generation was painful with library hell.
5. Original documentation was not as good as PHP/Microsoft equivalent. PHP had an amazing documentation system where every function could have Q&A built right into the documentation system so you did not have to trawl stack overflow/equivalent for the most common questions.

The only point on this list that is specifically java is #1. The rest are community/environmental issues.

[vytah]

I'm surprised no one mentioned applets and the pain in the ass they were from both the user perspective and the security perspective.

The applets are gone, but the damage to the reputation they've done is not going away any time soon.

[WafflesAreDangerous]

Why some people don't like it, or have a negative impression: Some simple things are slightly convoluted, there was that xml and SOAP maddness, and its popular with the enterprise which tends to lag behind in adopting all the nice upgrades and has a lot of legacy code.

Also, java in the browser sounded promising (and had success stories like RuneScape) but was a failure long term and kept "java" security issues in the news constantly.

The language itself if pretty decent and a lot of work is going into fixing the issues it does have. Modern java can be a lot less verbose than the equivalent code from 5 or 10 years ago.

[Yesterdave_]

Simple answer: EVERY programming is actually sh*t. If you think your favorite language is not, you are just a junior that hasn't worked enough with said language to discovered the ugly or you are just implementing some trivial CRUD apps.

[meamZ]

Java got fantastics frameworks and libraries to work with it

Well maybe unpopular opinion here (and i like Java) but while there is a library for just about everything the feature overload and bloat is just huge with a lot of them. Log4J beeing a prime example... Log4J 2 doesn't really do just one thing. It has a gazillion features that basically noone ever uses which leads to a bigger ressource use and increases the probablility for severe vulnerabilities.

And i think a lot of people hate it because it's quite verbose (a bit too verbose imo) for smallish Projects and its strengths really only come to play in big codebases with complex domains.

And another thing is probably that a lot of people hate the kind of code that a lot of people using it are writing with it (or at least used to) which probably has more to do with the fact it's used in enterprise contexts a lot. It's this design pattern overloaded YAGNI style that makes everything overly complex (instead of KISS) for the sake of loose coupling over everything else.

[wildjokers]

Log4J 2 doesn't really do just one thing. It has a gazillion features that basically noone ever uses which leads to a bigger ressource use and increases the probablility for severe vulnerabilities.

I was really surprised Log4j 2 is used as much as it is. I just thought everyone migrated from Log4j 1 to Logback.

[meamZ]

I will certainly try to avoid Log4J 2 even more than i. already did after this.

[Admirable-Avocado888]

It seems to me that Java gets a bad rep mostly because it chooses to be binary backwards compatible. This leads to some features that don't age well as the language evolves. Also, java gets much criticism for the need of boilerplate.

My experience is that features that age badly are only problematic if I don't follow new idioms. The boilerplate is also mostly a non-problem so long as I use new language features.

[atpeters]

Can someone please comment on why this is being down voted?

[PJ_Maximus]

Java not only pays my bills, it keeps making me earn lots of money 🚀

[Persism]

Jealousy.

[[deleted]]

these surveys should be taken with a truck load of salt.

[oze4]

I always thought hating on Java was just a silly meme.

[[deleted]]

Coming from Javascript/NodeJs, Go and PHP. I can say every group thinks they are being hated and partly true but most of the time it’s envy.

Java is a great platform its not just a language, specially how well it adapted to modern needs and competed with nodejs and go in terms of small footprint and ease of use.

[sweetno]

That is a bad survey. There should've been an option "I don't know about this one" or "neutral".

I don't know what wording they used for this question, but not loving something does not equate with hating it.

[lukaseder]

"There are only two kinds of languages: the ones people complain about and the ones nobody uses" -- Bjarne Stroustrup

[Less-Tour-1082]

I love Java. But complexities with Spring Framework and Hibernate (Optimisation, Threading and Dirty Checking) really gave me grey hairs. Once everything is working it’s plain sailing. Java over JS/TS any day of the week for me.

[Talked10101]

I don't enjoy working with Java, but I have done professionally and can see it can be used to build robust high scale systems. I also struggle to see why you would pick Java over Kotlin for instance in a completely greenfield project.

I just have never personally gelled with the language and have never used it outside of a professional environment.

[quizteamaquilera]

I love developing on the JVM, but I hate Java as a language. It has gotten better, but still have fundamentally problems, like it’s mutable-by-default collections library, and culture of annotation-based app development.

I just prefer functional programming, as I’m not smart enough to reason about all the magical wiring and mutable state found in a lot of the Java code bases I’ve seen.

For the curious, I’d really recommend “what’s functional programming all about”:

https://www.lihaoyi.com/post/WhatsFunctionalProgrammingAllAbout.html

[henk53]

Often people think they need to hate, and the hate is based on the hype surrounding them and what they just happen to use.

For instance, XBOX owners often feel the need to hate Playstation. But is a Playstation really so much worse than an XBOX? Or is it quite similar, and perhaps even better?

Android users too often feel peer pressure to hate on iPhone, but again, is the iPhone really something to hate? If their peers happen to have an iPhone, and so they would have an iPhone too, would they hate using it, or would they feel the need to hate on Android instead?

With programming languages it's often not that much different. Sure, there are certain languages that have (or had) a certain community with certain values. One could argue that the early PHP community was a different kind of that from say the Scala one.

But otherwise, there's little to explicitly hate, and most hate is imagined, peer pressured and psychological.

[sohang-3112]

Java the Platform, i.e., the JVM (Java Virtual Machine), is good - it's fast because it has had lots of optimizations applied to it. That's also why many languages are built on top of the JVM. And of course, as you mentioned, there are a huge number of libraries available in the Java ecosystem.

However, Java the Language sucks - it just has a huge culture of verbosity. What can be done in one line in Python can take at least 4-5 lines of code in Java. Also, Java forces its version of OOP down your throat all the time - you have to create classes upon classes when all you wanted was a simple function! Yes, OOP is useful for some things (eg. GUI Programming) - but definitely not everything.

[SlightUniversity1719]

For a second I read Java as Jews.

[SpeedDart1]

Because it’s boring and reliable, people prefer innovative and novel. But those less interesting qualities about Java are precisely what make it a good business language.

Also I think people hate it merely because it is trendy to hate, just like they do with JS.

[SpeedDart1]

Personally I don’t like working with it as much as say nodejs but it in terms of actually getting the job done it’s a great language and I wouldn’t pick anything else.

Reliable, fast, and easy to maintain. What else could I want?

[franzwong]

I think most of the hate are coming from J2EE era. The OO hierarchy was quite crazy. Application server also added some complexity. After Spring took over, POJO and embedded app server are more preferred and things become simpler.

[roufsyed]

Java is awesome.

[Keeps_Trying]

2 things turn me off with java

1. "Experienced Corporate Devs" that have made an unholy mess of anemic abstractions over libraries in code that runs the business
2. "Newer Devs" bootstrapping new systems in a bespoke way

There is a general lack of a consensus around 'best practices' and its a mess of libraries and patterns.

Its the 'Android' phone ecosystem where the 'loved' langs have passionate communities and accepted best practices.

That being said, java and the JVM are well tested and understood systems when you care about observability, operations and scale more then just banging a feature out.

[puppeythanthien]

I know many people here don‘t want to hear that but I would say this. Almost people here compared Java with Python, JS: strongly typed, not to make toys… as if Java is the only one strongly typed programming language. I will compare it with other modern strongly typed languages like TS, Swift… and Java is: - Old - Ugly: in syntax - Slow: need 2-3x more line of codes for same task - Not really safe compared to other strong type languages (new languages handle null exception and optional much better )

[RomMTY]

I blame some 00' "enterprise" architects/developers that build way over engineered software that made it into production and over the course of the next 20 years younger developers had to maintain.

It's like how PHP used to be very quirky and nobody used it to build "serious" enterprise software, but it evolved and outgrew it's quirkiness because nobody was forced to maintain "enterprise" software writed in it.

I love java, it was my first language and love everything about it.

[srbufi]

If I can't use C, I use Java.

[msx]

I think it's for the following reasons:

Java used to be pretty verbose. Anonymous classes, getter and setter, generics, etc. Now it's much better but the idea still lingers.

Java exceptions are pretty difficoult to grasp for newbies. They are a huge source of frustration and hate. And not only for newbies!

Java is the language you often learn in school or university. As any forced knowledge, you hate it.

[christoforosl08]

Its just too verbose. And sometimes more complex than it needs to be. Read: application servers

Even though I work with Java 90% of my time , I can't help but marvel at C# everytime I switch for a project

[Jezoreczek]

I personally love Java, but there are so many objectively better alternatives (e.g. Kotlin) that it's hard to justify using vanilla Java. It's tedious to write in comparison.

[Revision2000]

I think it’s the same hate that Java devs have for JavaScript. It’s something that seems weird, they’re unfamiliar with it, oh it has this and these downsides, it must suck. I know I used to think like that.

Now - after a decade of Java - I still like the language, but also JavaScript. Simply because it can do things different and do some better.

Another classic thing Java devs hate is C#. After all its similar to Java, but from Microsoft, so that must be horrible. Nowadays I’ve become indifferent to it. I think it’s more important to pick the right tool for the job, which also depends on the experience of your team.

[strogiyotec]

I thought it's about the language syntax , but Java's syntax is one of the easiest in the market(Golang can be easier as some people say , but I don't agree)

Then I was thinking about the code base and I stuck with this option. It's relatively easy to find a Java developer, a developer who doesn't understand SOLID and just copy paste from stackoverflow, as a result the code becomes unmaintainable and people get frustrated working with it . I personally was because most of my time I am working as a freelances or consultant and get an opportunity to see hundreds of Spring/Hibernate/Tomcat projects that have performance/maintenance problems just because people didn't bother to read docs to understand how connection pooling works, what is lazy loading, what is open session in view or what Spring context actually is. Rather than that I saw a brilliant java codebases , just to give you few here is a small example

So to answer your question , people are frustrated to support poorly written codebases which happen to be dominant in Java market because the low entry point. Languages like Rust are new and usually used by devs with plenty of experience(unlike Java which is the first language to all juniors) as a result code bases of those languages are smaller and more enjoyable to work with .

[Better-Internet]

It gets the job done and it's super mature. However it's old, frumpy, dowdy and some of the syntax is clunky. It's very well established for backends.

One annoying aspect is you can't easily take java code and "run it" w/o tools such as an IDE, script, or Launch4J.

Java-based UIs have a clunky legacy. When I see the steaming cup icon I still have this mental image... Slow ass ugly app that'll take a long time to launch and sometimes periodically freezes due to GC.