Anon tries programming in Java

I also think Java is shit, but if you manage to get a NullPointerException while writing a hello world program, maybe anon is just not cut out for computers?

I always loved that Java has a NullPointerException but doesn't have the concept of pointers in the language (only references).
- That is because they planed to add pointers and then gave up.
- C# has NullReferenceException and it actually makes sense.

Java

Thats your first mistake bucko

Am I weird for liking Java? I feel like it just makes so much more sense than other languages.

C# is nearly the same, but much, much better.
It doesn't (usually) come with the Java culture 8 layers of abstraction. This isn't in the Java language. This isn't in OO. Yet nearly every Java programmer makes things way more complicated than it needs to be.
It's a prettier language. Similar syntax with less bullshit.
It's open source
It's still multiplatform. Modern dotnet / C# works on anything.
Both Visual Studio and Visual Studio code are great IDEs that blow Eclipse out of the water
It's one of the most common business languages.
It's going to be supported forever.
If I could restrict the world of programming to two languages, it'd be C# and Rust. C# for most things and Rust for a lower level language.
- Nah, C# suffers from a lot of the same shit Java does. Needing everything to be a class is just no longer a good design choice (if it ever was). AOT support is still lacking. I don't get, why it does not have typdefs. I think the solution / project structure is unnecessary and I could probably think of more stuff I dislike about C#. But imho, it still beats Java.
  Golang is my choice over C# any time. I strongly prefer how interfaces are handled and I actually like the error handling.
- I'll take Python and Fortran, thank you very much
- I only had one job that used C#, and it was the worst job I ever had. Even with the worst possible way to be introduced to the language, I still love it.
- Isn't Visual Studio Code just a fancy editor and not an IDE?
I like how straight-forward the syntax is. And it also seems orderly to have everything be a class. There's a system to it.
I'm using C++ for a project now and I like it in a similar way, but there's more freedom (everything doesn't HAVE to be a class). So with C++ I'll never go back to Java (unless it's for a job).
No. Every language has its haters. There's a reason Java is so widely used. If you like it, keep at it.
- Yes and the reason is because millions of lines of production code were written and it isn't worth rewriting them.
  Plenty of languages around now that don't have 30 years of baggage and the specter of Oracle hanging over it.
  Now a days many businesses choose Go.
I thought I like Java until I tried Kotlin. It's everything I liked about Java, but with everything wrong with it fixed.
- I used to be very into Java and Kotlin looks nice. What's your favorite IDE?
I am a certified Java hater, but you're allowed to like it. If simple and objected oriented is what you want, I can see the attraction, and it has a good and mature ecosystem.
Honestly I would consider that a bit weird. At the very least, old-fashioned. If you like Java, it makes me think you haven't tried a better more modern language to compare it with.
- Which would you suggest? (And if you say python, I will attack you with a pointed stick)
- The first language I learned was Python and I hated it. I have not tried Rust yet but I have tried all the Cs.
  Edit: added missing not
No, Java has lots of merits. For example, once you know layout managers, you can have a resizable GUI app in no time. It's the exact opposite of arranging things pixel by pixel. You just define "I want a grid of these buttons south and a big text field in the center" and Java will do the rest. I whip up apps like this for the silliest things, like noting which dungeon has what rotating boss this week in a game, so it's more convinient than noting it in a text file.
- And GUI is even easier and faster with Compose.

I might have agreed a decade or two ago, when I knew no better. But today, I find the tribalism surrounding programming languages comical.

I don’t particularly like Java, but I use it because it pays the bills. Similarly, I use C++ (which I prefer) when my work requires it.

I don’t particularly like Java, but I use it because it pays the bills. Similarly, I use C++ (which I prefer) when my work requires it.
I mean, anon is not arguing against that. They're saying the language is shit regardless of how much it is used in business. I don't think they are entirely wrong.
Tell us more ancient one, your heroic tale of "giving up against the endless weight of capitalism" is fascinating.
- “giving up against the endless weight of capitalism”
  We just call it "having a job" nowadays
- Love the dramatics.
  This ancient one has learned the art of pragmatism. A little time in the trenches of enterprise development can do that – turn passionate ideals into practical choices.
  Some days it’s C++, some days it’s Java, Python and so on. In the end, the code compiles, and the ancient one get paid.

If it took anon 30 minutes to write hello world in java, programming is not for anon.

We bow to your wisdom, wise gatekeeper
- Thank you. If you bothered to read a 5 minutes tutorial instead of posting to 4chan, you could also reach this level of knowledge.
- It's like 5 lines of trivial code

My old boss is one of the 3 initial creators of Java. He ran our department the same way this greentext reads.

He was also a paedo. You can figure out the rest if you dig.

Known for : the Java programming language, internet sex crime and the fantasy defense.
Are you saying OP is...
- No.
- From PIE root "pau-" (few, little), to Latin-transliterated via Greek "paed" (boy, child), and spelled thusly to distinguish from "ped-" (foot), circa 1600AD. Reduced to "pedo" from "paedo" as part of the shift in Americanization of accents and spelling in the late 1700s early 1800s.
- Confidently incorrect.

C# masterrace and I'm tired of pretending it's not

C# is pretty good generally - I know it far better than any other and it pays my bills! - but it certainly has its weak points. Particularly around the newer features, a lot of them feel really rushed and just kind of shitty.
The one I hate the most is the whole “nullable” pattern. It’s a total mess. Having to mark up files as #nullable enable, having to mark methods with a bunch of attributes, and the way that it works differently if it’s a value type or a reference type, it’s just so half-baked.
If you spend some time with a more modern language like Rust or Swift then you’ll quickly start to notice C#’s weaknesses.
- I feel like you're doing something wrong with the nullables... I'm pretty sure you don't need to mark up files, you can just enable it on the whole project? I'm not sure about the attributes, you might have a point there, but it just makes sense for value vs reference types IMO, since value types are already implicitly different in terms of nullability.
  But yeah, I can imagine it's half-baked, since nullable reference types (that's the name, previously reference types were just nullable by default with no extra features) are a more recent addition to the language, one that wasn't built with them in mind.
After close to two decades of programming, C# is still the best language I've used. While some of the newer features seem a bit weird, I'd say it's one of the few languages that has never got in the way and has just let me write code that made sense. Even with all the improvements Java has made over the years it's still nowhere near as good as what C# was like maybe 15 years ago.
The same goes for everyone's other "fav" language, Python. Ruby has been a better beginner scripting language than Python for many years, and while Rails is definitely a ghetto, as a language Ruby is great at teaching great programming fundamentals.
C# is nicer Java, but I think it's still fundamentally a poor language.
Rust master race:

fn main() { println!("Hello world!"); }
Unfortunately, the time you save typing you'll spend compiling, so there's that...

My inner mathematician respects Java. The first step in any problem is defining your universe

You may find JML interesting. https://www.openjml.org/

Not using Eclipse helps. Using Scala helps even more

Really want to go to La Scala one day but I looked it up and the tickets are like 500 euros. An eclipse is much cheaper

Just imagine how it must have been to code Minecraft 🤣

They only had to deal with LWJGL. The corporate java world has to use Spring.
Edit: They also had to deal with all the fans saying they should've written it in C#.
- And much of the confusion and frustration at "Java" is actually because of Spring, or the "enterprise" nonsense making everything unnecessarily complex. You can just... write Java without any of that.
  You shouldn't though, because Kotlin exists, which fixes everything that's wrong with Java while still being 100% compatible, so even in legacy projects you can mix and match and write new code in Kotlin without needing to rewrite any of the existing Java.
- C# is just M$ java IMO. What a crap language too.

Hello World

30 minutes of boilerplate

writing imports

    
$ cat <<EOF > Hello.java
public class Hello {
  public static void main(String args[]) {
    System.out.println("Hello world!");
  }
}
EOF
$ java Hello.java
Hello world!

ok

Welcome to java, we have a couple unconventional ways of doing things, but overall I'm like every other mainstream oo language.
People: AHH! Scary!
Welcome to python. your knowledge of me wont help you elsewhere as my syntax is purposefully obtuse and unique. Forget about semicolons, one missed space and your code is as worthless as you after learning this language.
People: Hello based department
- Oh my god I got fucked by a python script once because of a single space. It took forever to figure out what went wrong
- **kwargs
  "No, I don't use type annotations because they don't actually do anything. In fact I purposefully give this parameter different types for different behaviors. How is that confusing?"
- Python has its drawbacks but it also has a pretty useful standard library so as a language for small scripts, one can do much worse
- It is possible to dislike both. For me SmallTalk-like languages are peak. Message passing for life!
Python:

print("Hello world!")
- C:
  c
  
  #include <stdio.h> int main() { printf("Hello World!"); return(0); }
  EDIT: POSIX-compatible shell:
  bash
  
  echo "Hello World!"
This is getting a little better nowadays.

> cat Hello.java void main() { System.out.println("Hello, World!"); } > java --enable-preview Hello.java Hello, World!
Things to notice:
No compilation step.
No class declaration.
Main method is not public static
No String[] args.
This still uses preview features though. However, like you demonstrated already, compilation is no longer a required step for simplistic programs like this.
- Microsoft Java is a one-liner these days.
  
  > cat program.cs Console.WriteLine("Hello, World!"); > dotnet run Hello, World!
- System.base.stuff.output.out.printfunctions.println
  Or so it felt every time you wanted to dump something into the console...
- Main method is not public static
  It must be somewhere under the hood. Otherwise, it wont be callable and it would require an instance of an object to call. Unless the object here is the Java environment?
  No String[] args
  They are just optional I'm sure, like C and C++. You still need them to read command line arguments.
  All in all, these syntax improvements are welcome. I already moved on to Kotlin for Android development though.
He types REALLY slow.
I got the impression they skipped the hello world cause it was too easy and they wanted to get right to writing their app, so they moved on to more advanced stuff without having a real grasp of the basics

object orientated programming is the wrong idiom for almost all problems, and even in the few cases where it makes sense, you have to be very careful or it'll hurt you

Idk. Maybe it's because I learned OOP first that it makes more sense to me; but OOP is a good way to break down complex problems and encapsulate them into easily understable modules. Languages like Java almost force everyone on the project to use similar paradigms and styles, so it's easier for everyone to understand the code base. Whenever I've worked on large non-OOP projects, it was a hard-to-maintain mess. I've never worked on projects such as the Linux kernel, and I'm hoping it's not an unmaintainable mess, so I'm pretty sure it's possible to not use OOP on large projects and still be maintainable. I am curious if they still use OOP concepts, even though they are not using strictly OOP.
I also like procedural python for quick small scripts. And although Rust isn't strictly OOP, it obviously borrows heavily from it. Haskell is neat, but I haven't used it enough to be proficient or develop good sense of application architecture.
I've done production work in C, but still used largely OOP concepts; and the code looks much different than code I've seen that was written before C++ was popular.
- The Linux kernel actually uses quite a bit of OOP ideas. You have modules that are supposed to have a clear interface with the rest of the world, and they (ab)use structs to basically work like objects. If you try hard enough, you can even do "inheritance" with them, like with their struct kobject. It is actually somewhat well-thought-out, imo. No need to go full OOP, just pick some of the good parts, and avoid the MappingModelFactoryServiceImpl hell or the madness that is C++.
I have been trying to be more functional but I still use classes for things like loading/modeling configs. What are some common situations where using an object is a good solution?
I use python if that helps at all.
- What are some common situations where using an object is a good solution?
  It depends on what you mean by "object"
  Some kind of structured data?
  Some named type which fulfills an interface?
  When you have some kind of structured data, having a class to represent it is fine. If you're able to give it type annotations, that's much better than passing around random dictionaries.
  When you need polymorphism and have an interface where some method on an object needs to exist (e.g. car.honk()), that's also fine as long as you avoid creating subclasses and using inheritance. If you need some car that can honk like a truck and drive like a racecar, use composition.
  What I would consider a good use of classes (more specifically, nominal types) is dependent types. The idea is that you use the type system to enforce invariants for data.
  For example, suppose you have a string for a user email. It might be a valid email string, or it might be garbage like "z#%@("=))??". You have a function for updating the user email in a database, and it requires the email string to be valid.
  One approach is to validate the email string after receiving it from the user. That works, but what if your coworker creates a new form and forgets to validate the email string there? Bad data gets passed downstream to functions that expect well-formed data.
  Another approach is to validate the email string at the top of every function that expects well-formed data. That also works, but now you're validating the same string multiple times and pasting validate_email(email) everywhere.
  With a dependent type, you have a ValidatedEmail type and a constructor for it. The constructor will return an instance of the ValidatedEmail if and only if the email string is valid. Any function that expects a valid email will only accept a ValidatedEmail, and not a string. If your coworker creates a new form and forgets to validate the email, the type system will complain about a string being passed instead of a ValidatedEmail. You also shift the responsibility of validating the email to wherever there is a boundary between validated and unvalidated data, avoiding unnecessary validation since you know a ValidatedEmail is already valid.
  It's an extremely useful paradigm for avoiding logic errors, but it's unfortunately not as common as it should be.
- Objects are great for game programming.
  Stuff like enemies, bullets, loot, items, etc. are constantly changing and affecting each other. This makes it difficult to program in fixed functions that run through and crosscheck a bunch of constantly changing arrays. It makes logical sense to have objects with their own functions stored in dynamic lists instead of arrays. A lot of the properties are used by several different objecs, like coordinates or health points, so it also makes sense to describe them in classes.
  So, I'd say that it's a useful way to classify data that is very dynamic, or when different functions need to run depending on that data.
  I don't like putting all code into classes, because a lot of code doesn't need that kind of flexibility.

Forgot the JVM eating the entire machine's RAM for breakfast

JVM is like a gas. It expands to fit it's container, however large that is.

I really enjoyed the text.

From the perspective of a python programmer it all seems valid.

A Java-Dev would probably write the same about an embedded engineer.

Sorry, you had a small error in the spacings of your post; Therefore I cannot parse a thing you're saying. Didn't mean to scare you with a semicolon either. It's just a tool in language's to end a clause and begin a related, independent clause. That could be useful somewhere...
As embedded dev, the stack trace alone scares me. It would be funny to watch the Java runtime blow the 8 frame deep stack on a PIC18 tho
Honestly, I prefer C to Java, it's incredibly simple without all the BS that Java throws at you:
interfaces - compiler will fail if you provide the wrong types; w/ Java, figuring out what types to pass is an effort unto itself
functions - everything needs to be in a class; even callback functions are wrapped in a class (behind the scenes if you use modern Java); in C, you just pass a function
performance - Java uses a stop the world GC, which can cause issues if you have enough data churn; in C, you decide when/if you want to allocate or free memory, no surprises
There are certainly some bad parts, but all in all, when I run into an issue in C, I know it's my fault, whereas in Java, there are a million reasons why my assumptions could be considered valid, and I have to dig around the docs to find that one sentence that tells me where I went wrong w/ the stuff I chose.
That said, I prefer Rust to both because:
get fancy stack traces like I do in Java (I really miss stack traces in C)
compiler catches most of my stupid mistakes, Java will just throw exceptions
still no stupid interface hell, I just satisfy a specific trait and we're good
generally pretty concise for what it is; I can rarely point to a piece of syntax and say it's unnecessary
I use:
Python - scripting and small projects
Rust - serious projects or things that need to be fast
Go - relatively simple IO-heavy projects that need to be pretty fast
C - embedded stuff where I don't want to mess w/ the Rust toolchain
Java has been absent from my toolbox for well over a decade, and I actively avoid it to this day because it causes me to break out in hives.
- For over a decade?
  In the last decade java finally is starting to catch up! The latest java releases have finally given us the ability to pass through a function, and work more functional.
  And you can choose any GC you want, even less "stop the world" ones, but who got the time to figure out which GC they actually want... The memory allocation from C is what haunts my dreams more than the GC from java.
  Still, I really want to give Rust a look, if only I gave myself enough time.

This is probably the best 100 second explanation of Java to exist.

I'm sure that's Fireship, without clicking the link.
- Nah it's not you should check it out
My experience with Java over the last 2 decades or so. Shame Android gave it extra life, thankfully Kotlin exists now.
- Yup, I swore off Android dev almost entirely because of Java, and then Kotlin came out and Android programming was tolerable again. Not fun, tolerable, lipstick can only make a pig so appealing...

You're not stuck with it Anon. You can use something different!

I started with java for school. The day I tried C for the first time I was flabbergasted, "what do you mean it doesn't matter which order I put things in?"

I still think Java is good for teaching newbies precisely because it will throw an error quickly if they are doing it wrong.

Rust over there like
Hey kid, tired of putting off your problems?
So will pretty much anything except JS.
- Arguably there’s Typescript now, too.

Must be several years old - otherwise, javafx deserves quite a bit more ire.

Could be worse, could be programming Javascript (or Typescript).

A text file with a script block and nothing else, containing a console log, is all you need. You already have all the boilerplate to run it in any computer. No extra dependencies, no installing anything. Literally just a notes editor app. This is a valid HTML file:
js

<script> console.log("Hello World") </script>
- By that logic we should all program with .bat files
- I think you forgot to pollyfill your console.log and now you have some error in some script in some callback
I love javascript. Shit. Just. Works.
Even if you, the programmer, are a complete fucking moron, by god javascript will try to make your program run as long as possible.
- Even if you, the programmer, are a complete fucking moron, by god javascript will try to make your program run as long as possible.
  I mean it might not work as intended but it'll run and not complain!
- Javascript is a beautiful language where '3' - 1 = 2 but '3' + 1 = '31'.
- Javascript doesn't "just work". It's a language originally designed to glue actions to html elements and it is fundamentally broken in ways that will be never be fixed. Weird syntax, weird type coercion, horrible base types & functions, surprises galore. Even Typescript, which is basically a precompiler, is just JS with some type checking. The only reason anyone uses either is because it is ubiquitous - people have to use it.

Just use c#

Aside from the general stupidity, Java is a heavily front-loaded language in my experience. I'm not going to engage in any tribalism about it or claim that it's better or worse than others. As a matter of personal taste, I have come to like it, but I had to learn a lot until I reached a level of proficiency where I started considering it usable.

Likewise, there is a level of preparation on the target machines: "Platform-independent" just means you don't have to compile the program itself for different platforms and architectures like you would with C and its kin, as long as the target machines have an appropriate runtime installed.

Libraries and library management is a whole thing in every general-purpose language I've dealt with so far. DSLs get away with including everything domain-specific, but non-specific languages can't possibly cover everything. Again, Java has a steep learning curve for things like Maven - I find it to be powerful for the things I've used it in, but it's a lot to wrap your head around.

It definitely isn't beginner-friendly and I still think my university was wrong to start right into it with the first programming classes. Part of it was the teacher (Technically excellent, didactically atrocious), but it also wasn't a great entry point into programming in general.

I'm not a Java dev, but I know enough of it to fix simple bugs in the backends I work with. My main issue with it is that 99% of the code doesn't seem to do anything. The clear, obvious place that looks like it handles the feature you're looking for? None of it does anything! It just instantiates another class from God knows where to actually do the work. I swear I spend most of my time in Java projects just looking for the damn implementation in a sea of AbstractSingletonFactoryBean shit.
- The dev culture certainly contributes to the problem. In the attempt to modularize, isolate functionality from expectations and create reusable code, a mess of abstraction patterns have sprung up.
  I get the point: Your logic shouldn't be tightly coupled to your data storage, nor to the presentation, so you can swap out your persistence method without touching your business logic and use the same business logic for multiple frontends. You can reuse parts of your frontend (like some corporate design default structures) for different business apps.
  But you can also go overboard with it, and while it's technically a dev culture issue rather than a language one, it practically creates another hurdle to jump if you want to use Java in an enterprise context. And since that hurdle is placed at the summit of the mountain that is Inheritance, Abstraction and Generics... well, like I said, massively front-loaded.
  Once you have a decent intuition for it, the sheer ubiquity makes it easier to find your way around other projects built on the same patterns, but getting there can be a confusing slog.
I'm sorry just as a matter of policy I'm going to have to downvote you for saying you like java. Nothing personal.
I think some things that were novel when java came out are such old hat at this point the 1990s benefits just aren't benefits anymore. Run anywhere? I'm in a html app right now. As is my IDE and my chat app. Strong interfaces and sane types are only in comparison to the bizarroland of c++ which visibly always seems to basically be word vomit. JIT compilation is in python which is both easier to use and has way better tooling and libraries...making python today run in the "fast enough" category that java was kinda in. I've literally never seen a usable java UI tho.
- So you're going to stride past the part where I say "I'm not going to [...] claim that it's better or worse than others", ignore the bulk of my comment on Java being hard to get into, make a point of declaring you'll downvote for stating a personal opinion, then pretend it's "nothing personal"? I'd be curious how that makes sense in your mind.
  Anyway, like I said, I see no point in petty tribalism. I like Python and C too - that's not mutually exclusive. I hope you have a pleasant, Java-less day :)
- Minecraft is a decent example of a good java program. People jump to the first silly reason to disregard it. Cope.
- Python and Java are barely comparable. I adore both languages equally and use them about the same amount at work. They are just different tools better suited to different tasks.

I learned programming with Java and then thankfully never had to use it since CS102. HATRED

I'll never get the hate for java and love for python. It's like learning mandarin because you think it's easier than Spanish. When you know java you also kinda know javascript, C, Php, and others. When you know python, it's probably a government sponsored course, or a programming class talked your school district into buying their "intro to programming python course". Plus you only get to know python. I'll die on this hill

I use both professionally and I hate both of them for different reasons.
- In my experience, this kind of sentiment is what marks someone as a seasoned professional. When you finally see that all tools are flawed and deserving of some negative remark for a bone-headed misfeature or three, you've arrived. Carry on.

https://bash-org-archive.com/?338364

Anyone who knows me knows that I hate Java with the fire of a thousand suns, but this is just sad. Most of these are true of any programming language. There are plenty of legitimate reasons to hate Java besides the fact that its concurrency utilities are as utterly shite as those of its 90s contemporaries, like the fact that it does not support multiple inheritance, or remote interface implementation, or any form of namespacing besides the goddamned filesystem, or unsigned integers, or string formatting. Or you could rant about the primitive type/object dichotomy and how you can't use primitive types in generics, or the fact that type erasure is a thing and you can't return a generic type from a method because javac is too stupid to remember what generic parameters you passed to a class, or the JVM's atrocious memory efficiency, or the fact that it's not backwards compatible thus requiring end users to install multiple versions of the JVM for different projects, or

Threads will literally punch you in the face

Like...through the monitor? How does that work? Is it an actual fist or some kind of mobile computer component?

Trying to print hello world is actually pretty easy

public static void main[Args]{ SystemPrintOutLn("Helli world"); }

That's should be it. But I can devinetively agree. For simple tasks Java is to complex because you need to do to much stuff prior to it. If you have more complex things its actually not that bad since if you have a good polished infrastructure it can be quite good.