Home
About
Apple
Career
Experiences
General
Graphics
Hardware
History
Humor
Interface
Networking
OS
Opinion
Politics
Programming
Quotes
Reviews
Security
Software
Sound
Thought
Web
Cheap International
Airfare Online
Wachovia online banking
Get Free Coupons Online
Finding the perfect
discount hot tub
Payday Loans
Stock Trading Online
Stuffed Animals
Smart Investing Online
|
|
Copying Files
Comparisons can tell a story
By: David K. Every
|
Kind:
Created:
Size: |
Article
Oct 30,2003
37 KB |
|
|
 |
 don't have a strong of preference for any particular OS, I have a strong preference for better behaviors and good UI (User Interface), and whichever platform has those. With that in mind, let's look at copying files as a Human Interface; let's pick some nits and learn what the art and science of UI is all about.
Note: This type of analysis is what good User Interface is about. It isn't just widgets and graphics, that's the superficial presentation aspects; the real meat of UI is the details of man-machine interaction and psychology of behaviors and error avoidance. This is just a taste; this article could be 10 times longer on just file copying. Real UI is the details. And that's what some Mac people get, and many UNIX or Windows people do not. While OS X is better than Windows, it still misses too many details.
Since file copying is done often, is time costly, and can be destructive to data, this is a pretty important function. Many of the issues are pedantic details, and most users won't notice (at least not right away) or understand why something works better or worse. But even if users don't know the cause, they probably will notice problems or quirks. And that is what good human interface is about; figuring out the details and consistency (before hand), and making things better, even if users don't understand why.
        
Now the first thing about consistency is that it is consistent; meaning it works the same. Mac OS (pre-OS X) generally worked the same. You could guess what it would do, and learn what it would do, and it would keep doing it the same way. That seems pretty obvious, but it isn't.
Windows is not one Operating System, with one interface; it is many (NT, CE, 98, 2000, XP, XP Home, and so on). Think of all the flavors of Windows and all the patches. Things change between each of them, including almost all the behaviors I document. It is very troubling because any time you say, "it works like this" you are wrong, because it only works like that on some versions or in some modes.
While OS X isn't as bad as Windows, it is nowhere near as good as Mac OS used to be. Things change in each version, and versions come more quickly. Since the behaviors worked better on Macs before, it is frustrating waiting for them to relearn and reimplement what they already had, step by step; frustrating users with each change and the instability in the process. So while fixing it later is better than leaving it broke; it is never as good as doing it right the first time. Apple used to spend the time to design things right the first time - here's hoping they get back there.
     
One of the most important things for file copying is preflighting. Since copying is often a time intensive operation, and sometimes data destructive, a good design tries to convey information (progress) while preventing errors or wasteful delays.
When you copy a file on the Mac, the Operating System first goes out an "preflights" the destination (and source) information. The OS makes sure that the source information is OK, and that the destination is ready to accept the copy, and that there is enough space on the destination disk to actually complete the copy, all before it starts the copy. This pre-validation is a way to make the computer help the user, avoid problems, and save the user time. 
Windows doesn't preflight. Instead of the Operating System helping the user, and avoiding problems, it waits until the user crashes into them; then makes the user correct the problem for it. The OS just throws up a failure message (drive is full dialog): 
Even the error message is confusing since the "Insert a new disk to continue" message and the buttons "Retry" or "Cancel" seem to have no relationship to each other; retry could reference insert or continue. Notice that Windows also doesn't tell you where it got the error. If you're doing multiple copies, how do you know which copy failed? Apple's error tries to tell you where the copy failed. While the Mac could give you more details, Microsoft couldn't give you less, and that ambiguity creates problems and user confusion. Microsoft's bad dialog verbiage is infamous.
Some claim that they don't need preflighting, because failures are rare and the common case is success. This is true; but I've been bit on Windows all the time. Manually making CD or DVD backups, mirroring or backing up drives, putting things onto a USB memory sticks, and so on. So while it may not be very common, it is still common enough to be annoying. Interface designers exist to think about the edge cases (rarely happening things), and common user behaviors, and help avoid costly mistakes.
Would you take off in an airplane without knowing that there's enough fuel to get to your destination? Not preflighting may save OS programmers a little extra time and effort - but it costs the user instead. I'd much rather have a warning that something is not going to work, than waste time waiting for it to complete, only to find out I have to delete the partially completed copy, and start over. And there's no guarantee that your next attempt will work any better. This cycle can make a simple process much more time consuming and frustrating than it needs to.
Reservations : One thing that no one is doing well is reservations. When you start a copy, you should really pre-reserve the space you are going to use. The reason is because modern computers are multi-user and multi-threaded. Just because there was enough space when you start an operation, doesn't mean there will be by the time it completes. Especially with modern file sharing and networking. When you start, you need to be able to tell everyone, "I've got this much space" so you aren't racing to see who can fill up the drive first, and cause the other to error out.
While the Mac (pre-OS X) didn't do this, it wasn't as multi-user or multithreaded, so you ran into this problem less. Still, Apple had realized the problem and promised to fix it in Copland, and demo'ed real solutions to address the problem. OS X and Windows now have many more threads of execution, and more network services that can contend for the same resources, so it more important than it was in the past; and both of them just ignore the problem. Let's hope someone addresses the problem soon.
 
Similar to reservations saying "I'm going to do this", there is also locking; which is saying, "Don't bother me, I'm busy doing this".
When you copy a directory under MacOS you cannot add or remove items to the source directory or move the folder until the copy operation is complete. This keeps you from making mistakes like moving something before a copy is done, or by adding files to the source directory which confuses things and almost always guarantees that something doesn't get copied properly. It also prevents deleting things before they are copied somewhere else and so on. You can still work the folder or files in nondestructive ways, like you can look through the folder and copy it (or parts of it) to other destinations at the same time. But you are properly prevented from doing the wrong things. 
Of course nothing is this simple in Windows. In Windows some versions lock the entire source drive (not just the folder you're working on); this locks you from doing other file violations; but there's no good feedback to tell you what is going on. Other version don't lock you at all, but let you screw up the copy and mess things up, or throw different errors when you confuse them. In the versions that do lock, just because you're locked from on interface (either the normal desktop or the File Explorer), the other way still lets you get around what they were trying to stop you from doing. (This is because they lock themselves in memory, but other programs don't know this. The Mac locks the file, so all programs are informed when they try to access things). After hours of effort, I screwed up one hole filing system doing legitimate things, and gave up trying to figure out which rules work on which versions. But it does not have good "in use" behavior or locking.
  
On the Mac when you copy files to and from drives (and floppies and CD and DVD's, and so on) it verifies that they made it to the destination. On Windows, the OS assumes they made it there intact. You know what they say about assumptions?
Imagine you move a file (which is really a copy and a delete), but the copy never worked right. I'll just bet that deleting your original without having a usable copy was not your intent.
Now you can do verification in Windows, but only from the command line. If you use the DOS prompt, you use the ever intuitive "/v" switch to do a copy with a verification. In other words, the Mac behaves correctly (safely) by default, and Windows will only if you know the secret workaround and commands; talk about a metaphor for the entire difference between the systems.
Sadly, while I mock Windows, OS X takes a mighty leap backwards. If you copy from the command line, there are really many commands to do a copy; only a few of them work property (copy both forks, and so on). There are articles devoted to when to use which type of copy, so I'm not going to go over it here; but suffice it to say, the do not have it working consistent or predictable. The excuse is legacy; Apple didn't want to fix all the UNIX commands and variants of them to work right, so most of them don't. Apple created their own command/variants that do work. It would be better if they fixed the legacy commands; or aliased them to working ones, but they didn't. So I understand it; but it still makes for lots of errors and bad interface. It gets worse, much worse.
You'd expect that a copy from the Finder (UI) to actually work properly? You'd be wrong. OS X's copy is lame; really lame. Apple decided that instead of bundling attributes and resources with files and folders (using the power of the filing system and metadata that they had), instead they'd litter invisible files to a fro; worse yet, they differentiated those files by just starting them with a period. So now what do they do when you copy a file or folder with those files? Since they don't know what to do, they do nothing, and lose all that information when you copy. So your copies forget most of their "extra" attributes, and you get to fix them all when you move them. But wait, there's more.
I'm a web developer; there are a lot of standard files that also start with period, ".htaccess" being a common one, but ".password" is another, and there are others as well. I can't see them from the Finder because the new Apple is ignoring the problem with lame-ass file naming convensions, but more importantly, I constantly lose my copies of them because when I make a copy of a folder it doesn't copy ALL the files. OS X decides for me that I don't really want those and poof, they're gone. With all my mocking of Windows, at least it can copy a folder and its contents. The Mac used to copy its invisible files as well.
I keep hoping that OS X will figure that out, but it's been about 8 years since Mac people first started complaining about this (in Rhapsody) and longer with NeXT, and they keep getting the lame excuse, "but that's how UNIX does things", as if we should make stupidity the norm just because it is popular or they way that UNIX has always done things.
Speaking of stupidity there's the issue of permissions and domain (ownership). In the 60s some turbo-nerds hacked together a cheesy way to manage domains. And while there are many ways to improve it, nothing really bad in UNIX ever gets fixed or addressed. (That would require change instead of just bolting something else on). Apple wanted to keep in that tradition, so now you've got UNIX permissions stuffed underneath something that human users are supposed to use.
Sometimes permissions work, and you get something that asks you to validate. Often, it does something weird, and changes your move into a copy (you can tell by a little plus on the cursor that no one notices; and you only realize later when you find you have multiple copies of things lying around that you have to clean up. Often, they just don't work at all, and you get errors like the following: .
While the idea behind the dialog is bad, the wording and functionality is worse. No I don't want to skip them, I want to authorize or overwrite; where's the option that would make sense?
While Mac OS didn't have permissions, it was easy to use. I don't mind adding security, if you do it well and make it painless. Unfortunately, we didn't get that. The results are that now there are dozens of errors; can't do that, can but it will change things, and so on. Admin can't access everything, they can only change something to have their ownership, then do something to it, then they manually have to try to change it back. But that doesn't work because different files in a set have different permissions so you can't do them in batch, and so on. Then if you get things working, Apple comes in and craps on everything each upgrade or install, making you have to start all over again. None of it is hard to fix but all of it is time consuming.
Someone has got to figure out that the pinnacle of human-security interaction and ownership management was not reached in the 60s and start really fixing the problem. But for now, we live with what we've got. The only good thing I can say about OS X permissions is that I have as many (or more) problems on Windows.
 
File copies are often long operations; sometimes taking many minutes. Since the copy will take so much time, it would be nice for the computer to popup some status and tell us how things are going.
The Mac shows a nice clean window to explain the progress of the copy, containing information about how far along the process is (in files count, and size) and offers an estimate of how long (in time) the operation is going to take to complete. It also shows you in detail where it is copying the file from and where it is putting it. This reminder can be helpful on large copies.
While OS X is almost as good as the Mac, it is less informative. It does give you accurate progress, and tells you what it is copying; it fails to tell you where it is copying files from and to. This is a step backwards.
In the old Mac dialog also had a little rocker arrow, which allows people to see much more information (or less). This is called progressive disclosure; don't show people more than they need/want (and don't waste space) unless they ask for more. Back on a 9" screen you needed the space, and when opening things gave you much more information (like source and destination), this was a good idea. Today, OS X is far less screen efficient overall and using much larger screens and more resolutions, compounded with much less information in expanded mode, so this anachronism seems a little excessive. Just show people what's going on, the extra line or two of text isn't going to hurt them.
Still, while Mac OS X is a step backwards from Mac, Windows is a hop, skip and a jump further down the path of bad UI.
Windows has a progress bar, but the progress only shows the progress of each file or folder and not the progress of the total. This makes it completely useless! I don't care if it is half done with one file (out of 10 or 100 files), I care about how near to completion the whole operation is; duh! And while the Mac told you source and destination, and OS X at least told you what was being copied, Windows does the worst of both. It tells you what (and not where), but it tells you what twice; once for the source and once for the destination. We're copying, not renaming, so the source are destination are always going to be the same. This dialog layout just adds more noise, wasted space and confusion; bad UI.
Windows has a graphic little piece of paper that flies from the source folder to the destination folder, then disappears. Assuming you know that the folder to the left is the "source", which you don't since it isn't labeled, and assuming you know that this means that the destination isn't eating your folder, or that your files are being sent to the shredder; this is supposed to reflect something of value, though I'm not sure what. In good UI animation should mean something and convey information, not just be there to waste processor time and screen real estate.
Also notice the name of the buttons. Windows says "Cancel" the Mac says "Stop". You can't cancel a copy; the files copied are already copied, "canceling" will not go out and remove all the files that are already copied (and it shouldn't). So you can only "Stop" copying more files, or stop where the operation where it is; there is no cancel and go back. Mac button is labeled properly while the Windows label is not.
Animation, color, display, text, verbiage, they all have a purpose in good UI. The flying files aren't reflecting the right type of file or their progress, the progress meter is useless, the text is redundant and confusing, and the button is named poorly. This whole dialog is a complete write-off as an example of really bad UI. This is the difference between confusion and understanding; or between getting it by looking at it, and having to dive for the manual or help system to try to figure it out.
  
Now not only do you need to convey information clearly if you are doing a copy, but you need to do it if you are doing multiple copies.
On Mac OS, it opened a Window for each copy, and slightly staggered them, so that you can see there are other copies going on:
On Windows the copy status windows are opened directly on top of each other so that you can't tell that anything has changed unless you notice the files that are being copied, or if you go to move one of the windows, and find out there is another one behind it.
OS X does things better than the other two; it displays all of the copies in the same window, with their progresses racing each other in their own thread. This lets you manage multiple copies in one clean place, instead of having many windows to manage.
There is still an issue with them all. Multiple File copies should not really be done to the same place, or at the same time. The reason is because when writing files, it will interleave the file; write some of one threads file, then some of the other, then more of the first, and so on. This means that you are fragmenting the files as you are writing them. It would be better for later operation to just queue up the copies and write them serially; complete one before starting the other. But it can be faster to complete the copy by doing it in parallel.
Computers jobs are to remember what you tell them; they are awesome little archives of information. But that applies to the interface as well. The computer needs to remember what you are doing, and how you like to do it.
On the Mac when you copy files it pops up the progress window. Since copy operations can take some time, and odds are you don't want the copy progress window where they put it (center screen). So move it - say to the lower right of the screen (or to another monitor in a multi-monitor operation). The Mac remembers where you prefer that window to be.
On Mac OS, if you start another copy, the next status window will be right next to the first, on OS X just adds to the dialog that is already there. And on both, the next time you start a new copy, it will remember where you prefer that window and pop up the window there.
On Windows, it places status where it wants. You can move it, but the next time you do a copy operation it places the new status window right where it wants (the old "wrong" position). To Windows users this isn't even surprising, they are used to working around the interface.
What happens if you do a copy and a file or folder you are copying already exists in the destination? The Mac is clean and easy, with a clear message, "Do you want to replace it".
If they aren't the same date, the Mac also tells you which version of the file is newer.
Windows allowed for a few more options in replacing, but as usual it wasn't that clear:
On Windows when you do the file copy, it tells you the file already exists and asks you if you want to replace it. Unless it doesn't. On multiple file copies, it presents you with more options on how to replace, sometimes. Some versions will show you both files dates, and ask you to pick which one is newer (as if it can't figure that out). It will only compare dates on files and not folders, so it takes a while to figure out when it is going to work.
OS X does single files clearly, and if there is more than one file, it has all the proper options, and presents them more clearly too: 
OS X has more options than Windows, and more presents those options more clearly. But when it comes to which version is newer or older, OS X hasn't yet matured enough to do the right thing. It too just asks you whether you want to replace it or not, without any hints as to whether you should or not.
The Mac is once again clearer about what is going to happen, which reduces the likelihood of a mistake. The clarity and productivity gained or lost due to better interface doesn't show up on benchmarks or most reviews, so users are unaware of why they are losing time or information. But performance is also measured in productivity and avoiding costly errors not just speed of an operation
 
Good interface is about anticipating the users needs, and helping them. Let's say that you were doing a copy to a drive that does not have enough space now, but would have enough space if you just emptied the trash. Since you haven't emptied the trash, there isn't enough room, but it is in the trash because you're preparing to delete it. The Mac used to be smart about it, preflight the operation and use a little intuition and ask the obvious question: 
This prevents workflow disruption, and saves the user from making another step, or makes something obvious that they might not remember (that they have things in the trash taking space). Windows just gives you the same old, "not enough space" message. Sadly, this is another area where OS X took a step backwards, and also gives you the same message Windows. This reflects the philosophy of good UI; trying to anticipate user behavior and do the right thing, versus taking the quick way out and making something the users problem. While it still works the wrong way, I don't think "minimum necessary" is a good philosophy of interface engineering.
Another example of better interface has to do with removable media. The Mac had software controlled eject mechanisms (or locks). So while you were writing to a floppy, CD, DVD, and so on, you can't eject the disk and screw up the copy midstream, not to mention damage the device. PC's have eject buttons which can allow damage; which of course that throws up an error that may make no sense to the user.
Imagine you are doing a copy that takes a couple minutes -- you forget it is in-progress, and so you eject and stuff another disk in (to read in some file you want to work on). Then you notice that some dialog is complaining that your copy failed. What copy? You're just trying to read a disk. Since this "retry" button (and dialog) looks similar to the "having problems readng the floppy" dialog, "would you like to retry" -- many will just press "retry" thinking it will attempt the read again. That means that their floppy will get filled with crap you don't want on it (the rest of the previous copy), or it will have another error (filled disk, wrong disk, etc.) that makes even less sense. Again, all this ambiguity is caused by bad interface -- or at least the Mac has a better interface.
On the Mac if you want to make a copy of a file or folder (in place), you just select the file/folder and use a single step command: Duplicate. MacOS makes a copy of the file, it adds "Copy #" to the file, with the '#' becoming 2, 3, 4 and so on if you make a copy of the copy, and so on.
OS X also has duplicate, and tries to mimic the naming behavior, but it more annoying. OS X adds "Copy #" in the middle of the file; after the name but before the file extension. While this sounds the same, the file extension gets in your way, and makes it harder to rename the file, which everyone is going to do. File extensions are lame, but that's an issue for a different article; but just from a UI point of view, the least you could do is put the "Copy #" at the start of the file, and not the middle. Editing things from one end are easier than in the middle.
Yes, I realize that you can hide file extensions, and then the rename works better. But that creates tons of other issues; if you're going to use file extensions, then I want to see them. And if things work wrong sometimes, then you should fix it
Despite any annoyances in OS X, the Mac is still much better than making an in-place duplicate on Windows. Windows doesn't have a copy in place (duplicate) command, but you can do the same thing with a two-step command. Select what you want then select the copy menu item, and then select the destination (in this case, the same place) and select the paste menu. It sometimes even works, too. Sometimes it will prepend "Copy" to the copied item and work basically how you expect, sometime it will throws an error because there's already a file with that name.
The error verbiage is once again incorrect, saying "Cannot copy"; the failure was in the "paste" command, not the copy command. And the true failure is that Windows sometimes doesn't know how to rename a file, or append the name to a file. OS X does copy-paste of files too, and at least it can rename them properly. I started to build a complex truth table for when it doesn't work on Windows, which way, on what versions, and when it doesn't work at all - but it got hairy. Suffice it to say it is not predictable to users.
There's a lot more to copy and paste with files; the metaphor is very weak when it comes to filing, and brings all sorts of interface ambiguities and issues. Mac OS wisely avoided this confusing metaphors and bundle of interface errors. Windows invented it; and sadly OS X decided to replicate it. OS X works better in more cases than Windows, but it is still a bad metaphor. Let me explain just a few reasons why.
Now sometimes when you select a file and cut or copy it is doing the name, and other times it is doing the file; you have to be careful to know which. Overloading the behavior causes errors; and that's bad.
The biggest hole in the metaphor is that copy and paste is really cut, copy and paste. Cutting text is fine but cutting files is more destructive; you don't want to accidentally cut files into non-existence. So they disable that part of the metaphor on OS X, which proves you shouldn't be using that metaphor at all; either the metaphor works or it doesn't, and it obviously doesn't. On Windows they are worse and enable the dangerous and destructive cut behavior; but they have to make it a deferred action, which is worse still (more confusing and potentially destructive).
Dragging files is an immediate action, which prevents confusion. When you release the mouse, the operation is complete. Copy and paste is what's known as deferred; you start the cut or copy command and then do the paste minutes or hours later. On the Mac you can view the clipboard and see what is on there and what is going to happen. On Windows you can't; there's no feedback that you've done something, and you can't ever verify what is there and what the paste operation will do. So if you come back to a machine and say paste, or you forget which copy was the last copy, then you will get unexpected results. Also while cut/copy/paste is normally deferred on the paste, on files they have to defer the cut part of the operation as well; it doesn't do the cut until after you've done the paste. Normally, you can cut one thing, then cut another, and it deletes the first item; but that doesn't work on files because it is destructive. And try to cut and paste to the same place and the cut fails and throws an error. These are totally peculiar and unlike the way the metaphor works anywhere else, again demonstrating you've stretched the metaphor too far. Good interface means helping the user to avoid things that can make mistakes (especially destructive ones) and being consistent; copy-paste of files fails on both those counts.
There are two kind of file moves; one is on the same drive, and the other is remote - to another drive either another local drive or across the network. On a local drive a move is a move, the files just go to the new place. On a remote device, a move copies the files, then deletes the originals once complete.
A big question is if you move something to another drive, should it delete the original? The answer is no. Deleting the original is destructive, and it is way too easy to make errors and lose data, and it is easy to delete the files manually. Good interface says you'll always verify destructive behaviors (like deletes), and this is impossible to do well with moves, so they don't. With that in mind the Mac OS didn't allow remote moves, while OS X and Windows decided to empower users to more easily and accidentally destroy copies of their data. They've succeeded too; you can vaporize your files much easier now.
Both Windows and OS X use modifier keys to do different things (moves and so on); they're going on the dangerous assumption that nothing will ever be resting on the keyboard or that keys don't stick or users don't make errors, and so on. A friend was doing a Windows move of almost his entire drive to a new machine; but on the target drive he missed the target by a fraction of an inch and accidentally released on the recycle bin of the other drive; which is the shortcut for delete now without verification. Poof, he'd vaporized most of his data and weeks of work before he could stop it.
Remember, when you're moving remote you're copying and deleting. The safest way to do this is to copy everything, then when that is done and verified, go back and delete everything. Windows and OS X both do it the non-safe way; it copies one file, then deletes it off the first drive. That way if there is any failure in the process, like you ran out of space because it didn't preflight (Windows), you are left with a mess and half your files on each drive. And Windows doesn't copy-delete them in any user understandable order, making it messier to fix. You can waste hours trying to repair the messes Windows makes, and only waste minutes trying to fix the messes OS X makes.
There's more to remote moves as well; mostly around trashcans and recycle bins. I can't figure out all the rules; sometimes moving to the trash deletes immediately, sometimes not. And with Windows you need to be real careful about hitting your local trash or the remote one with a move, or your files will go bye-bye. Again, easily allowing the destruction of your data is not good interface.
If you really want to do complex copies or moves, you want to use a file synchronization or backup tool. These allow for much more powerful management, and much better reporting, with lists of files and their dates or differences, and what to do about them, and so on.
MacOS had this built in with the Synchronize control panel, and you had a backup tool. This was especially handy with portables and keeping it in synch with your desktop. So in OS X, Apple doesn't have that. They've made some more limited solutions if you pay for .Mac, or they have specialized versions for some hardware; but iSynch doesn't really synchronize files or do backing up generically, which would be useful, it only deals with some vertical hardware and some files and data. And there are no free and built in backup solution. This is much more important in OS X because normal file copies don't work right (and copy all files), and the invisible files and preferences and privileges make things messier. You can do it from the command line, but that's not really a good solution. So people resort to third party solutions to do what used to be built-in on the Mac OS and is a very common behavior.
Windows doesn't deal with issues in general.
The Mac generally didn't deal with many foreign filing systems. It could deal with DOS disks, but the "8.3" filing convention (names could have 8 characters and a 3 letter extension) made things ugly. It would truncate the filenames as best it could with DOS, then it added an invisible file for itself that it used to remember what the real names were as best it could. It worked fairly well.
Windows dealt with it's own formats, but there were some differences between older DOS and newer Windows files. It too had to do the same thing the Mac did for dealing with its own files; and had a little remapping thing with short names as the norm, and long names somewhere else.
In both cases, it mostly worked. There are quirks in these translations that you couldn't avoid, or at least not easily. But generally, Macs dealt with other formats better than Windows did. There is always an exception with Windows; Windows server did a pretty good job, but that isn't what most people were running on their desktop, so only a few ever knew that.
OS X tries to be much more open, dealing with many more formats. This makes for some quirks and issues. I still can only sometimes get it to format things as DOS; which is important if you want to actually copy a floppy, USB smartdisk, and so on, to a PC. UNIX seems to work well if they are files that UNIX would understand. And instead of having one format, now there are about 4 or 5 to confuse things. And in the new mode of Apple, there seems to be a lot less attention to detail. While others usually succeed at remapping, I get errors like the following: .
I'm not sure what the heck that means, or why it happened, but it is annoying that it interrupts my copies to tell me it can't do what I bought it to do.
These are just some of the issues, and from a high level overview. The more you look at, and the deeper you get, the more obvious things become.
Some people will argue that these issues are just nits that either don't matter, or only matter when someone is first learning the system. While they do matter more to newbies, they are more than nits. These issues add up. The likelihood of being bit by any one issue at any particular time, is pretty low. The likelihood that you'll get bit by some of them is very high. A few minutes here or there, a few days of data lost here and there, diving for manuals to understand overly complex behaviors or shortcuts and it all adds up. The nits matter; and avoiding them is what good user interface is all about in the first place.
The Mac OS did things better. The high-priests of interface did a great job of preserving consistency and predictability, and preserving the users data at all costs.
Windows was different; it was about the quick hack, cool features, secret functions, useless animation, or just getting things done quickly and easily, for them (easier means more profits). For users, this means more danger, errors confusion, support, and lost data. But lining Bill Gates pockets is more important than quality and data security, right? The facts are facts, Microsoft could afford to invest in good human factors if they want to; so the fact that they don't says something.
OS X is a hybrid. Sometimes they learned from the Mac and did things right or even better. Most places they didn't. Sometimes it appears OS X went after glitz over substance, or they want to make it more like Windows to make it easier to migrate. Whatever the reasoning, the results are the same; interface wise, while OS X does a few things better than earlier Macs, overall it is far less consistent, misses some important things, is more confusing and complex, and it is less safe with the users data overall. At least with the migration argument they appear to have succeeded; Windows and UNIX people feel more at home on OS X than on a Mac (more than some Mac people do) - but it is because OS X does more of the same bad and destructive behaviors that they are used to. Hopefully OS X will keep getting better (more like the old Mac), but it is frustrating to wait. At least OS X is better than what Windows or UNIX people are used to; whether they realize it or not.
The normal reaction for a failure is for a user is to blame themselves, "Oops, I should have done that". More need to wizen up and learn that it isn't usually their fault; good interface is about anticipating users behaviors (accidental or not), and making it easier to work well, and harder to make mistakes. Saving a second here or there isn't always enhanced productivity; avoiding days of lost effort usually is. Attention to detail matters and adds value to me. The less of it there is, the less value in that OS I see. The FileCopy functions are just a sampling of the many other and much bigger issues all over the OS. But they are a good sampling of the philosophy and implementation quality of the OS overall.
 Format for Printing  Mail
|
|
|
|
