Joel Spolsky (of Joel on Software), famous ex-employee of Microsoft and chronicler of his own opinions on software development, has some opinions about choices. He thinks choices are bad, that they make people unhappy. As he puts it, Choices = Headaches. Leaving aside for a moment the logical absurdity of a programmer, talking to other programmers, using an assignment operator in the languages with which he is most familiar in that manner, he makes some excellent points.
The really salient and accurate point underlying his superficial points about the importance of simplicity in an interface is that being able to choose exactly what you want from a pool of as few options as possible is, all else being equal, a net win. Having to make the decision does not make you happier. On the contrary, it is likely to make you less happy. The absurdity of the redundant and poorly presented array of options available to users of Microsoft Windows Vista for taking Windows out of a fully-operational mode when not actively using the thing is aptly illustrated by his description of the situation. He’s right that the process could, and should, be significantly simplified.
Joel conflates having options with having to choose between them, however, at least to some extent. The end result is that he ends up settling on a solution to the problem of choosing how to shut down the system that is reminiscent of mid-’90s Macintosh design philosophy: automate everything you possibly can to save the poor widdle easily-confused heads of the users, and prevent those users from meddling with it. Personalizing the Mac should be limited to deciding between laptop and desktop, and choosing a case that matches the drapes. Our users can’t handle any real critical thinking tasks, so don’t curse them with options.
Obviously, this is not the philosophy to win the hearts, minds, and happiness of human beings. It didn’t work. Things have changed at Apple — and they have changed for the better — as a result of the lessons of usability and marketing hard-won by the depressing Mac sales figures of the previous decade.
There are really two ideal approaches to your system interface, both of which draw on the lessons almost taught in Joel’s recent essay, and also on the contradicting lessons of the open source movement: people want options, as we discover in the proliferation of Linux distributions, BSD versions, and legions of open source utilities and applications, but they don’t want to have to choose among them over and over again all the damned time. In combination, this is a lesson that may be far more understandable to your average sysadmin than to your average programmer. After all, programmers spend all day trying to create software that they think answers users’ needs. Sysadmins, meanwhile, know exactly what the needs are, but have to decide on the best way to achieve them and, when they figure out what works best for them, they script it in Perl (or whatever) so they don’t have to choose the same things over and over again every time an oft-repeated task is needed.
The point here is that people like to have the options that allow them to pick out an ensemble that best suits their needs and preferences, but they don’t like to have to select all the garments and accessories that make up that ensemble over and over again (to abuse a metaphor). This is really what happens, to some extent, with open source software: one puts together a preferred system configuration by an iterative process of tweaks and nudges approaching perfection (as defined by the user), then uses that well-configured system happily. Apple takes an opposite, but equally valid, approach with MacOS X: there is a default, feature-rich user experience ready and waiting, but it is easily dismantled bit by bit and altered to suit the needs of the user. One is the cook-from-scratch approach to the perfect soup, and the other is the reduce-from-gumbo approach. It is easier to cook the perfect soup from scratch than to reduce a gumbo, but at least with a premade gumbo you have something already edible, which greatly lowers the bar for entry to the wonderful world of serving soup.
I’m full of bad metaphors today, apparently.
So, we have two unavoidable options, really, because there will always be a need for both approaches to choosing the right user environment. You can’t really abstract those out to reduce to one single option. When building a system from something approaching scratch (such as by way of a minimal install of your favorite Linux distribution, on which you install all the software you really want and not one whit more), you put yourself in the position of having to make a lot more decisions before you even really have a very usable, productive environment — but the beauty of the exercise is that, when you’re done and all is ready, you are done making those decisions, the only exception being when you need to create a user environment again (and even that is simplified by already knowing your own software preferences).
The moral of the story is that options are good, excellent really, and necessary to happiness, despite Joel Spolsky’s statements to the contrary. They just need to be presented in a sane way, such that there are ways to avoid making more than the absolute minimum number of decisions, to choose how many decisions you really want to make, and to make as many of them as possible only once.
Start with a default feature-rich environment with all the bells and whistles, but with the actual choices at your fingertips minimized to the specific options most likely to be most favored by the most people. Allow for an option to throw away everything, and build from scratch. Allow for an option to change defaults. Allow for an option to remove stuff. Perhaps above all else, allow for an option to minimize the visible options, reducing things to only what the person actually wants to see, when an ideal configuration is reached and decided on (with, of course, an option that opens up all the previously hidden opportunities).
Don’t overburden us with unnecessary options all the time whether we want any of them or not. At the same time, though, don’t actually eliminate the options — just let us decide which options we want to see.
People — like Joel and, one supposes, Jim Allchin — seem to have the mistaken impression that they must choose between giving us all options in front of our faces all the time or only those options we are most likely to want according to some imaginary measure of the average end user. They should simply learn to trust us to know what we want, both in allowing us to choose from all the options, and in allowing us to tell some of those things we decide against to go the hell away and never return to pester us in the middle of typing an email or, for the love of gob and all that’s wholly, trying to turn off the damned computer.