That is because they planed to add pointers and then gave up.

C# has NullReferenceException and it actually makes sense.

Isn’t Visual Studio Code just a fancy editor and not an IDE?

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.

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 used to be very into Java and Kotlin looks nice. What’s your favorite IDE?

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

Which would you suggest? (And if you say python, I will attack you with a pointed stick)

And GUI is even easier and faster with Compose.

“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.

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.

It’s like 5 lines of trivial code

Thank you. If you bothered to read a 5 minutes tutorial instead of posting to 4chan, you could also reach this level of knowledge.

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.

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!

C:

#include <stdio.h>

int main() {
    printf("Hello World!");
    return(0);
}

EDIT: POSIX-compatible shell:

echo "Hello World!"

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.

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.

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++.

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.

Nah it’s not you should check it out

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…