In fact I often use the "Thing thing" approach to variable declaration and I think I like it. It's an easy way for me to avoid thinking about taxonomy. But it's not that important. If it wasn't possible I could invent different names.
What really irks me is that in case-insensitive languages, codebases naturally start to use all kinds of variations of casing, to refer to the same variable. It really trips me up when reading code. It's also difficult when writing code since I tend to remember variable names in a very visual way. (Same reason why I dislike the case-insensitive Windows filesystems).
There simply isn't any good reason not to always use the same case for any variable throughout a project.
Beyond that it's also aesthetically not pleasing, from an engineering viewpoint. Case-insensitive comparison is much more complicated than simply comparing strings as arrays of bytes.
Historically, I think the reason why case-insensitive languages exist is simply that at the time they were invented (at least in the case of Pascal), many systems couldn't input lowercase characters.
> In fact I often use the "Thing thing" approach to variable declaration and I
think I like it. It's an easy way for me to avoid thinking about taxonomy.
But it's not that important. If it wasn't possible I could invent different
names.
There's no reason that types and variables need to live in the same namespace.
The language can know what it's expecting at a certain point. Putting them in
different namespaces, like Lisp does, lets you re-use the same name for types
and variables even with matching case, and is more waterproof with regards to
clashes than a case convention.
> There simply isn't any good reason not to always use the same case for any
variable throughout a project.
I agree, but I also feel that there isn't any good reason to have multiple
distinct objects in the same namespace whose names differ only by case. It
just seems like a recipe for confusion.
When I'm quickly iterating on something, it's nice being able to be lazy and
inconsistent with capitalisation. Standardising that in a codebase is
important, but it's more of a job for a linter, I think.
Yes, C has that too. It has different namespaces for struct, union, and enum. And I like the clarity of the explicit namespace prefixes at each place of reference. But I tend to not rely on that distinction, since C++ has only a single namespace.
And as soon as we go to more dynamic languages, where types can also be variables, it all breaks down.
I was just saying that there's no good reason to have different variables with names that only differ by case; the example you gave where you do like that has a better solution in multiple namespaces.
Yes, but it's one extra verbose character, and it's also not a waterproof systematic. E.g., the type "THat" would clash with the variable "that". Instead I want the simple, obvious, and reliable thing: string comparison is comparison of byte arrays. No problems.
My point is that the systematic is an inferior workaround to the obvious case-sensitive approach that would be simpler to implement, simpler to explain, and wouldn't have any of these problems to begin with. It's completely pointless.
Maybe people who somehow don't differentiate between 'T' and 't', and are not visually remembering persons, don't have this problem. But for me, and for computers, they are different characters.
What really irks me is that in case-insensitive languages, codebases naturally start to use all kinds of variations of casing, to refer to the same variable. It really trips me up when reading code. It's also difficult when writing code since I tend to remember variable names in a very visual way. (Same reason why I dislike the case-insensitive Windows filesystems).
There simply isn't any good reason not to always use the same case for any variable throughout a project.
Beyond that it's also aesthetically not pleasing, from an engineering viewpoint. Case-insensitive comparison is much more complicated than simply comparing strings as arrays of bytes.
Historically, I think the reason why case-insensitive languages exist is simply that at the time they were invented (at least in the case of Pascal), many systems couldn't input lowercase characters.