Linus Torvalds Expresses His Hatred For Case-Insensitive File-Systems : linux

[–] [email protected] 61 points 1 month ago* (last edited 1 month ago) (4 children)

I prefer case sensitivity, the filesystem shouldn't do any magic like that. If someone types "file.txt", opening "File.TXT" would be convenient, but also misleading. Ignoring case is what autocompletion/search is for imo.

load more comments (4 replies)

[+] [email protected] -14 points 1 month ago (30 children)

Good for him. I hate case-sensitivity, and it's what keeps me going back to DOS & Windows. FILE, File, file, and FilE should all be the same thing at all times.

[–] [email protected] 0 points 1 month ago (1 children)

somehow you remInded me of the BIG-small archItecture.

[–] [email protected] 0 points 1 month ago (1 children)

BlG-small?

load more comments (1 replies)

load more comments (29 replies)

[–] [email protected] 75 points 1 month ago (2 children)

I recall a case-insensitivity bug from the early days of Mac OS X.

There are three command-line utilities that are distributed as part of the Perl HTTP library: GET, HEAD, and POST. These are for performing the HTTP operations of those names from the command line.

But there's also a POSIX-standard utility for extracting the first few lines of a text file. It's called head.

I think you see where I'm going with this. HEAD and head are the same name in a case-insensitive filesystem such as the classic Mac filesystem. They are different names on a Unix-style filesystem.

Installing /usr/bin/HEAD from libwww-perl onto a Mac with the classic filesystem overwrote /usr/bin/head and broke various things.

[+] [email protected] -45 points 1 month ago (28 children)

Case insensitive is more intuitive and MUCH safer.

You do not want every Windows user to live in a world where Office.exe, office.exe, Offlce.exe and 0fflce.exe are all different files.

OSs and filesystems aren't built for programmers, they're built for grandmas. Programmers just happen to use them. It's much more sensible to give programmers a harder time fixing bugs and incompatibilities than it is to make the user experience even marginally worse.

I mean, all due respect for the guy, but that is an absolutely terrible opinion and I will die on this hill.

[–] [email protected] 19 points 1 month ago (1 children)

OSs and filesystems aren't built for programmers, they're built for grandmas.

You're just flat out and completely wrong.

No grandma is typing out file URLs. This is not a point.
OSes literally do nothing useful on their own. Their explicit purpose is to allow developers to write applications for them for users to use.
Case insensitivity can be handled at the application level, there is no necessity to handle it at the OS level.
Case insensitivity isn't even clearly defined as Linus outlined, but you know what is clearly defined? Different character byte codes.

[+] [email protected] -6 points 1 month ago (1 children)

The entire issue is that gradmas don't type out filepaths.

When you're tying filenames case is easy, because a) you have to press something different, and b) typically terminal monospace fonts look very different in caps and non caps.

But in a GUI where you aren't typing the names out? For a human reading human text caps and non caps are interchangeable. So as the name of an icon case sensitivity is confusing and prone to human error.

I mean, it's that in typing, too, because it's a very easy typo to make and all sorts of mixed case choices can be hard to remember, but it's MORE confusing if you end up with just an icon with a name and the exact same icon with the exact same name just one character is a different case.

OSs don't do anything by themselves, but they come bundled with all sorts of standardize applications built on top of them. If case sensitivity is baked into the filesystem, it's baked into the filesystem. And absolutely no, you can't put it in at the application level. I mean, congratulations for finding the absolute worst of both worlds, but how would that even work? If I tell an app to use a file and there are two of them with different cases how would that play out? You can build it into indexing and search queries and so on when they will display more than one result (and that, by the way, is typically extra EXTRA confusing), but you can't possibly override the case sensitive filesystem.

Now, character byte codes are a different thing, and it's true that the gripe in this particular rant seems to be almost more focused into weird unicode quirks and the case sensitivity thing seems to be mostly a pet peeve he rolls into it, I suspect somewhat facetiously.

But still, that's for the OS, the filesystem and the applications to sort out. It's an edge case to handle and it can be sorted out via arbitrary convention regardless of whether you do case sensitivity for filenames. "Case insensitive means insensitive to other things, too" is not a given at all.

[–] [email protected] 10 points 1 month ago* (last edited 1 month ago) (1 children)

Now, character byte codes are a different thing, and it's true that the gripe in this particular rant seems to be almost more focused into weird unicode quirks and the case sensitivity thing seems to be mostly a pet peeve he rolls into it, I suspect somewhat facetiously.

No, it has nothing to do with "weird Unicode quirks".

It has everything to do with their being a universal standard for representing different characters, and the file system deciding to then apply its own random additional standard on top that arbitrarily decides some thing are probably the same as others.

This is just like Javascript's early ==, fuzzy equality choice. It was done to be helpful, but was a fuzzy system that doesn't cover enough edge cases to be implemented at that low of a level.

[–] [email protected] -5 points 1 month ago (1 children)

Arbitrary is the word.

Arbitrary means you can implement it however you want. The limits to it are by convention. There is no need to go any further than case insensitive filenames. At all. Rolling case insensitive filenames into the same issue is entirely an attempt to make a case against a pet peeve for unrelated reasons.

You want it to handle the edge cases? Have it handle the edge cases. You want to restrict it to the minimum feature just for alphabet characters? Do that.

But you do NOT give up on the functionality or user experience because of the edge cases. You don't design a user interface (and that's what a OS with a GUI is, ultimately) for consistency or code elegance, you design it for usability. Everything else works around that.

I can feel this conversation slipping towards the black hole that is the argument about the mainstream readiness of Linux and I think we should make a suicide pact to not go there, but man, is it starting to form a narrative and am I finding it hard to avoid it.

[–] [email protected] 8 points 1 month ago* (last edited 1 month ago) (1 children)

There is no need to go any further than case insensitive filenames. At all. Rolling case insensitive filenames into the same issue is entirely an attempt to make a case against a pet peeve for unrelated reasons.

This is literally just the same issue. I cannot see what two issues you are separating this into.

All of this stems from case insensitive file names.

But you do NOT give up on the functionality or user experience because of the edge cases. You don't design a user interface (and that's what a OS with a GUI is, ultimately) for consistency or code elegance, you design it for usability. Everything else works around that.

The OS is not the GUI. Every GUI you see in the OS is an application running on top of the actual OS.

The OS should not arbitrarily decide that some characters are the same as others, it should respect the unified standards for what bytes represent what characters. Unless there is an internationally agreed upon standard for EXACTLY what case insensitive means for every character byte code, then you are building a flawed system that will ruin the user experience when massive bugs and stability issues come up because you didn't actually plan out your system properly to cover edge cases.

You know, as Linus is pointing out given his multi decade history of running Linux.

[+] [email protected] -8 points 1 month ago (1 children)

No, hold on, this is not about the OS.

This is about whether the filesystem in the OS supports case insensitive names.

That determines whether the GUI supports case insensitive names down the line, so the choices made by the filesystem and by the OS support of the filesystem must be done with the usability of the GUI in mind.

So absolutely yes, the OS should decide that some characters are the same as others, not arbitrarily but because the characters are hard to read distinctly by humans and that is the first consideration.

Or hey, we can go back to making all filenames all caps. That works, too and fully solves the problem.

[–] [email protected] 4 points 1 month ago* (last edited 1 month ago) (6 children)

No, hold on, this is not about the OS.

Holding on.

This is about whether the filesystem in the OS supports case insensitive names.

K, now that we're done being pedantic...

That determines whether the GUI supports case insensitive names down the line, so the choices made by the filesystem and by the OS support of the filesystem must be done with the usability of the GUI in mind.

Oh yes, let's prioritize making sure that when grandmas are using the raw filesystem they're not confused by case sensitivity, totally worth it over stable, bug-free, secure, software.

Definitely couldn't have just built grandmas a case insensitive option on the user portion of the file system instead of introducing bugs and edges cases into literally every single piece of software they might use...

load more comments (6 replies)

[–] [email protected] 56 points 1 month ago (1 children)

Your grandma will never type file names in shell, she'll use Open File dialog, where case sensitivity does not matter.

[–] [email protected] 13 points 1 month ago (1 children)

Hah. Second absolutely deadpan Average Familiarity instance in a Linux forum I have this week.

I mean, no offense to grandma. Plenty of grandmas are computer literate. But the idea of this hypothetical normie Windows user doing anything but double click on an icon (too slowly, with a bit too much pressure on the left mouse button, as if that made a difference, probably having single clicked to select first, just in case) is absurd.

File names are icon names first and foremost. File paths are a UI element to breadcrumb the location of the currently open file manager/explorer window unless proven otherwise.

And that is the right answer and how the whole thing should be designed.

[–] [email protected] 12 points 1 month ago

double click on an icon (too slowly, with a bit too much pressure on the left mouse button, as if that made a difference, probably having single clicked to select first, just in case

I do that.
I use KDE.
I am a programmer.

Also, I make directories with the correct capitalisations for the project names before going inside them and running git clone, which makes another directory in small letters.

Also, when I make header files matching class names, I capitalise them same as the class name. That messes up stuff for some others, sometimes. I like it.

load more comments (26 replies)

load more comments (1 replies)

[–] [email protected] 21 points 1 month ago (2 children)

Utterly reasonable opinion. Case insensitive filesystems are just lazy programming.

[–] [email protected] 47 points 1 month ago (1 children)

Case insensitive file systems arent lazy, they're a programmer putting in a lot of effort to try and be helpful only to realize that their helpful system doesn't actually cover all the edge cases it needs to and thus just adds a whole extra layer of complication and annoyance to the project.

[–] [email protected] -1 points 1 month ago (2 children)

Hmmm. I doubt that, unless they were really bad programmers, downcasing (or upcasing) the file name in the file name accessors took much work, but I'll grant it's more than zero.

I'll retract the "lazy" comment.

load more comments (2 replies)

[–] [email protected] 30 points 1 month ago (1 children)

Kind of the opposite. It takes more effort to make a filesystem case-insensitive. Binary comparison is the laziest approach. (Note that laziness is a virtue.)

I'm on the fence as to which is better. Putting backwards compatibility aside, there's a perfectly good case to be made for case-insensitivity being more intuitive to the human user.

Apple got into a strange position when marrying Mac OS (case-insensitive) and NeXTSTEP (case-sensitive). It used to be possible to install OS X on case-sensitive HFS+ but it was never very well supported and I think they axed it somewhere down the road.

[–] [email protected] 3 points 1 month ago* (last edited 1 month ago)

I can with very high confidence say that for the average computer user, case-insensitive is basically the only alternative. At least if you don't want IT and computer support around the world to start going postal.

As soon as someone is at least semi comfortable navigating a unix-style terminal and using a terminal based text editor to at least change config files, case-sensitive starts to become better. And often the more you get into programming, the more you get like Linus here and develop a hate.