I really really hate C#

it’s far from the worst language I’ve used, but I’m trying to learn Unity and unfortunately that means I’m forced to use C# for all of my Unity code. and it is absolutely full of design decisions that I find bafflingly bad

for example, instead of having a module system, every C# file is imported in every other C# file, all the time. they’re all just dumped into each other’s namespaces and there’s presumably no way to opt out of that

but it gets worse, because you can make things even more confusing with using statements. for example you can type using UnityEngine; and C# will happily dump every single thing inside of UnityEngine into your current namespace too. it’s the equivalent of Python’s from UnityEngine import * (which is considered bad practice for reasons that I hope will become clear in just a bit)

so those are already two design decisions that lead to a lot of confusion, but it gets even worse: when you’re accessing an attribute of a class, you don’t have to write this.attributeName - instead you just write attributeName and the this. is implicit

so that means if I’m reading somebody else’s code that looks like this:

using UnityEngine;

public class SomeClass : MonoBehaviour
{
    // blah blah

    void SomeMethod()
    {
        return someVariable;
    }
}

I have no easy way of knowing, without using an LSP, whether someVariable is coming from:

• somewhere in UnityEngine
• somewhere inside of SomeClass
• somewhere in C#’s global namespace
• somewhere in MonoBehaviour
• somewhere in MonoBehaviour‘s inheritance chain
• somewhere in some other file anywhere in my entire Unity project
• maybe even more places that I don’t know about??

I think an important feature of any language is for the code to be unambiguous, and unless I’m missing something this is the exact opposite of that: it introduces a ton of ambiguity every single time a variable is used, anywhere in C#. and I’m not even sure what they were trying to accomplish by doing things this way?

if my experiences with Haskell and Common Lisp have taught me anything, it’s that if I don’t like a language in the beginning then studying it more deeply is only going to reveal even more things that I don’t like, and deepen my anti-appreciation of it. but unfortunately I do have to learn this language despite my feelings. I’m going to complain the entire time, though

@kasdeya Many of the design decisions of C# are explained because the syntax is aiming to closely imitate java, which was maybe the biggest language when C# first came out. At the time, it was normal to have to carefully organize your code into namespaces, module systems are a relatively newer invention. And both C# and Java are languages where people are expected to be using IDEs to write them, so access to static analysis tools is taken as a given. I agree the design is superceded by modern module systems, but I think the decision was a sensible one at the time the language was being designed