Greentext

I've worked on a corporate project with multiple Java services, anon isn't really exaggerating. Java can be a hell scape at times

I'm pretty sure Java doesn't have pointers, so writing a hello world application isn't gonna fuck up nearly that hard.

The one thing he forgot though is that your source file is probably in the folder

com/companyname/net/classes/factory/factoryfactory/worker/lib/bin/refresh/jdk/model/ui/closebutton/press.java

And spread out among a bunch of other directories, and the java file is like...3 lines. But there are 10k files spread all around directories like this that are all 3 lines a piece with a class definition.

• a hello world doesn't need libraries in Java
• installing JDK takes at most 5 steps, depending on the OS
• a nullpointerexception is more likely the developper's fault (unassigned value, calling a function on a null object)
• IntelliJ is easy to install and modern (granted, other IDEs are very ancient)
• developping GUI apps is a PITA, no matter the ecosystem (generally)

The rest is more or less spot on (no idea about concurrency issues though)

Java is religiously backwards compatible. Modern java projects are not as enterprisey and boilerplatey, but, as jdk21 is backwards compatible with jdk1.3, you can still happily write code as if it's 2003.

Additionally, the java space is huge, so just wildly googling will probably not help you that much.

95% exaggeration. Here is reality:

• yeah you need main class coz it’s OO-language. Though, not required anymore, which should’ve been done once Java got scrip language capabilities (jshell) back in JDK 9. But as of today not required anymore
• imports exist in most if not all languages. Gotta be insane writing them manually in 2010 let alone 2024
• installing Java runtime (JRE) is as simple as installing any app. Though for installing JDK you need 5 mins for setting PATH. Think about JDK as like TSC or Webpack and JRE as a Browser. I’d argue installing and configuring JDK is simpler than TSC or Webpack
• Unless you doing some non-trivial multi-threading your stack trace will tell you exactly where is your NPE. You gotta be as blind as my teammates to spend more than 1 minutes to find where it is coz it literally tells you file and line numer where Exception occurred
• I mean, yeah if you use IDE from 2000 it will look like it. IntelliJ looks modern, though I don’t like the fact latest versions look like VSCode
• I hardly reach 3G of deps from all 10 projects I have on my workstation.
• IDK what anon means by ecosystem here, Java ecosystem is quite standard across the board. JDK(std lib), Maven/Gradle(deps, build, publishing), Spring Framework (all sorts of blueprints and solutions to standard app level problems), Hibernate/JPA (ORM), JUnit+Mockito (testing). These are tools and libs used in 90% of projects I worked on. Of course there will be more depending on project needs. Layers? It’s not like language imposes any layers whatsoever. It’s just common practice to have 3-4 layers and some glue in-between.
• don’t do GUI in Java it sucks and will suck until Java gets string interpolation. Hopefully soon
• concurrency is actually the only thing which is really bloated in Java. Which will change with next LTS version if I remember correctly. And it’s not that hard if you actually read the f manual and not just “try and hope”. Again it will become much more efficient and easier to follow soon. As of now - yeah, not trivial. But people mostly prematurely optimize, so karma
• Java is kinda have 20 ways to do same thing but actually no. Java built with idea of providing simple building blocks. Then it provides more specific API built on top of those building blocks. It allows to have API which solves typical problems and provides capability to solve custom problems with those building blocks. People often confuse this as many ways to do one thing but it’s like saying “I can have byte array why I need string data type”. Those are different levels of abstraction

Edit: typos

I've been programming in Java professionally for 11 years. It's not just embellishment, it's outright lying.

Threads giving you race conditions? All concurrent programming will do that if you're shit at it.

Java has come a long way. I will admit that UI in Java is terrible. I would never do that.

Only have a beginner perspective, but in school I did really well in intro CS class that used Python. 2nd class was in Java and it almost broke me I was so confused.

It's much better today, but in 2010 that was 100% accurate.

That being said, using Java as a first time programming language is like a 15 year old trying to fly an airliner to get a few blocks away to pick up some after school snacks. Obviously it's way overkill. Sure you could get across town with it, but it's probably 1000x more complicated than just a simple bicycle or even walking.

Java is industrial strength for professionals. There's absolutely no consideration made for educational usage.

Anon pretty much sums up my experience with Java when I had to learn it in college 20-ish years ago. I'll never get rid of my distaste for the language I'm afraid.

I have developed in java and C/C++ (many years) and Anon is maybe exaggerating a bit but not lying, we all have been there more or less.

Personally I hate how java forces you into bad architectural choices. Where is the unsigned int? Why isn't an int a class BTW? Why the pass by copy for some, by reference for others? Where is multi inheritance? Lots of things are dumbed down or you have no choice in the matter.

Sure didn't help it was a power hungry beast moving at snail speed back in the day too.

It certainly can be that bad.

https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition

Anon is absolutely exaggerating for comic effect. That doesn't mean Java doesn't have all of those problems though, it just isn't as ridiculous as they made it out unless you get dragged into enterprise bullshit (then you're in for it).

For the “simple” apps anon is talking about, they are exaggerating a lot. Though, when you get beyond the obligatory “Hello World” and “a window with a button”, the complexity does start to increase exponentially.

Throwing in frameworks like Spring or JavaFX does make things more complicated. But it’s still relatively manageable once you get used to it and know what goes where and when.

Now the whole configuration thing, that’s an art form best left to those hooded “seniors”. It’s good to learn eventually, but not when you first start out; lest you have a fetish for pain.

Java has come a long way. It’s not the languages fault that people create monstrosities like AbstractJavaFinalSerializedFactory or whatever. But if you do want to be “good” at Java, you will want to learn about design patterns. It also doesn’t hurt to have a thick skin too, because you’ll be both criticized and made fun of for your choices. 😊

Concurrency isn't bad, and package management (while maven is absolutely terrible to work generally), the dependency chains aren't exceptionally bad. Getting it installed is easier than python on platforms it's not already there on, not because it's more portable, but because the installers do more for you. Portability is hard, they haven't done it well but they've paved the default use case pretty well (although that works against you when you get to harder cases)

But the rest is pretty close.

The worst is the scaffolding, it's literally superstition for years to gain the understanding as to why you're doing it. I took two years of Java in high school before getting a degree - it was 4 years and halfway through a degree before I understood why I was making a class with a method main(string[] args). It works like that because your entry class calls the main method with a list of string arguments... I didn't understand at all, because even though it's simple it's a special case, and I'd never seen anyone name the string array anything different, so I just copied and pasted it, never understanding it because I'd been told "you just have to have that" for do long

Builds are arcane too - there's still companies that only use netbeans in their build pipeline, Android still requires a specific an old Java version in conjunction with the IDE or a gradle build, at best a project uses maven (the package manager), which is xml based and full of arcane details that are best treated as a magic incantation to be copied exactly from elsewhere

Not much at all. It’s truly awful

If you've never used Eclipse, which I assume it was referencing, it does feel old, clunky, and ugly out-of-the-box (to me at least). I tried to use IntelliJ wherever possible, but a previous company had a project that really didn't like to run from it but would with a very specific setup in Eclipse (I don't recall any details now more than 10 years later).

There is a fair bit of boilerplate and bloat.

I don't remember UI stuff being so bad, but most of what I worked with was old Swing/AWT stuff. I did have to use JavaFX (I think it was?) once and remember something about it being frustrating, but it was for some existing thing I had to modify.

I don't mind Java so much, but it's certainly not my favorite language.

I don't know how one gets a nullPointer when doing a hello world, though. I'm guessing this is embellishment or mashing together something later with their initial printing of hello since I think you'd come up with some other error in that process to getting something to print before nullPointer.