Slashdot Mirror
Are Computers Getting Too Easy To Use?
An unnamed correspondent writes: "The latest issue of the Journal of Electronic Publishing has a paper by Bradley Dilger called The Ideology of Ease. Dilger writes that making computers "easy" may also make them less useful. 'Ease is never free: its gain is matched by a loss in choice, security, privacy, health, or a combination thereof,' he says." Some of the allusions seem a little stretchy (I'm not sure that Marx has much to do with user interface design) but Dilger makes an interesting case for re-thinking the motives behind some moves toward "easiness." Especially as GUIs for Linux proliferate, it makes sense to think about exactly what constitutes ease.
I find it ironic that a paper on ease of use uses such unapproachable language. I found to be over-analytical and bombastic (I love self-describing words).
Not to pick on you in particular, deacent, but I was rather amused to see several people commenting on the vernacular the author demonstrated.
As I was reading it, I was thinking of how nice it was to see someone who dares push beyond the simple vocabulary we're used to encountering on network television and even in most newspapers. The "people who use big words are elitist" and general anti-literate attitude that prevails in North America disgusts me. (And you'd think that people who, in general, claim to have sufferred mild persecution for their intellect would be the last to criticize such an author.) Even if he did manage to lose a good chunk of his readership by mixing in several coined terms without defining them until a couple paragraphs later, he used the most accurate language he could find for the job. More power to him.
And don't forget that the man teaches writing. He'd very nearly look bad if he were to forego a smattering of tri-sylibic words in everything he publishes.
--
If a tree falls on an anonymous coward yelling 'first post' in the forest, does anybody hear?
Man, when I started out (1973), you had to be really, really dedicated to use a computer. Everyone who used one knew how to program (ok, mostly because they didn't do much else). When I hacked into my first UNIX system (1975, one of the hundreds at Bell Labs in Holmdel), half the users didn't even have passwords. Didn't need 'em, UNIX (System III, maybe something even earlier) was just to hard to use.
Now anyone can learn a computer. My Mom knows three operatings systems (AmigaOS, MacOS, Windows). What's this world coming to? They were hard to create, they should be hard to use. In fact, most of you shouldn't be on a computer, either. I think the test should be "can I design one from scratch". In case there's no silicon FAB in your backyard, you can use FPGAs...
-Dave Haynie
I have always felt that the ease of use-lack of sophistication argument is most prevalent on the Internet. In the days of Usenet, gopher, BBS, and lynx the people posting were those with the know-how to post. The average quality of stuff found on the Internet was higher-it took brains to use, so posts were thought up by brains.
With the advent of the Web (A Very Good Thing) suddenly people without the knowledge of how things work and many other general skills were thrust into an arena where it was easy for them to crear nonsense and havoc. (who do you think put the chaos there?)
To quote my father when a non-tech would ask what was so good about the web- "Nothing, stay off, don't clog it for those of us who want to actually use it."
Im not saying that the Web is a bad thing, but with the ease of use comes an inevitable loss in standards of quality.
Articles like this pop up every now and then and it amazes me every time! Sometimes I think we assume too much that we have the perfect user interface models now with command line, window based GUI's, desktop analogies and computing is divided into applications with running application instances as processes - often residing in their own windows. I'd like to see some work and ideas on radically different types of user interfaces and views on what an "application" is.
In the real world, work is typically divided into tasks. People have a hard time concentrating on more than one task at a time, which is why a task division is logical. Computers however, do not work like this, so a task division and a division into applications is not at all as clear. I like the Java idea a lot where the whole collection of objects running / "living" in the virtual machine is essentially one big application.
Recently, web based user interfaces are everywhere. This is a pretty interesting analogy because it's based on documents - almost reports. "Here is the current situation. What do you want to do? Ok.. here's the situation after you did that."
The way I see user interfaces in, say, 3-5 years, is that we have large systems of objects, be it Java, COM/DCOM, Corba or whatever, collaborating between relatively small and simple devices. There could be some in a VCR, some in a TV, some in a game console, some in a web pad, some in a cellular phone etc.. Then you have user interface consoles; cell phones and web pads for instance, that you use to access the data in the network / system of objects. The user interfaces will be relatively simple - much like that of a TV.. On, off, volume, select channels.
To perform more complex tasks, you might use some kind of agent system, assigning tasks to autonomous agents that carry out the tasks on their own and report back to you. Artificial intelligence is an area that has been largely forgotten lately. People make fun (perhaps rightly so) of the Microsoft Office actors (the paperclip), but the fact is that this is a very clever system and can help making systems much easier to use in the future.
Whatever happens, it seems pretty bizarre to claim that computers are getting too EASY to use. Please! We are nowhere near that point yet! The user interfaces we have now are very primitive and un-user-friendly.
I ask this because all the comments so far are based on the statements in the /. summary, not the article itself.
His argument is that ease-of-use has ceased to be the means (as it was initially with the desktop metaphor) but the end of GUI design. That is, programmers are now trying to make things easy on the user, instead of easy to use productively.
An example of his point I'd like to reference is the "smart menus" in Microsoft Office, which deliberately hide functions in order that the user doesn't have to see them. That actually makes it harder to use the software's functions, and it doesn't make it any easier to use the existing ones; it simply lets the user feel at-ease, never even seeing options he doessn't understand.
Steven E. Ehrbar
All of the above certainly employ computing technology. They even all have interfaces though of vastly differing sorts. No, none of them are the same as the general-purpose box that sits on your desk yet many of them duplicate the functions it performs.
At one time a 'computer' was a large hulking device that sat in a special air-conditioned room attended by a cadre of highly trained folks that spent all day performing mathematical calculatiions (hence a "computer".)
Now we use that underlying technology to edit digitized video, play interactive simulated 3D games, and instant-telegraph each other.
Are all of those 'computing'? Well, yes in one sense but no in another. Are all of the devices listed above 'computers'? Well, yes in one sense but no in another. Do all of them have interfaces? Well, yes in one sense but no in another.
What and how we use 'computers' have evolved. Their capabilites have also evolved. To argue that they've become 'dumbed down' is to ignore their ubiquity and specialization.
Tools are built appropriate to a their task. For computers that task is no longer calculating large tables of ballistics or whatnot but rather the ones listed above plus so many others. That we limit our tools to their task is not suprising: it's smart engineering.
Kee It Simple, Stupid means defining a tool's functions and paring off extranious functions. Make it the best at what it does and don't compromise it with superflous features. If it can be multipurpose great but don't let this interfere with it's basic usability.
Computers have become specialized tools. To confuse optimizing their functionality for their task (oftentimes interfering with extranious or lower-priority functions) with 'dumbing-down' is to ignore the features this specialization brings.
I don't read ACs: If a post isn't worth so much as a nom de plume to its author then I wont bother either.
Grandmothers are exchanging cookie recipes.
Children are being harassed daily by the same type of people who would try to kidnap them.
Rednecks say things like: "Maw, Paw done shot up the America Online again!"
oh, wait a minute, every one of these has happened!
{SARCASM}We're too late! We're DOOMED!{/SARCASM}
"Ancillary does not mean you get to rule the world." --U.S. Circuit Judge Harry Edwards, speaking to the FCC's lawyer
I would agree that this is a good example "hiding the machine from the user", but this is just a natural progresion of computer science. Drum, Core, and Random Access Memory have all given spawn to their own file systems to help a user store and retrieve information from them. Extending this logic, one could say that a journaling file system "makes it to easy" and doesn't really teach the user about the computer they are using. Clearly, this is progress to welcomed with open arms.
Should car makers include displays for compression per cylinder? Mixture? Exaust spectralnalysis? All of these items would be educational to the user and give the user a better understanding of how and why his car works, but it would not help him get to work in the morning.
If the product has a target demographic that is very diverse and crosses many differant educational levels, the interface should match the market.
The GUI's are easyer until something goes wrong. Then the user has to either figure it out or get help.
Leading to strange ideas such as how is such a user ment to have a clue what a stack frame and register dump in hex is ment to tell them.
While I agree that his statement is bullshit, your reply implies some steaming hot crap of its own.
While you can make the GUI itself as usable as you want, you certainly can't make the system as a whole easy to use unless the underlying non-GUI architecture is clean, consistent, tight, and well-organized. Typical end-users need more than a pretty symbolic graphic interface slapped over top of a chaotic, complex system; they need a system that is simple and well-organized in every place it is exposed, including the filesystem hierarchy and the ability to install and configure hardware and applications.
GNU/Linux or GNU/BSD systems are the furthest thing from this. They are chaotic and their overall organization (or lack thereof) hasn't been thought out well at all. It's not that the development community is incapable of developing a well-organized GNU/Linux or GNU/BSD system; it's that no one seems even remotely interested in doing so.
For instance, every program uses a different configuration file format, often times with its own steep learning curve. This is a headahce not only for expert users who want to configure everything with a text editor (they must usually learn a new and different scripting language just to configure each new app!), but for developers who have to implement a custom GUI configurator app and different file format parsing code for every program. What is needed in this instance is a common XML/schema-based configuration file format so that developers can write a single configurator app and have it suck in a schema that comes with every app it is used to configure; the configurator dynamically creates dialogs, controls, etc, based on the schema and can then be used to configure any program in existence--while expert users or administrators who want to telnet in and edit a configuration by hand can easily do so to an XML-based config file, and can then even run a common XML validator that verifies the syntactical correctness and well-formedness of the XML configuration file before doing something crucial like restarting a key system service.
Another foolish oversight in underlying GNU/Linux design is the practice of hard-coding absolute directory path references into programs. For instance, if you relocate gcc to a new directory, it breaks unless you (1) recompile it from sources and compile in a different hard-coded directory expectation, or (2) download binaries that someone else has already gone to the trouble of compiling that way for you. As an end-user or administrator, you have very little choice about where you can install a new program's files within the filesystem. This sucks for distribution makers who might want to make a simpler, better-organized filesystem hierarchy to make a GNU/Linux system that is more suited to normal people. For instance, I might want to create a distribution that has only 3 major root-level directories: /apps, /docs, and /system. But I can't do this now without hacking around on source code and rewriting every single app and utility and daemon I include in my system--and that's preposterous. Instead, every app should have been smartly programmed to not expect the existence of a file in a particular place in the filesystem, but instead to assume the existence of an environment variable in which it can look to retrieve the needed path; in this way, I (as an end user of intermmediate knowledge or as a distribution maker) can rearrange the filesystem hierarchy as I see fit, without having to hack around on the source for every installed program and recompiling it. In fact, I can even relocate installed binaries and other files and still have the program work--something that's a clear advantage over the world of Windows.
- "It's just a matter of opinion!" - PRIMUS
In the end, each person needs to find the balance that is right for them. To have more configurability, they need to invest more time to do the actual configuring. To be able to configure in less time, they need to give up some of their configurability. This is a wide scale ranging from the Macintosh interface to actually programming an X application yourself. Obviously, actually programming the thing is the ultimate in configuration, but it takes the most time. On the other hand, using the Macintosh interface is much like watching a movie, you just sit back and watch without being able to change anything.
'Ease is never free: its gain is matched by a loss in choice, security, privacy, health, or a combination thereof,'
This all depends how that ease is obtained. This is no different from trading off power of a program against the speed or space resources it uses: of course you can make a program use fewer resources by making it do less. On the other hand, if done properly, you can often make it do *more* while using fewer resources.
Ease of use obtained by limiting your what you can do with the code, of course, necessarily makes this tradeoff, but that's just a straw man.
The difficulty of providing power while simultaneously delivering ease of use is overcome by excellent engineering. Real Ease of use obtained in modern software design is obtained by standardizing the general idioms with which many programs are to be used, and eliminating inconsistencies and awkward modalities that make software use more complex, not for the purpose of additional functionality -- but for the ease or ideosyncratic views of the programmer.
This latter "ease of use" actually empowers users, making it possible to do more, better and faster, without significant compromises.
Unlike the inherent conflicts between interactivity and fiction (where there is a true trade-off) one can at once offer a user consistency, elegance and power. It isn't as easy for the programmer to do this -- especially if the programmer is unfamiliar with user design issues -- but that isn't a relevant factor.
Ease of use is something for which we must constantly strive. Articles such as this simply offer lazy programmers excuses to rationalize shoddy engineering.
Ease is never free: its gain is matched by a loss in choice, security, privacy, health, or a combination thereof.
This sounds suspiciously like something out of an economics textbook: if you're at an equilibrium, utility maximizing point, you can't gain something without giving up something else in return.
However, the above is true only if you're at an equilibrium point, when all factors are in balance and you're forced to trade off one for another. The fact of the matter is, most software is difficult to use simply because it is poorly designed, with skill or little thought given to the end user experience -- end of story.
I've been hacker (!cracker) for almost 20 years now and for as long as I can remember there have been people moaning and complaining about computers being hard to use. But the plain fact is, computers are not hard to use, they are hard to learn to use. Just like anything else which requires skill, computers require time and effort to master. GUI's and other such interface advances work to make working the the computer less alien and confusing to a new person by presenting files and programs in terms of pictures or some other easily grasped analogy. But these don't make computers any less complex, all they do is hide that complexity. When things break, which they always will, the complexity hits you square on the nose. This is why most computer problems that come in to techs nowadays are software problems or pure ignorance on the part of the user, not hardware failures. Ten years ago the opposite was true. Once upon a time if someone owned a computer and used that computer, they had a pretty good idea what was going on with it. When things broke they had some chance of fixing it, and fixing it right. Today the average computer user is as oblivious to what goes on under the hood of their systems as they are of quantum physics. Arthur C. Clarke once said that any sufficiently advanced technology is indistinguishable from magic. The reason why computer technology is like magic to the average person is that our culture has not caught up with the technology. Once it does the problem will solve it self. Cars are not mysterious things to most people. A person might not be able to rebuild an engine or even change their oil, but they have some idea what is going on in the engine compartment, and they aren't afraid of their cars. Of course there are always going to be people who are exeptions, but generally this is true. This is because cars have been a part of our world for almost a century. No one makes claims that cars need to be easier to drive. Instead everyone understands that driving is a skill and one that must be mastered over time. Once mastered, driving a car is second nature. This is exactly how it is with computers. In todays world computer literacy is every bit as important as the ability to read. There are few jobs other than manual labor where computers aren't used. They are an integral part of any business. As such they need to be effective tools. A computer is only as effective as the ability of a person to use it. Someone else once said that if you make a system even and idiot can use, only idiots will use them. I find this to be very true. Dumbing down a computer to satisfy those who are not willing to master it is ultimately counterproductive. In the end you have a computer that anyone can use, but which is not useful for much of anything. Great music is not played on a piano with 3 keys. Now I'm not saying that everyone out there should should be uber-gurus capable of debugging code in their head, in binary. But people should be able to make use of windows or the MacOS (or even Linux) and master the applications they use on a daily basis. The truth is they aren't going to get any easier to use in the future. With software companies constantly adding new features to their products to justify costly upgrade cycles every 2 or 3 years, software stands to become more and more convoluted. Now if the software companies were smart, they would spend their time and energy figuring out how to better implement the features they have now and make their software run more efficiently, but that is another issue. You can make something user friendly, or you can make it idiot friendly. The two are not the same thing. Making something user friendly means making it easy to use, efficient to use, even if there is an initial learning curve involved. Keyboard shortcuts in applications are a perfect example of this. They take time to learn, but once master they make a program far more easy to use. Making something idiot friendly means trying to remove or lessen its learning curve to the detriment of its usefulness. All technology requires knowledge and skill to make use of it. The sooner people understand this and work towards gaining that knowledge and skill, the sooner they'll realize just how easy computers really are. Lee
Muslim community leaders warn of backlash from tomorrow morning's terrorist attack.
If you look at the very bottom of an article (before the footnotes and bibliography), you'll notice that Dilger writes:
What he's saying essentially is that he is opening a formal enquiry into this particular subject. It's the beginning of a scholarly dialogue about the ideology of ease; understanding this can be greatly beneficial to both academics and programmers and developers.Should car makers include displays for compression per cylinder? Mixture? Exaust spectralnalysis? All of these items would be educational to the user and give the user a better understanding of how and why his car works, but it would not help him get to work in the morning
I don't think your analogy is quite correct here. The Microsoft Office "hidden" menus are hiding functionality that cannot be duplicated with other features. If you were talking about how Microsoft hides things like the status of the disk cache or the the number of free clusters or something like that, you'd be correct.
But what we're talking about here is more akin to car makers who might, for example, hide the cruise control buttons or the car's stereo behind panels for fear that new users would find them to difficult to use. Imagine walking into a car where everything but the minimal tools you need to get you to work in the morning were hidden behind panels. The only things visible would be the ignition, the shifter, the steering wheel, the pedals, and the speedometer. The fuel gauge, the temperature gauge, the stereo, A/C controls, cruise control, etc. are all hidden behind panels that must be opened first before they can be used. That's what MS Office is doing.
My journal has hot
There is easy-to-use, and then there is easy-to-learn. They are often orthogonal. That seems to be especially true in computer UI's.
It seems to me that the MacOS is easy-to-learn, judging by the things the Mac-o-philes tell me. That is, you can easily get things done, without any need for any understanding of what is going on behind the scenes. That isn't really a bad thing, either, until you NEED to know what's going on.
That's where the author's example came in: the kiddies would use ftp, and not have a clue where the file wound up, or even that they had downloaded a file. They hadn't learned that you start an application, and then open a file... they had learned that you click on something, and it opens...
If you save a file somewhere on a Unix box, but don't know where, or exactly what the name was, you can use grep with regular expressions, or any one of a number of methods to search the directories where you have write permissions and find it. If you have that problem under Windows, there aren't any reg-exps, just ? and *. Reg-exps are hard to learn, but so powerful and easy to use. They just don't seem to fit the Windows/Mac way of doing things. This is the difference between easy-to-use and easy-to-learn In a Nutshell (hey, that's a catchy phrase, I should trademark it!).
I read that fellow's article,and I'm still scratching my head. I know that you have to salt a scholarly paper with some big words, and some obfuscation, lest people realize that you really aren't adding anything to the field, but this was ridiculous. What field is this guy in? The standards for content are very different than in Econometrica, or even American Statistician.
I'm really not sure what his point was, but I have the uneasy feeling that he had one.
Nels
See what I've been reading.
Ease of use isn't bad. The point of the article is that, by taking such drastic steps to hide the actual workings of the computer from the end users, it does them a disservice. It makes it impossible for them to take their understanding of one program in one environment and apply their knowledge more generally.
You want the truthiness? You can't handle the truthiness!
This is an interesting way to start a Sunday. :)
I've got to stress that the headline and snippet chosen here is NOT an accurate summary of my article. As I say time and time again in the article, I have NO problem with the general trend of computers becoming easy to use. My problem is that this ease is sometimes portrayed as the only way to do it, in a variety of different contexts, and by a variety of different agents. "Is it easy?" can become the only question asked, and that compresses the possibilities of computing for a lot of perfectly capable folks.
More on this very complex problem later... got a lot to do today. Thanks to everyone who has commented so far -- many of the points made are quite salient. I hoped to start an academic discourse about ease stuff; a Slashdot discourse is great as well.
best,
Bradley
The article is discussing the fact that we are making the GUI so easy to use that the average user (NOT the power user) have no clue what they're actually doing. For example, the university provides a link to an FTP client to allow users to transfer files between the University system and their home systems. The users click on the link then complain that "I clicked, the computer downloaded something but then nothing happened. Now what do I do?"
The question isn't "Are GUI's restricting the power users from getting at the guts of the machine?" The issue is "Is making GUI's so easy to use a good idea?"
"The legitimate powers of government extend only to such acts as are injurious to others." Thomas Jefferson.
"I see no reason why computers can't have several layers of user friendliness. When you're comfortable with one leve and ready to move on, you enable the next layer of complexity."
Good point. However, most important for mindshare and marketshare, is how easy to use the "newbie" level is, because this is where the overwhelming majority of users will enter the system. If this level is sufficiently buggy, the new users will never bother to become advanced users, they'll just walk away. If the "newbie" level *requires* use of the power-user interface (like editing config files, or using the command line) to get basic things done such as modem setup, or printer setup, then, again, new users will never bother to become advanced users. Therefore, the most user-friendly level should have sufficient power to do the things that even beginning users need to do, easily, consistenly, and seamlessly.
Multi-level UIs is where OSes are converging. From the power-user side, the free *nices are adding increasingly easy to use GUIs - desktops and window managers. From the newbie side, the MacOS is layering it's extremely consistent, easy to learn GUI over a full BSD unix, with terminal windows/command line, bash, gcc, apache, etc. That's what MacOS X is.
But in order to succeed, an OS must ensure that the *easiest* UI level, the GUI, is seamless and easy to use. Power users expect, and can tolerate a little complexity, but most new users cannot, and it is from the legions of new users that tomorrows power users will come. If you want these future power users to end up on your OS of choice, then you need to make sure that the entry level UI on your OS is extremely consistent and user freindly. So far, the free *nices are not there yet. Much of this is due to the inconsistency of X application user interfaces on the one hand. On the other, it is due to the immature state of the free desktops, by which I mean, their failure to provide complete access to every sort of configuration a new user will likely need to do in a consistent, easy to understand way. Great progress has been made, but they're still not there yet.