Slashdot Mirror
Should "B" be the Same as "b"?
joshua42 asks: "Although having used Linux and FreeBSD for many years, I have yet to come
across anyone seriously questioning the traditional UNIX style file system name paradigm. With an Amiga background (It should be the same for people growing up with Windows, or those growing up with no computer at all (God forbid!).) it took me quite a while to get used to 'A' and 'a' being treated as different characters. This is of course fairly easy to accept and to understand if you have a technical background. I do however
have a hard time to see how aunt Ginny will ever be able to distinguish between her 'Letter.txt', 'LETTER.TXT' and 'letter.txt' files. In real life, upper and lower case letters represents almost identical information to most people. Has any thoughts been spent on this issue, now that our
favorite OS is becoming increasingly mainstream? Does it need to be
addressed? Have any attempts been done? What are the implications to parts outside the file systems?" This is an interesting point. As Unix grows more and more popular, the simple things we've taken for granted about the filesystem may stand in the way of general users adopting it. What ways can you think of that will mitigate this problem for new Linux users without actually affecting too much? Special shells for novice users, that can simplify much of the complexity may be the way to go, here.
My solution is for the OS to ignore the caps lock key. Not only would it solve the case problem, but it would shut up a whole lot of AOL users.
:-D
www.HearMySoulSpeak.com
Apple OSX is already case-insensitive in terms of filenames, probably for the reason mentioned. MS Windows/DOS have probably all done that for the exact same reason as well.
Of course, in OSX this did cause a security hole in Apache, but it was small, required a specific setup, and was easily fixed.
The One Rule Of Chess You'll Ever Need: Don't play someone who carries a kit in their bookbag.
The only reason why Unix is case sensitive is because it was easier, and faster to implement it as such in the early days.
It is not quite efficient to Preserve Case, and not make it case-sensitive.
I used a file system like this (HPFS) for many years and much prefer it over the case-sensitive alternatives.
It is also a security concern. If I have 2 files, which are identical except for case it is possible I could run the wrong one. Why? Point and Click interfaces barely show a difference between o and O, etc.
There is also no need for 2 files with the same name, and different case when it comes to SOURCE CODE. I have seen more than 1 program implemented like this and it is downright confusing and stupid. " No no, not "ubergeek.c", "Ubergeek.c"... etc.
Garbage. Crap. Total waste of resources.
I've been working in a database language that is case-insensitive for a number of years as well. It is damn nice to not have to worry about somebody typing something in differently than expected. It isn't a problem. And I don't have to call UPPER every time I do something!
case-sensitive is a pain in the ass.
iF yOU wROTE a lETTER tO yOUR aUNT gINNY lIKE tHIS wOULD sHE nOTICE sOMETHING wRONG wITH iT?
If you think she would, then she can grasp the concept that case makes a difference. Give her a little credit.
If tits were wings it'd be flying around.
That behavior depends on your locale.
Let's say I have a file with the following (meaningless) unsorted content:
asklhf
Adjgd
zaskd
Zaoifh
If I sort it with LC_ALL=posix sort myfile, here's what I get:
Adjgd
Zaoifh
asklhf
zaskd
Now, that is exactly the kind of behavior that you dislike.
Try this (LC_ALL=en_US sort myfile) now:
Adjgd
asklhf
Zaoifh
zaskd
Much like you wanted it to be, right? The C locale seems to give the same results as posix, and fr_CA gives the same thing as en_US. I'll leave it to somebody else to explain it by looking in a specific standard, or in the source code.
So in short, check that your locale is correctly specified, and sort should do what you want it to do. Or, you could just use the --ignore-case of sort.
Or were you talking about something system-wide, for ls, file selection boxes, etc.? Then it depends on where the sorting is done, and might be more difficult to fix (since you'll always miss one place).
For bash users: Add the following to the .inputrc in your home dir.
set completion-ignore-case on
Then when hitting tab to complete a filename, it will fix the case for you. i.e. typing "vi xf8" and pressing tab will get you "vi XF86Config" etc.
My other Slashdot ID is much lower.
... and now that I got your attention, let me specify that all other file systems as well are obsolete in the context of the USER INTERFACE.
Frankly, aunt Ginny should *never* have to deal with files and file names. She should not need to know what a file is, nor choose to "save" or "discard" her work after she has written the letter to her friend Margaret. She does not know her HD from her RAM, and all for the better. She would worry to death over having her letter spun around on a magnetic disc, it would get all jumbled up for sure!
File system is an internal, abstract and archaic database that is familiar to programmers and geeks, but a lousy way to represent data for the general user. There are few things worse than navigating a blind hierarchy of unknown folders with no contextual guide to help.
The system should remember the letter when it is written, keep tabs on when it was written, put the subject in a "recent letters" list and generally manage the internal filing transparent to the user. The storage capacity of a modern computer can last aunt Ginny for years, the real trouble is in FINDING her data, the file names alone do little good for that.
For a wonderful example of how well you could do without a filesystem, look at the operation of the Palm OS devices. Anyone could learn to use them. No files in sight! It's only recently that the clever engineers at Palm jumped off the deep end by adding a file system for the flash carts. Anyone who has ever used those knows what a nightmare managing them is.
Aunt Ginny knows fsck all about file systems. Lets keep it that way.
(Oh, and the answer in the context of user interfaces? Go for the most HUMAN representation. People are not very sensitive at all to upper/lowercase letters. We should not punish them for this.)
Jouni
Jouni Mannonen | Game Designer, Consultant
Oh? Well, as a result of a single capitalized "C" in your above post, you just accused another poster of snorting a soft drink. Capitalization does matter. *chuckles*
yes there is a good reason. and it is not about "removing" case-sensitivity, it's about adding it.
/any/ way what so ever. The only restrictions on Unix filesystem names is that no byte within a name may equal '\0' or '/'. You can put whatever characters or bits you want in a filename as long no byte equals ASCII \0 or /.
/before/ these 'beyond ASCII' schemes were even invented. Unix filesystems also support many many other future encoding schemes that have not been invented yet. :)
The basic issue is that Unix filesystems at the kernel level do not interpret filesystems in
This means no "tolower()" or case comparison overhead in the kernel. No complicated (and perhaps non-obvious) policy in the kernel.
It also means filename schemes are easily extensible in userspace. Eg, Unix filesystems support Unicode, UTF-8, ISO8559-[0-9][0-9], and whatever other encoding system you want provided you respect '\0' and '/'. In fact Unix supported Unicode, UTF-8, etc.. almost from day one (ie 1970), literally
Basically, tolower() / case comparison can be easily done in userspace - hence that is the best place for it. Now, of course, userspace might not always agree on policy or how to implement it, but that is not a kernel problem.
Case sensitivity is a matter of taste, and as such it's best not done in the kernel (where it will be set in stone forever). That's actually a general Unix design principle "policy should be implemented in userspace" - and it's actually a very good design principle..
now let's see how many slashdotters fail to realise it..
I use Friend/Foe + mod-point modifiers as a karma/reputation system.