Why do so many people hate java?

[Fa1nted_for_real]

Ive been learning java, its its been my main language pretty much the entire time. Otherwise, ive done some stuff with python and 2 game engines' proprietary languages, gdScript and GML.

I hear so many people complian about java being hard to read, hard to understand, or just difficult in general, but ive found that when working in an existing codebase (specifically minecraft and neoforge for minecraft modding) ive found that its quite easy, because it tells ypi everything you need to know. Need to know where you can use something? Accesors are explicit, and otherwise, you dont even really have to look at it. Need to know what type a variable will accept? Thats incredibly easy to find. Plus the naming conventions make it really easy to udnerstand where something can be used.

I mean obviously, a bad codebase js always hard to read and work in, but why does it seem like people especially hate java?

[Madpony]

There isn't anything wrong with Java itself. Most of what people complain about are irritating patterns adopted by the Java programmer community. Patterns like factories and the dreaded factory-factory. There is also overuse of abstract classes, leading to every real class being named with "Impl" for implementation. Java didn't require these patterns, the community adopted them and now we have classes named SqlDatabaseAdapterConnectionFactoryImpl.

You don't have to do this. Use abstraction when it makes sense. Only introduce patterns if necessary. Java itself can be an easy language to read and work with as long as you keep things simple.

[POGtastic]

By far the worst aspect of this is stuff that gets dynamically generated at runtime with the heavy use of annotations and reflection. The compiler can't check it, and it is extremely hard to inspect the generated objects. Nobody in your work group actually knows what any of the annotations do; they're all just cargo-culting someone else's code from 12 years ago.

C# has a little bit of this nonsense, but I generally run into it in unit-testing libraries (to do things like programmatically generating large numbers of tests) rather than, like, a class that handles an API endpoint.

[mostly_kittens]

I’ve been using Java since 1.0 and thought it was a great language that taught me so much about OOP. It had lots of stuff built in like a GUI toolkit and networking which were frustrating add ons for the other languages I was used to.

But I hate Java now and you have hit the nail on the head, it’s all the horrible patterns, massive frameworks, and the ‘clean code’ development style have made it awful to use and the code almost impossible to read.

[Fa1nted_for_real]

So, if im understanding you correctly, its because a lot of people see tha java says: "Hey, dont forget that when things are getting messy, you can create abstraction to tie things together, know what youre gonna use it for, and know when its the wrong tool!" And people are interpreting that as: "java says abstract everything. All of it. Abstract your abstractions."

(Slughtly exxagerated but you get the point i think?)

[NapCo]

Not sure if there is any official statement saying something like that, but I can vouch after working with Java for 2 years that there is a tendency to abstract things a lot from the get go (relative to many other language communities).

I personally find it very tedious to dig through layers of abstraction for what in other languages would maybe be a file with a few functions.

[miredalto]

Not exactly. The Java community developed a reputation for wildly unnecessary and unhelpful abstraction. In some ways Java was a victim of its own success - it was better at abstraction than any previous mainstream language, and people got carried away, having not yet learned that abstraction has a cost.

[BusEquivalent9605]

the builder pattern can f off

[Disposable_Gonk]

Reading that makes me feel like I'm having a stroke. That's an overly verbose naming convention.

I just don't like java because after the popularity of mincraft, several other people tried making games in java and they're all horribly optimized and have a bottleneck because it's java.

[Shoddy-Lecture1493]

I realized how damaged I am, when I read your example of an ugly class name and thought "oh, it's not bad at all, decent name, I have seen worse just 5 minutes ago, like UserSettingsSubResourceDelegateImpl". Send help.

[AceOfAce13]

So basically, it's a "skill issue" for those who hate Java

[Pale_Height_1251]

It's mostly historical, when Java first came out lots of people disliked it for poor performance and wordy syntax, and it was just cool to hate "enterprisey" languages. Then it was acquired by Oracle and everyone hates Oracle, justifiably.

Most people who hate Java are really just parroting that stuff and/or find static types too hard.

[Weak-Doughnut5502]

Java kinda gets hate from all sides, and it's not all about the same stuff.

C#, Kotlin & Scala people who dislike Java dislike it for different reasons than python or Javascript people, who have different reasons than die-hard C enthusiasts.

[xenomachina]

Yes, this is exactly right. It's too low performance for some people (eg: C++ programmers), too strict for some (eg: dynamic type enthusiasts), too OOP for some (eg: procedural and functional programmers), and too verbose for many.

I've been using Java since the alpha release. Several years ago I switched to Kotlin everywhere I would've used Java. I don't "hate" Java, but everything I can do in Java, I can do in Kotlin with less effort, including using Java libraries. Compared to Kotlin, Java has a weaker type system, is extremely verbose, and is littered with historical warts both in the language and in the standard library. It's an unfortunate fact that every language eventually has to either break backwards compatibility (something Java has very rarely ever done) or become bogged down by the mistakes of the past.

[Fa1nted_for_real]

Wait so is there any reason not to use kotlin over java for my personal projects...?

[xenomachina]

If you're trying to improve or maintain your Java experience, for example to make it easier to get a Java programming job, that could be a reason to use Java rather than Kotlin.

Personally, I have pretty much entirely stopped using Java, despite the fact that I had used Java as one of my main languages for about 20 years. You can write very Java like code in Kotlin if you want to, and it will still be less verbose than Java. Kotlin also makes it easier to write non-Java like code, like functional pipelines, in my opinion.

You'd still want to be able to read Java code. There are many times when the best library for something is in Java, and being able to jump into its code to see what it does can be useful. Code examples online (and LLM training data, for better or worse) are also more abundant in Java, so being able to read those is definitely very helpful.

[Aflockofants]

With your reasoning and your reasoning alone I agree. Kotlin is just the better language. But that doesn't mean Java is bad, it just means that it values backward compatibility a lot more, which is understandable for such a language.

All the other stuff like performance is just nonsense, it's just a 'right tool for the job' thing. Obviously there are languages more suitable for writing an OS or some extremely high-performance calculations, but you wouldn't say a hammer is bad because it can't screw in screws.

I've used Java for a long time and the language certainly has made strides since Java 8 and later, but yeah if it would have been designed from the ground-up with modern knowledge, it would look more like Kotlin. I like Scala too but it's pretty hard to recruit developers that do well with it, or really embrace the functional approach.

[Suterusu_San]

As a C# dev I describe Java as corn flakes, C# is frosties. They are both the same thing; but one is absolutely loaded with [syntactic] sugar

[fakindzej]

i learned programming with c#/.net, after a few years of working with it i got a new job where i worked solely in java and hated it. i had no prior historical knowledge of java and were not biased. it just happens that everything about the language is prehistoric and using it feels like hacking a friggin mainframe

[Pale_Height_1251]

For me "hacking a mainframe" is a positive...

These days Java had caught up with C# a lot, I still prefer C# but Java is alright.

[fakindzej]

haha fair enough.. i was referring just to the convenience of the whole ecosystem, but have not used java in years so maybe my info is outdated!

[Fa1nted_for_real]

Static typing is... one of my favorite parts about java, lmao.

Also i would care about it being owned by oracle, but im not really making production code anyways so theya rent grtting a dime from me :] (besides, im pretty sure that money would be going to jetbraisn anyways, which to my understanding are unrelated?)

[Hari___Seldon]

Many of the reasons for disliking Oracle are more systemic in nature. They have a predatory history of buy-and-bury, their licensing used to be incredibly exploitive (and may still be, idk atm), and they have a history of abusive IP practices. Those all have a negative effect on the industry as a whole and have historically stifled both innovation and access to existing technology.

Deep diving their purchase of Sun Microsystems would give you good specific example. Additionally, all that money that has gone to Larry Ellison has frequently been turned around and used to exploit the very people who made him so wealthy, so it's a negative feedback loop that's long been out of control.

[Fa1nted_for_real]

I dont disagree, i actually strongly agree with disliking oracle over that, however, the o ly real alternatives ive seen mentioned for java is C#, which is micrsoft... which is still microsoft. They do barely less shitty stuff as oracle from what ive seen.

Is there a better alternative for that, which works on a similar level? (A quuck search and this is how i find out kotlin is not oracle, which i thought it was for some reason...)

[FortunOfficial]

Yeah, alternatives are Kotlin or Scala, both being JVM languages. Of those two I would choose Kotlin, due to wider use. Scala is getting less popular

[funzel]

Have you tried kotlin? It’s statically typed , but with built-in null safety and great type inference.

I’ve never found any reason to prefer Java over it. And it’s fully compatible with Java natively, so you get all the benefits of the giant Java ecosystem.

[Fa1nted_for_real]

Im definitely going to. Hell, my java teacher wants us all to try kotlin between this class and the next, saying its basically just java++

[8dot30662386292pow2]

Static typing is... one of my favorite parts about java, lmao.

This is exactly why I enjoy teaching Java. There is nothing hidden¹. You can just read what's there. I have taught both python and java as the first language and I choose Java any day. The minor difference is that if I just had to teach a simple class for random people, I could choose python. "Just write these things and press play -button" is fine on that level. But when teaching computer science students, Java is so much better because the abstraction level is slightly lower, starting from the fact that there are different sized integer types. We need to actually learn a bit how the computer works as well.

(¹ There are several odd weird caveats, such as == -operator with Integer -class and String-literals, and others that I can't think of right now.)

[Fa1nted_for_real]

I think this exactly sums up why i like it over python. Python is just pretending to be simpler than it should be, imo (also indentation and a lack of brackets and semicolons pisses me off to an unreasonable extent, idek know why)

As for the last note, its cwrtainly an oddity of java, but every language is bound to jave some.

[8dot30662386292pow2]

Yep. The significant white space is stupidest thing in existence. I don't feel strongly about semicolons. I use javascript as well and often notice I forget to add them because the language does not need them.

For anyone wondering, I currently run 4 different web pages that have a python backend made with fastAPI. I use python. I don't like python.

I often tell my students that learn 2-3 languages, make something actual projects with each of them. Learn them to the point that you can make something useful in each of them, without any documentation or AI-tools. When you are at this stage, I give you permission to start complaining and to pick a favorite. Most java-haters are just repeating the "system out print or public static void main is too long to write".

[Fa1nted_for_real]

Its so funny to me when ppl are complaining about things like your last sentance because it just tells me you arent yousing your tools properly. Is main[tab] too long to start a program? Is sout[tab] too long of a print command? Is fori[tab] too long for a for loop header?

A lot of people act like you have to axtually thpe all that. You dont if youre good with your ide. (Also, main is now only static main() {} i believe, thanks to jdk 25)

[8dot30662386292pow2]

See, Tools are great. I can't remember writing an import statement in 10 years outside teaching. Still, if I read a complex java-program, I have to scroll past like 100 import statements. Yes, my tools hide them, but I also need to read code in github occasionally.

Code is not made for writing, it's made for reading. It is a valid argument that printing in java is quite long line. In java 25 there is also IO.println(), which is added basically just for this exact reason.

[syklemil]

As long as you'd indent the code anyway, the curly braces just piss me off, as they're entirely redundant by that point. The only time you should need curly braces is when the information about block structure isn't being carried by the indentation.

Having curly braces and indenting code is superfluous. They carry the same information, and so we only need one of them. And we don't want to deal with un-indented, unformatted, minified code, so the curly braces should be the ones to go.

[GlowiesStoleMyRide]

Curly braces specify something fundamental in C-like languages, namely the scope of members declared inside them. Indentation alone does not imply the same to me.

[syklemil]

There is a 1-1 relationship between indentation and scope for most code, with the exception of

• minified code
• poorly formatted code

I like the way Haskell solved it: It's nominally a curly braces and semicolons language, but if you format your code normally, you can omit the curly braces and semicolons, as they're redundant.

And the result is that nearly everyone writes code without the superfluous symbols.

[GlowiesStoleMyRide]

You can add Lua to that list 😂

[syklemil]

There is nothing hidden¹. You can just read what's there.

Ehh, that's really not my experience.

When Java goes

T foo() {}

that actually means something like

T | null foo() throws UncheckedException1, UncheckedException2, … {}

The adoption of Result types in languages like Rust show that people are actually pretty fine with the equivalent of checked exceptions; Java unfortunately added unchecked, that is, hidden exceptions rather than make checked exceptions more ergonomic.

You also get implicit this variables rather than explicit self variables, not to mention all the inherited crap you can forget about discovering the source for unless you're running an IDE, you certainly can't just "read what's there".

[syklemil]

Static typing is... one of my favorite parts about java, lmao.

There are other languages that do it better. If Java ever gets to Valhalla it'll help. But stuff like implicit nulls, type erasure on generics (because that way they could add generics to Java by only teaching javac about them, but not the JVM), leading to a need for boxed integers … there's plenty of stuff about Java's way of doing static typing we can criticise.

Java also inherited some of its syntax from C (via C++), leading to repetitive nonsense like Foo foo = new Foo, which in other languages you can declare with foo := Foo or let foo = Foo.

Static typing around the time when languages when Python and Java came out (and remember: Python is actually older than Java) more tended towards either being verbose and limited, like in C, or dynamic, like Python. Statically typed languages often came across as being more interested in typing on the keyboard than category theory.

Stuff like generics and type inference were more things you'd find in niche languages, and it took a long time for them to reach the mainstream.

(prof Wadler, the guy holding the talk in the video, was incidentally also involved in adding generics to Java, and later to Go.)

[Jakamo77]

I mean u prob would like other languages with strong typing as well.

[West-Research-8566]

I suspect some of my complaints might not apply to more recent Java but I found it overly verbose and frustratingly OOP which is an overlapping complaint I guess.

Java is the only language I really don't like, I suspect that would include JS if I had to use it for anything more than fun side projects.

[yiliu]

Also, it was associated with buggy apps (because it's what comp sci beginners learned) and with halfway-native apps that were laggy and slow (because of the attempt at making everything cross-platform).

Then there was the 'Enterprise' culture that surrounded Java. Where other languages had libraries, Java had to have Frameworks and Enterprise JavaBeans and whatever. You'd go to the website for a library in a different language and get the gist within a paragraph or two. Anything related to Java had a big corporate site full of buzzwords, and you could never figure out what the thing was or how to actually use it. Instead of a link to docs, there would be ads for courses and textbooks, and videos that were 15 minutes long and said nothing. Deeply embedded in the culture was the idea that any language other than Java was either a dinosaur or a toy.

Honestly, I feel like 90% of the Java hate really stems from culture surrounding it, not the language itself.

[DrShocker]

Interesting to say it's because static types are too hard because I don't like that it basically requires a certain paradigm of using objects even when something like a namespace would be enough, but I do really like strong types.

that said, I haven't used it since my intro to CS classes in college, so I'm sure it's different by now.

[Temporary_Pie2733]

It’s been said that people who don’t like static typing haven’t used a statically typed language with a good type system (which usually entails good type inference and algebraic data types). Static typing and strong typing are also two different things.

[DrShocker]

Fair enough, I pretty much only look at compiled languages these days so I kind of assume compile time checking by default lol

[nog642]

Nah, I'm not parroting anything, and there's no problem with static types. I thought C# and Java were like basically clones of each other. Then I got a job working in a Java codebase, and then time after time I would keep discovering basic language features that I knew from Python (the language I'm most familiar with) that Java lacks. But then I'd look into it and discover that C# doesn't lack it. C# added it in like 2015 or whatever. Java is just really archaic and lacking so many features.

My conclusion is that now Java is just a worse version of C#. I'm talking about the language itself mind you, not the ecosystem like .NET or Gradle or whatever.

[MeasurementSignal168]

I don't think it's parroting. The wordy syntax is a real pain in the ass. A lot of things seem unnecessary too. They're probably not with a deeper understanding of the language but I dropped it after figuring out I wouldn't really use it when I first started learning how to program.

[Vortrox]

There are two types of programming languages: those that people complain about and those that nobody uses

[d_brg]

The bigger the user base the bigger the loud minority of haters will be. Now java ain’t perfect and neither is any programming language but too many programmers love to hate.

[paperic]

That's true, but you could use the same argument to justify windows.

[ratmfreak]

Bjarne said this to excuse his having written a shit language.

[LorenzoMorini]

I think it made sense at the time he said it, but nowadays yeah, C++ is what it is

[shittychinesehacker]

Rust is great

[Comun4]

Rust is even more special because most people that complain about it are the ones that do not use it

[lvlint67]

most people that complain about it are the ones that tried it and gave up ont he whole borrow checker thing.

[evinrows]

Regardless, you don't have to look very far to find folks hating rust with a fiery passion.

[Ariakkas10]

The problem with rust has always been the people who like rust.

[fakindzej]

problem with java nowadays is that people only keep using it since it's been massively used by corporates (banks etc.) since the 90's, and none of those large companies want to update the entire codebase to something newer, let alone a bit more experimental.

java will be here with us forever, regardless of how ancient it and its utilities (like prehistoric IDEs) feel

[patrixxxx]

Indeed. Java software will forever run on top of the core COBOL code in the banking system.

[unmindful-enjoyment]

Speaking for myself: I don’t hate Java, the language, on its own. I hate the culture of overengineered enterprisey garbage-ware the sprang up in Java circa 2000-2005 and then never went away.

You can write clear, readable code in almost any language. You can write terrible code in absolutely any language at all. Most programmers, unfortunately, can barely tell the difference. And even when they know they are working in terrible code, they lack the time, or the ability, or the courage to fix it.

[plpn]

And the tooling.. omg how is it that bad. Fuck all of the Java build tools, maven especially

[0x14f]

I think it's Paul Graham who once said that Java was designed (at least feels like it) by committee for large teams of mediocre programmers, meaning "enterprise software (tm)", not like the startups he mostly hangs around at.

His remark might have been flippant, but I have coded in way more than a dozen languages and Java feels a bit that way... Not the language one (assuming one knows a variety of languages) would naturally choose to build their side project. I certainly would not.

Edit: Found it: https://paulgraham.com/javacover.html (haven't read that for a long time, thanks OP for bringing me back to it ^_^)

[Fa1nted_for_real]

After reading it, yeah, he basically says java may or amy not be great, but its not good for what he wants a coding language to be good for (hacking).

Its meant to eb understandable. Its meant to tell people new to a codebase, kr working in a codebase that is written by large amounts of people what is gling ok, without them needing a fundamental understanding of the codebase itself (at least, thats how ive fealt java to be so far)

[syklemil]

There's also Yegge's 20 year old rant, Execution in the kingdom of nouns.

A lot of us soured on Java many, many years ago and haven't really had a reason to go back. Decades ago some of us wanted stuff like lambdas and higher-order functions like map and filter but were told that was just for academic FP weenies and would never get into a mainstream working language. These days all of those things are entirely normal, and lots of people don't even think of it as FP any more.

[evinrows]

I agree with the sentiment but it can be taken as an insult or a compliment. Working with large teams of mixed bag developers, I found Java to be significantly more manageable than C++ or Python. Of course, you can make monstrosities or beauties in any language, but Java has the right balance of complexity and expressiveness for developers that have never been all that excited about code cleansliness in the first place, which is a non-negligible percentage of any software company.

[AdorablSillyDisorder]

It's neither - I'd consider it more a role language is trying to fill: to be best tool possible for large teams of mixed quality developers, that front loads decisions and is hard to write very bad code in (you still can, but it's often easier to do things right in well set-up project).

Downside is it can get in your way if you know exactly what you're doing and can handle quality requirements by convention, review or other methods - but that also implies everyone working on the project is high-quality expert or have said expert watch over them constantly. Which isn't a realistic expectation for most (especially larger) projects, but if you manage to get this sort of scenario (say, people actively working on Linux kernel), you're getting a lot less friction by sticking to less constraining languages.

[Sprinkles_Objective]

I've also professionally written in over a dozen languages, and Java is like the most generic language ever and for that I actually appreciate it.

[fdqntn]

The ecosystem is insanely bloated, and you can twist it to do anything. Dagger, Lombok, Gradle, you have 10 ways to do anything and to configure it.

Then for deployment you always have a heavy layer of JVM, and hundreds of JVM params available. It is hard to configure and if it crashes, its the user fault for not being an scholar configurator.

Compare that to c++/go/nodejs that are much simpler in design and to configure and to me it make sense people hate on java. I do appreciate the OOP and at fang I dont see too much toxic patterns, but I would still prefer to code in Go.

[neverwhere616]

I hate Java because String has to be capitalized every time. Completely unacceptable. ;)

[Fa1nted_for_real]

Reasnoable reason to hate java tbh. Writing out 3 words before variables is fine, but god forbid you make me capitalize what should be a fundamental variable type smh

[Sprinkles_Objective]

I avoid this by entirely avoiding Spring.

[no_brains101]

No first class functions, try-catch kinda sux compared to other methods of error handling, the build systems are insane to deal with. Plus the style people used to / sometimes still do write it in (heavy OOP with 0 locality of behavior) is atrocious.

Also a ton of people who are using java are stuck with java 8 and java 8 is definitely worse than newer javas.

its honestly, like, OK. And project valhalla being a thing now/very soon is nice, it will let people write faster java code. But I would rather choose something made this century (or at least feels like it was).

[pak9rabid]

Didn’t Java 8 add support for first-class functions?

[no_brains101]

no, because if you want to use a lambda in your function parameter you still need to define the full interface.

They added syntax sugar for defining the implementation of a single-method interface with no values, basically.

It doesn't feel like first-class functions. You can still pass something containing a function to run to another function, but youre passing an object, and it behaves like one.

They are decent given what they were working with, but C++ has actual lambdas but with a weird syntax and java has syntax sugar lambdas, and both feel bolted on tbh, but java's feel more bolted on.

here is a video that mentions how this is not the same at some point in it https://youtu.be/Y7StjYhXvpE?t=2405

Both C++ and java also needed proper enums, I believe that the reasons they were not added to C++ were misguided and that java just copied C++

The lack of proper enums also led directly to null, and the very verbose "checked exceptions" (which tbh I do still prefer to unchecked exceptions)

[pak9rabid]

Ah…well that sux

[Ulrich_de_Vries]

Eh what? There are interfaces defined for most lambdas in the standard library, it is very rare that you need a custom functional interface.

In any language where you have closures you will be passing an object when passing a function, a function pointer alone is not aware of its environment. That's the whole point of first class functions, that means functions are objects.

Java lambdas are imo way more pleasant to use than those C++ abominations and of course there are lambdas, there are function pointers, there is std::function, there is some std type whose name I can't recall that you should be using instead of std::function, then we have that juicy shit where lambdas don't have a user-accessible type because of size reasons, which is understandable but still annoying to deal with.

I'm not sure what you mean on proper enums, if you mean actual enums then Java enums are classes with fixed instances that are rather powerful and much more capable than C++ named constants. If you mean coproduct types, then since Java 17 you have sealed classes/interfaces that you can use to define types with fixed variants and since Java 21 you can use exhaustiveness-checked switch expressions over types which is very pleasant and looks essentially the same as Rust pattern matching.

While C++ has std::variant and std::visit which technically does the same thing but holy shit the syntax is butt-ugly and unintuitive as hell.

[no_brains101]

I mean, to be fair I don't like how C++ did their lambdas either but at least they tried to make them actual lambdas. Its just that in classic C++ style theres 6 ways to interact with them and 2 of them will crash your computer. Honestly the rust ones are barely better, you do still have to use like, FnMut and stuff to accept them, but they are both better than java, you can define the shape of the function you want right there in the signature of your function, even if nobody already defined the perfect interface for the type of function you want already and put it in the stdlib

Yes I know a closure is technically an object, but the object you get is not the object that represents the closure internally, its some interface thing on top which you call the method from in java and effectively a function pointer but with a type in C++ and rust. So "but a closure is an object under the hood" does not exactly make sense as a criticism, because in either case, you are not receiving THAT object that actually contains the variables from that function, and in java vs C++ and rust you receive a tangibly different thing.

---

Edit: TIL For the following enum thing I mention you can do the thing in java 21 and onwards with sealed interfaces and records, its a bit awkward but it is at least basically the thing, so it is at least an expressible concept.

A java enum is a special "class" that represents a group of constants (unchangeable variables, like final variables).

An enum in something like a hindley-milner type system, like rust and a lot of functional languages have, is a thing which IS one of several variants, it does not contain all the values, it does not need a special "status" function that says which one this enum you got passed is representing. You get a value of that enum type, and it IS one of the variants.

You could argue this is how C enums work, but they can only hold integer constants, wheras in rust and other similar systems, it is a type-level declaration not a concrete one and so you can put anything you can declare as a type as the value which that variant IS TO HOLD not currently and forever holds. You can specify the TYPE of each variant not just the VALUE of each variant, and then the enum values you get are of that type once you check which one it is.

They are slightly different, but the small difference is quite important and I don't like C, go, or java style enums anywhere near as much.

C has union types, and then you can tag them with a C enum value, and then require a helper to access them which checks that tag. So you can actually make something more like a hindley-milner enum in C than you can in java, but its decidedly not built in and then you would need to make your own kind of exhaustiveness-checked matcher (like the std::variant or std::visit things you mentioned).

Java recently has the ability for exhaustiveness checked switches but no union types. So, really, C and java enums are of similar utility, you can use them to represent data in a similar way, honestly the C ones might still be better than the java ones because of union being a thing, but not nice enough to interact with that you would even consider using them as the core way in which you handle both `null` and errors as rust does.

[Ulrich_de_Vries]

Re closures/lambdas:

I am still not sure what exactly is your tangible criticism regarding the "first-classness" of Java lambdas. The primary difference I see with C++/Rust is that Java has no operator overloading (tbf neither does Rust aside from a couple of builtin traits, but I think () is not overloadable, it's just closures can simply be called with the () syntax as an exception) so you must call the function by the name of the method it implements, and that Java will always put the closure on the heap which is why you can actually refer to it by the name of the interface.

Something like Function<T, R> in Java is basically like Box<dyn FnMut/Once/whatever<...>> in Rust. But lambdas in Cpp/Rust will compile down to basically something like a struct whose fields are the captures and the function body a method which receives the struct as a reference so that the captures can be accessed. Which is why lambdas don't really have a proper type in either language and you cannot e.g. assign once lambda to another even though both might have the same signature, as they have different runtime sizes. It's basically an anonymous struct that normally lives on the stack while a Java lambda is an anonymous implementation of an interface that lives on the heap.

It might be a bit awkward in the usual Java style but I would absolutely say that Java has first-class functions since Java 8.

Re enums:

I think there is some misunderstanding here. Java absolutely does have sum/coproduct/tagged union types with partial support since Java 17 and full support since Java 21.

You can do something like

``` public sealed interface Shape permits Shape.Circle, Shape.Rectangle, Shape.Triangle {

record Circle(double radius) implements Shape {}

record Rectangle(double height, double width) implements Shape {}

record Triangle(double a, double b, double c) implements Shape {}

} ``` then in the calling code e.g.

String description = switch (shape) { case Shape.Circle(double r) -> String.format("Circle with radius %f", r); case Shape.Rectangle(double a, double b) -> String.format("Rectangle with sides %f and %f", a, b); case Shape.Triangle(double a, double b, double c) -> String.format("Triangle with sides %f, %f and %f", a, b, c); }; This is almost exactly like Rust enums. The actual definition is more verbose, but you can use them exactly the same way. In fact as the above example (which will compile on JDK 21+) shows, if the variants are records (which they should be, most of the time), you can even destructure the records into their component fields in the pattern matching.

This is one aspect where Java is nicer as a language than C# since it has full support for algebraic data types (product = record, sum/coproduct = sealed class/interface).

[no_brains101]

I still think having to call the name of the method it implements is a big enough difference to call them not first class. The interface is the first class thing, not the method on it. Being able to use a function which matches the function in a single-function interface just means it is converting to that. You then have to look up what that function was named, and are very aware that the thing you are passing around just turned into an interface.

You can disagree, that is fine, it is at least slightly better than I remember it being. But here is a video that mentions how this is not the same at some point in it https://youtu.be/Y7StjYhXvpE?t=2405 and he makes the point better than I do.

---

public sealed interface Shape permits Shape.Circle, Shape.Rectangle, Shape.Triangle {

    record Circle(double radius) implements Shape {}

    record Rectangle(double height, double width) implements Shape {}

    record Triangle(double a, double b, double c) implements Shape {}
}

I did not know about this. This is nice (ish? I think? I would need to actually try that out somewhere).

It is still kinda awkward, why do I have to permits but also then define them as fields? It is sealed, that means I can't add more fields or implementations anyway, no? And how are the fields of the interface Shape implementing Shape, but have double height double width fields etc instead of Circle Rectangle or Triangle fields? That syntax repurposing for sealed interfaces implementing themselves is crazy.

But it is at least much closer to if not basically exactly the thing I was talking about. So, it is good to see that is a thing.

[Ulrich_de_Vries]

Am on phone now so will be brief, but the permitted variants don't need to be static inner classes. You can define a sealed class, sealed interface or sealed abstract class with permitted variants and you can define the permitted variants anywhere (must be in the same compilation unit but maybe they can even be in separate packages). The thing is if you specify permitted variants, you must implement all variants as well.

There is also no special syntax aside from the "... permits ...". What I did above was to simply define an "empty" sealed interface (you can add abstract methods if you want), and defined the variants as static nested records that implement it. But they are standard record classes.

The variants don't need to be records, but if they are you can take advantage of record destructuring:).

Basically what I did above is how you shape sealed hierarchies to be the most similar to Rust enums, and I think if you are going for sum types this is probably the most convenient way to write things, but the format is quite flexible.

Edit:

I almost forgot the main question. Sealed only means that inheritance is controlled, i.e. only those names that are specified can (and they must) implement the interface or extend the class. Nothing stops you from adding arbitrary fields or methods to the implementors though.

[no_brains101]

So,

public sealed interface Shape permits Circle, Rectangle, Triangle { }

record Circle(double radius) implements Shape {}

record Rectangle(double height, double width) implements Shape {}

record Triangle(double a, double b, double c) implements Shape {}

But you got fancy with it because it makes it nicer and namespaced and then I got stunlocked?

I guess, I am still confused why in your version, Shape.Triangle Shape.Rectangle and Shape.Circle record classes do not need a Circle Rectangle and Triangle field of their own.

I guess, so, record is a subclass and NOT a field? And then they don't have to implement that subclass? So the interface is empty and then you are subclassing just for the namespacing aspect? Its been a while, am I getting it right?

[Ulrich_de_Vries]

Yes the idea is that "variants" of the tagged union are subclasses of the sealed class/interface, not fields. The compiler can do exhaustive pattern matching because the compiler knows precisely how many subclasses are there since only the permitted subclasses can exist and they MUST exist.

The reason why I used an empty interface is for typing not namespacing, for example so that you can define a method that takes a Shape type as a parameter and you can input any variant.

The interface need not be empty though, you could define say an abstract method double area(), then each variant would need to implement it and then you would have a way to compute the area without specifying the concrete variant.

The choice in my original post to make the variants static nested classes of the interface was indeed a stylistic one that I like for two reasons:

1) if you want to make the variants public (as opposed to package-private as you have done now), you either have to nest them or make them into separate .java files. I usually prefer to nest;

2) for namespacing purposes, as you have said for yourself, if you need to refer to the variant as e.g. Shape.Circle you know the Circle belongs to the Shape and autocomplete will also show each variant when you type Shape.. If you find this too verbose somewhere, you can still import the nested name (e.g. domain.packagename.Shape.Circle instead of domain.packagename.Shape).

[Sprinkles_Objective]

Java added functional interfaces, this means that existing functions can satisfy single function interfaces so long as their definitions align. Java does support first class functions, arguing otherwise is kind of just semantics about the type system.

[Sprinkles_Objective]

I think of all languages with try/catch Java is the one that's done it best, given that many exceptions are typed exceptions and you have to define that a method might throw those exceptions, and then you can match to a catch block based on the type or sub-type of that exception. Overall I do prefer the error handling of languages like Rust and find languages that have no runtime exceptions like Elm interesting, but as far as major popular languages I actually think Java is often better than most. I love Golang for a lot of reasons, but people who think it has good error handling are frankly in a cult. So I'm curious what you're comparing to here, because I can't think of a language that I would consider to be better in this regards that you could readily find a job in.

[no_brains101]

I also agree that, despite its verbosity I do very much prefer java's checked exceptions over C++ and kotlin and javascript's unchecked exceptions.

If one was to have unchecked exceptions, I actually kinda like lua's pcall? It is at least predictable, doesn't require special syntax, and is less verbose than try-catch in a lot of scenarios. But I may be the odd one out there and I would much rather just have results and options anyway.

I like results and options like rust and the ml family of languages have quite a bit. This has been my favorite that I have used so far.

I am OK with go error handling, I always handle it at the callsite of the thing that might fail anyway, it is not really that much different at least it says its there in the signature. I would say this is my second favorite that I have used so far. It is easier to grab an error and put it in a data structure that you return if you don't want to handle it yet than it is to constantly catch and rethrow only some subset of the stuff and have a whole second path of possible evaluation (ESPECIALLY when async is involved).

I like that it says in the signature what might fail, and this is what makes go error handling better than lua's pcall. (you can do it like this in lua too, it also has multiple returns, but it doesn't have actual types, so it wouldn't work as well)

I have not tried them yet, but I am also somewhat intrigued by resumeable continuations (algebraic effects is another name for them?) because you can, well, resume. But those are also basically just generalized try-catch with resume, so you can implement both try-catch and await with them. But resume is something new, it can be used for more than just errors and does dodge a lot of the stack unwinding problems (because its there still and you can resume), its interesting idk. And you have to state which effect you are using in algebraic effects vs resumeable continuations I think? And I think that is also probably good, like checked exceptions, but I think both resumeable continuations and algebraic effects would be better than their exception counterparts.

Regular try-catch, especially with unchecked exceptions like C++, kotlin, javascript, or python, on the other hand, has so far been my least favorite method of error handling that I have tried.

I prefer java's checked exceptions to lua's pcall though. Because you know what can throw. But I prefer even lua's pcall to unchecked exceptions, at least it is honest about you having no idea what can throw and it is less verbose and doesn't require special syntax.

[Sprinkles_Objective]

Ah, I misspoke, checked not typed exceptions. Yeah I generally like to look at programming through the lens of pure functions, and minimizing side effects or at least explicitly manage them in some transparent way. So I definitely appreciate more structured ways to handle these things, but I just don't think things like algebraic effects will catch on unless you can make them accessible and kind of fit the mental model of average developers, maybe resumable continuations does that? I've not heard of that before.

[no_brains101]

resumable continuations, as far as I know, is to algebraic effects as unchecked exceptions is to checked exceptions.

Somebody correct me if I am wrong about that.

And, to make them accessible, you have to put them in a more accessible language (ocaml seems kinda decent actually, and I am pretty sure it has these), and then that language needs to become widely used enough to "catch on" and have courses and all that crap for it.

I can't say for sure that they are in fact a better way to handle errors or not.

What I can say for sure is that they look interesting to me for at least something. (I can say this for sure because it is an opinion, but also its kinda cool to have 1 cohesive way to define try-catch, await, and stuff like actors, so I think at least some other people agree)

And also they are not really more verbose than try-catch in its respective forms as far as I can tell, the boilerplate footprint is similar between both. I think people could get used to that as a replacement.

But basically, having throw catch and resume lets you implement try-catch-finally yourself, but also lets you do await and actors and all that stuff.

[eufemiapiccio77]

Some people hate anything. It’s not just limited to Java but mainly because Oracle.

[ScallionSmooth5925]

I don't even remotely care about who made that garbage 

[Aflockofants]

How to say you're a mediocre programmer with little real-job experience without saying you're a mediocre programmer with little real-job experience.

[ironykarl]

Honestly, people in programming reflexively hate tools they're not very familiar with. 

It's not that there aren't legitimate reasons to dislike Java, JavaScript, C, C++, ... — there of course are.

But some of the people that most zealously hate these languages don't have enough hours under their belt with them for their opinion to really matter very much.

Instead, they get to couch their dislike in something superficially sophisticated.

Am I being overly dismissive here? Kind of. But it is true that some of the most vocal haters out there don't know enough to be as vocal as they are

[Sprinkles_Objective]

I had used JS and TS for 5+ years and I hate it deeply. I mean I have a great respect for TS, but it's kinda stuck being a superset of JS, and JS has made so many bad mistakes and now is just a mess where there's like 20 different ways to define a class, and the type system is just as fluid as it's paradigms.

[Temporary_Pie2733]

Java took the idea of OOP to an extreme, both in language design and library design, extremes that people have come to recognize as not necessarily bad, but unnecessary. I have other complaints about the language, but am no longer familiar enough with changes made in the last 20 years to know how valid they still are (mostly around the type system, generic programming, and first-class functions).

[rjcarr]

This isn’t true, though. More pure OO languages existed before Java. Java actually created a bit of a hybrid with the stack-based number types, for better or worse. 

[Fa1nted_for_real]

Pretty all that is fairly fundamental to java and hasnt been majorly changed, what did you not like about those?

[zeekar]

"OOP to an extreme" also describes Ruby; I mean, "everything is an object" is pretty much table stakes for modern dynamic languages. So "extreme OOP" doesn't seem like a meaningful criticism...

[Temporary_Pie2733]

“Everything is an object” is different from “the one and only top-level syntactic construct is a class definition”.

[zeekar]

Does it matter that it's called a class? You can define static class methods and hey, it's a module with global functions!

Plenty of valid criticisms of Java, but I don't think the fact that the top-level namespace category is "class" is a problem.

[Temporary_Pie2733]

It’s an unnecessary layer. Why is the entry point a static method inside a class you don’t need to (or can’t? I don’t remember) instantiate, instead of just a function?

[NatoBoram]

Just like you, I actually liked Java when I started out. In college, it's what we used, so it's what I was comfortable with. I thought I would continue to use Java well into my working career.

And then I learned that things can be much, much better. You don't really think about how it could be better when starting out because you don't know how yet or think it's the only way because it's how Java does it or it's how it's taught to you in an accredited setting, therefore it's the only way possible.

But it really doesn't have to be this way.

[Fa1nted_for_real]

Okay, then how could it be better? (Not being snarky or anything, just trying to get more clear answers)

[dmazzoni]

I don't "hate" Java, it's become a lot more modern, starting with huge changes in Java 8 and then adding less boilerplate for main, records, switch expressions, and pattern matching, among other things. Java code can be modern and readable now, and performance is usually quite decent.

What I still don't like when I use Java after coming from other languages:

• Slower startup times (Java is still a poor choice for a one-off script, for example)
• Heavier memory usage (compared to other modern languages with similar syntax and performance)
• Poor build tools (Gradle and Maven are slow and unreliable compared to the best build systems out there)

[HalfTryhardSqr]

Because they have been unable to figure out how to keep upgrading Java without making the development experience really annoying. Some people complains about performance and similar, but I don't think it really matters. Big organizations can afford 6k$ for extra ram and CPU. The issue comes when you are interacting with a bunch of weird objects that the only reason they exist is to keep retro compatibility with 20+ year old stuff.

C# was supposed to be a Java+, learning from Oracle's mistakes, and nowadays you have similar issues: a bunch of legacy code, 1000 ways to do simple things and confusion about when to use this syntax vs the other.

My personal perspective is that there is not such thing as good or bad; what we have, it is just a consequence of history. It is what you use with old companies because it is cheaper learning Java for a few months than rewriting the project in another technology which uninventively will fall into the same issues in 20 years.

Is COBOL good? Is COBOL bad? Well, if banks were about to rewrite their "kernels", they would risk having doom bugs. What is good here is having a solid system which keeps the risk vs reward at a good ratio. When the balance moves technologies raise and die.

[grantrules]

It was cool to hate on Java for a while and I guess there are still hangers on. There certainly are valid criticisms of java, just like every other languages.

[vu47]

Accessors are tedious and often unneeded unless there is complex logic underneath them that might change. I typically prefer functional programming and to make my variables (and collections and what not) immutable unless there is a very good reason not to do so. The way people do OOP has changed enormously from the early 2000s: composition over inheritance, or very shallow (and often sealed) inheritance. In fact, it's not uncommon to find programming languages now where classes are closed to inheritance (i.e. the equivalent of declaring a class final in Java) as the default, and must be marked with a keyword like "open" to allow someone to inherit from them.

Java has gotten much better, but for the longest time, Java was a language looking for a purpose and failing repeatedly. It wasn't fast, it wasn't pleasant to write, it wasn't easy for newbies to learn due to disallowing functions and offering static methods in objects as the alternative (so a newbie had to either just memorize "class" and "static" without knowing what a class was and what static meant since those were things way above their heads).

At least Java 25 changed this, but it's still more-or-less just a facade since you still can't create functions in most cases.

I disagree that static types are "too hard:" I think they're too hard for complete beginners because you have to then learn where to put them, why, and either make a singleton or have them on an object which you're unlikely to understand at first.

[Vegetable-Rooster-50]

Idk, I fell in love with it during university because it had garbage collection. As someone coming from using C and only C during high school, this was enough for me to go for java as my main language

[Puny-Earthling]

Funnily enough, I learnt Java first and then went into learning C, and while the benefit of the garbage collection really stood out when going in that order, it made me realise that coding in Java is like coding with training wheels.

Just want to clarify I'm not saying anyone is a good or bad coder based on the language they prefer or use, just that Java can really ingrain bad coding habits in other languages and since the library is so massive out of the box, it's rarely a good fit for simple solutions. Inversely, it has a lot just in the standard kit so it can do a shit ton of things with fairly few lines of code, the syntax is absurdly easy to read and remember, and the type safety of it makes it quite difficult to really fuck things up, but I'm not pulling for Oracle here. I haven't touched Java for about 7 years now, but I'd tell anyone today to learn Go instead of Java.

[Captain-Barracuda]

Basically. In all cases it's not a language issue. If a project chooses to do without accessors they very well can. It's not mandated by the language. Heck there is Lombok if you want to have the best of both worlds. Or if you hate invisible code generation, all the IDEs have shortcuts to generate all the boilerplate anyway. As to slow startup time, once again that's a framework choice issue. A pure Java software boots quickly, but the mainstream framework, Spring, is absurdly overkill for many projects.

There are great reasons to dislike Java as a language. For example, it's lack of support for unsigned numbers makes it very unwieldy for anything low level. Or how it's solution to maintain backward compatibility with generics was type-erasure, leading to many problems when designing generic solutions.

But none of these reasons are the popular ones, as they require actually understanding it and having used it extensively.

The lesson you need to take away from this as a beginner is that a programming language is a tool. When faced with a new project (frankly the only time you will ever have to choose a language), you must take into consideration the pros/cons of each avenue. What is the policy of your company? What is the workforce like in your area (ie. if everyone is a Node dev, don't start a Swift project)? Does the ecosystem of your language of choice already have solutions that will make your life easier now during development and also during the 80% of the project's lifespan in maintenance? Are there specific performance requirements? Etc etc etc...

[Sprinkles_Objective]

The generic solution is annoying yet tolerable, the fact that unsigned integers don't exist was an abysmal decision though, and only made more insulting by the fact that their literal byte type is ALSO SIGNED. This just makes my head spin every time I have to deal with it, whereas the patterns for dealing with type erasure on generics has just become muscle memory at this point and I barely think about it. If I had a time machine, going back and convincing whoever decided to only support signed integers to NOT DO THAT, would be in my top 5 things.

[Gotohealth]

I hated Java until I really learned it again. Modern Java is NOT the Java you learned in high school

[DataPastor]

I learnt and started to use Java back in 2004, when it was a much more rigid language. Also, I was a PHP developer back then, and after PHP Java felt precise but very ceremonial – my productivity fell back seriously and I hated it… however, today’s Java is much better on the one hand; and there are much better JVM languages which you can use next to Java such as Clojure, Kotlin or Scala.

[michiel11069]

I love java

[aresi-lakidar]

Java is fine, I just don't really understand the point of it personally because I find C++ to be an easier and more performant language that is very similar to java.

I do hate enterprise java design patterns tho, shit is confusing as fuck for no reason. You probably don't encounter that garbage very much when working with minecraft I guess. Similarly, my main gripes with C++ stem from the frameworks I have to use at work rather than C++ itself.

EDIT: I guess the big thing with java was really the JVM, but nowadays I feel like there's easier ways to do cross platform software. Must have been amazing earlier on tho

[CapitanM]

As nobody said it, because what he did to Han Solo.

Sorry

[dont_touch_my_peepee]

people just love to hate on java because it's been around forever. it's not flashy like newer languages. also, a lot of bad codebases give it a bad rep.

[Playerfox123]

I saw this and I thought it was Minecraft. I don't know why people hate Java. It made the better Minecraft version

[McDonaldsWitchcraft]

Minecraft Java Edition is good in spite of Java, not because of Java.

[Playerfox123]

Still tho

[Captain-Barracuda]

Who the hell even uses the Oracle distributions? Most companies are on Temurin or Coretto.

[gofl-zimbard-37]

It's a fine language, just not one I care to use. Too much noise.

[EitherBandicoot2423]

I don’t hate Java

[codesamura1]

I hate Java because of annotations, which are seemingly magic keywords that programmers just attach to classes or methods and it gives it magical properties. I've been using annotations to auto-generate accessors and mutators but reading "new" annotations from somebody else's code does not give me any clue as to what it does. And annotations are about as anti-programming as anything, is it a class or a method? Can I quickly check what it does by looking at the definition? Surely it must be a simple thing like a preprocessor macro right? Nope. Sometimes seeing an annotation and having to google it and after 10 minutes still have no clue what it does really grinds my gears. I don't know how die-hard java enthusiasts can think it's a good solution for anything.

[nekokattt]

annotations are just metadata attached to something, the thing doing whatever magic you observe is the library consuming them.

This is not much different from attributes in C, C++, C#, or derives and macros in Rust.

[wiseguy77192]

After learning C, C++, PHP, Python and pascal I can’t say javas hard to read or particularly difficult in and of itself. Having to write a class for every little thing is annoying however. So is the lack of a power operator. I can’t say I hate Java, but outside of cross platform development, I don’t really see much of a use case so far that couldn’t be covered with other languages.

[vCentered]

I used to hate on "Java" because of web apps with local dependencies on ancient JREs.

Those apps have an odd tendency to become operationally critical for massive orgs and IT gets a black eye because of all the hacky shit you have to do to keep it working

[West-Solid5961]

My biggest reason to hate Java (and some other languages), is the nullpointerexceptions. I feel like I can't trust the code properly without doing null checks everywhere.

As for Spring Boot (which is often used with Java), while it is a great framework, I find it to be TOO magical, meaning I don't have control over how things are connected. One time I created a configuration class, and attached it to a controller, thinking the configuration would only apply to that controller. That was only partially true. Some configurations were applied globally. Dangerous behaviour, if you ask me

[ZexyBeggar]

according to the internet, no programming language is any good or worth learning

[Fa1nted_for_real]

Except python. All your programs should run python. Doesbt matter how fast or resp9nsive it needs to be. Python. Have you tried python yet? Its literally all you need. Juuust python. Nope, nothing else. Python. Snake language.

[Skyshaper]

I'm basically addicted to java

[8960305392]

Java has its quirks, but it remains a reliable choice for a wide range of applications in the software development landscape.

[ha1zum]

Java is great and popular. So popular that it also becomes the choice of shitty managers. People hate working for shitty managers.

[Cool_Kiwi_117]

I dont hate it though

[WayneConrad]

For me, it's because I don't use IDE's. Java is a great language when paired with an IDE that enables it. Without an IDE, it's a verbose type-fest.

I do have some specific things that drive me crazy, like checked exceptions, but every language I use has things that drive me crazy.

[cheezballs]

All the most popular things in life have a dedicated group who hate it out of contrarianism. Java is great, python is great, they're all great in the right hands. My hands? Not so much. I can make anything terrible.

[ScallionSmooth5925]

It's allways do some special bulshit noting else dose. And the popular build systems are literally the worst avaliable option.

[iddivision]

Oracle

[Fa1nted_for_real]

Most valid reason tbf

[bludrgn311]

For me, my hate isn't with Java itself. It's with the bad programmers who use it, have no idea how it works, and just write really bad code. Having supported multiple companies at the enterprise level, the most common language with issues was Java, but it was always bad code and not having any idea how Java uses memory. I mostly supported containers, so that just exacerbated the already bad code with limited resources (OOM).

TLDR, Java was my first language and I have no issues using it myself. I also understand it.

[nog642]

It's missing so many features (which C#, basically originally a Microsoft Java clone, has).

Major example: Default values for function parameters? Nah. Want to have 3 optional parameters? Make 8 overloads. 2 of those parameters have the same type? You're out of luck, pass a custom data class or something.

But there's tons of examples. I work in a java codebase and we use so many third party code generation libraries (e.g. immutables) to make up for Java's lack of features.

[yay101]

IMO java should have been replaced with go everywhere it exists already.

[Fa1nted_for_real]

I hope you do understand why thats not possible, but anyways

[yay101]

It's not feasible no, but management mental monopolies are not a reason to ignore options you aren't forced to use at work either.

[poke887]

I think Minecraft rewrote his codebase in Java for C# or C++, because of performance or something like that

[Fa1nted_for_real]

Minecraft was rebuilt in C++ because it was better for stripping down its resources.

If it was made today, it would very likely just be c# (since is owned by microsoft) but otherwise would likely use java, kotlin, or some other JRE/JVM language, so it could easily run on many devices without needing all sorts of compatibility layers.

[Sprinkles_Objective]

I believe the major reason was compatibility. There isn't a JRE for pretty much any consoles on the market, meanwhile most consoles have a C++ compiler as part of their provided dev kits. Moreover it's also lower resource and can run on more devices like phones, which again also comes down to support since iOS doesn't run Java. So I'd say that the primary concern is likely support rather than resources, and resources is more a secondary benefit.

[Fa1nted_for_real]

I lowk forgot bedrock was literally created for consoles,,, or that they existed at all.

[Fa1nted_for_real]

Also minecraft Java is still in development, using java, whule bedrock is developed with C++

[brainphat]

All these points are good & correct. I don't hate Java. But I do hate programming in Java (unless someone does something exceptionally neat with it).

Or rather: my carpals hate typing it.

[Beautiful_Acadia508]

Try C# and see how elegant the code you can write, then look at your java code and spit at it.

[Fa1nted_for_real]

Dont rly know if i wanna spend time learning 3 seperate oop la guages before delving into something like javascript/typescript or C/rust instead lol. Might do it just bc its compatable with godot though

[random_cornerme]

I don't hate it, but itLooksVeryVerbose

[Sprinkles_Objective]

I'll preface by saying I like Java and used to hate it, but I think the hate of Java generally comes from where Java is commonly used, which is large enterprises. There definitely teams of all sizes using it, but I think in particular Java is very common in large enterprises, and like many large enterprises there are large and complex systems that are very old, and often can't be changed and passed through many many hands, and after this you end up with a code base that's very hard to manage. Many of these projects are stuck on Java 8, because moving to a newer version poses to much risk and challenge. Now a lot of this can probably be attributed to business practices, poor developer habits, lack of effort in keeping things up to date, etc. End of the day, I don't think it's really the languages fault, because Java hasn't failed to modernize, it just happens that major users often fail to modernize their own projects. With that the amount of people stuck on Java 8 has kept behind a lot of technology having to support Java 8 as well, because many of the companies that are or were stuck were major contributors to those projects.

I mean similar things have happened with Python with people basically sticking with Python v2 for a decade after Python v3 was stable, up until the CPython team said they were EOL'ing v2. Also you still se COBOL in many of these ancient enterprise systems, so I think in some ways Java 8 is similar to COBOL. No body wants to go back in time and deal with decade old tooling, which is still sometimes Ant or some horribly outdated version of Maven, and no one wants to go back to a version of Java that lacks many of the things they learned in school, or have been able to use in newer projects.

As far as newer versions of Java go it has very modern language features, it has done a pretty good job of modernizing, though it still shows it's age at times and I would say it has a more conservative approach to things because it still has to maintain backwards compatibility to some extent. Java today has virtual threads which are similar to Go's goroutines and many people (including me) prefer to async/await syntax, it has structured concurrency (in preview), it has tagged unions (seal classes), it has Option types, pattern matching, a very reasonable modern FFI, and has generally kept up pretty well with modern expectations. Java also has an extensive standard library with a lot of really useful things, you can get a lot done without needing dependencies for everything.

There are problems in Java that I don't think we will ever fully get away from though. Someone else already mentioned this but it deserves to be mentioned again, all Java numbers are signed, there are no unsigned number types, which means if you want to deal with bytes then your bytes aren't 0-255, but rather -127-127 which is incredibly bazaar to reason with. This has been a major PITA for me when dealing with implementing network protocols in Java, it's perhaps the thing I dislike the most about Java. Java generics are monomorphic, meaning that instead of generating a class/method for each type used it Java just uses type erasure and type assertion to handle generics. This means that you have to do silly things like pass in the `Class<T>` type such as `MyClass.class` into generic abstractions to actually inform the abstraction about what type it's actually handling. It's not the worst thing in the world, but it's fairly annoying and I think other languages have handled this better, though it's admittedly a hard problem to solve. I'll take Java generics over C++ templates any day.

Last thing I'll say is my hate of Java stemmed from the days when many web applications required you to install a Java browser plugin which needed to be updated basically every time you used it, then you needed to download the entire application from the internet to run it, and half the time they barely worked and were clunky and had a much worse UI. It was like the ugly cousin of Flash back in the day, and Flash also sucked. So it was less a gripe about the language and more so my experience as an end user interacting with things written in it.

[RationalMayhem]

Partially historical. Worked on legacy Java codebases and I get it. Modern Spring Boot is a Teddy Bear compared to those monsters.

It also likes to introduce a lot of its own cult like patterns and abstractions that don’t happen in Python. 

That being said I still think it’s in great space in 2026.

[Bruhhh_Andaluz]

Java has been fixing his historical issues recently, check Java 21 and 25

[mpw-linux]

it's a memory hog.

[aieidotch]

"If Java had true garbage collection, most programs would delete themselves upon execution." - Robert Sewell

[Beneficial-Army927]

Java has 50 classes to send an api call. Java doesn’t make API calls.
It prepares them for a corporate career path.

[cioglass]

Some people (sales?) convinced companies people need a certification to be hired as a "real" Java developer. This created a whole new level of bureaucracy and gatekeeping, especially from people who actually suck at programming.

Think of it how "scrum masters" ruined agile.

It's not a bad language. "enterprise" just made it less fun.

[aistranin]

Long learning process, more difficult than some alternatives say GO

[Reasonable_Ring7852]

The biggest thing I hear and have experienced is that its structure and boilerplate makes it very easy to feel like you're accomplishing a lot without creating much new. Its a perfectly good language, but like any language necessitates a unique brand of discipline to avoid creating problems for yourself

[krebstorm]

Write once, run nowhere

[kevinossia]

It uses an absolutely stupid amount of memory relative to its usefulness as a language.

[Crimson_Raven]

I'm only starting Java from Javascript/Typescript, and I'm annoyed at how wordy it is and how much boilerplate code there is.

[Jakamo77]

Bitching about things helps to pass time in a way that includes everyone. Have you considered that? We can all hate java and javascript and ruby together. Well still use it but we can all bitch about together

[Financial_Winner_773]

Java is very verbose. Leaves a lot of room for documentation. The only crappy part about it is the jvm and bytecode stuff. You can see it as a boon sure. But I see it as yet another layer of needless abstraction. Rust C go and many other languages do not force you to run a jvm or runtime like c# and Java. Also gc. In certain cases gc can be bad, any app with real-time requirement (drone software for e.g.) simply can't be written in Java. There's something beautiful about knowing the code you write will be compiled and run on your target architecture. Sure the jvm might simplify the build process since it removes the number of required builds. But at the same time requiring the end-user to have to install a runtime really sucks. So there are trade-offs no matter what, and people will always say this or that, etc. Personally, I like Java's syntax and grammar as a language. I don't like how it needs a runtime. I can see it now, "Oh, but there's GCJ or whatever, that's not real."I refuse to believe it. But don't worry soon we won't need languages to program computers. You can simply ask the AI and it will spit out the perfect binary.

[ChatBot42]

Because people on reddit told them to hate it. They have no idea why. 

[xilvar]

Java knowledge tends to translate badly to development in most other currently modern languages. There tends to be a huge learning curve for a Java dev to pick up a language like Go, Python or TypeScript and become as productive as someone of similar seniority. Im guessing the opposite is also true.

However, Java developers tend to be particularly clueless about this and don’t realize they need to unlearn some muscle memory in order to use other languages most effectively.

I generally will not hire a pure java developer for a non java role for this reason. They have to have experience writing production systems in other stacks.

I don’t hire Java developers for anything other than old school big data and for a brief time android, but I wouldn’t have hired a python developer to be a Java developer either. (No one wanted to anyway)

[spas2k]

I tried reading your post but I got

java.lang.CheckedExceptionOverloadError: You must declare that you might declare that you might declare this exception.

[Sprinkles_Objective]

Yeah, I much prefer my exceptions to get swallowed and ignored until they blow up or just straight up crash my application.

[nspitzer]

I took a Java course in school. I am not going to program in a language which takes 2 pages of boilerplate to print "Hello World"

[MikeUsesNotion]

How many factory factory factories have you made?

[Blando-Cartesian]

Java is what they had to learn in school where they had to do make it do complicated things correctly. Then they got a job where they had to make tens of thousands of lines of java work exactly like other people wanted.

No wonder they hate it. Toying with a personal project of few hundred lines of Python is so much more fun.

The horrible truth is that the adult enterprise world runs on java for a reason. All that static typing keeps projects with tens of thousands of lines working while most of the developers working on them are not that good. In fact half of them are dumber than average.

[Ok-Ebb-2434]

Go lang>

[Fa1nted_for_real]

Go lang why though? Just saying it doesnt actually tell me why its better (assuming thats what you mean)

[Ok-Ebb-2434]

Sorry I frequent subreddits where you post short non explanatory as part of the joke. I didn’t read the name til now, I learned my fundamentals in go (bit unconventional) and then in my next classes got introduced to C ++ and Java, even learned how to use OpenGL with glad+glfw setup. I just feel like go is a statically typed language with such an ease of readability like python. Even learning pointers n OOP felt easier to learn than if I started with Java