In application design, there's a tension between power and simplicity: Users want the ability to get a lot done, but they don't want to take the time to learn lots of complicated features.
- One way to address this dilemma is to use progressive disclosure — that is, to show users only the most important options until they ask for the advanced features.
- Another good approach is to use generic commands, which remain the same across many different contexts and thus reduce complexity.
Cut, Copy, Paste
The cut-copy-paste triad offers the most famous example of generic commands. These 3 basic commands suffice to let users do everything from move text to edit movies. In fact, because they work across so many applications, I view them as " super-generic commands."
The first guidelines for generic commands are:
- If at all applicable to your domain, your application should support the super-generic commands that people expect and know from other applications.
- In particular, provide cut-copy-paste commands for moving stuff around.
One of the big criticisms of iPhone version 1.0's user experience is that it doesn't support cut-copy-paste, even though users definitely expect these commands in any modern design.
The cut-copy-paste triad wasn't the original generic editing command set. The original designers at Xerox PARC used move-copy-delete. If you think about it, these two triads both map to all common user actions, they just do it in different ways:
||Cut (with no subsequent Paste)
|Insert stuff in a new location while removing it from the old location
||Cut, followed by Paste
|Insert stuff in a new location while leaving it intact at the original location
||Copy, followed by Paste
From the above table, it might seem that move-copy-delete is the superior set of generic commands. In practice, however, it forces you to specify where you're copying or moving to and from. Having 2 arguments per command complicates matters. In contrast, cut-copy-paste employs an intermediate state: the clipboard, which is a different complication but allows each command to proceed with only 1 argument.
It's hard to say which of the two models is superior. But it's clearly best to pick one model and stick to it everywhere. Much confusion would ensue if people had to use one model half the time and another model the other half of the time.
Benefits of Generic Commands
Generic commands have three advantages:
- They are ubiquitous, so users will expect to find them (and will look for the commands without being prompted to do so).
- They are consistent, so users will know how to use them.
- They replace many commands that are more specialized, so users have less to learn.
If users are to form expectations about available commands, consistency is essential. Consistency is further enhanced when commands are always assigned the same command-key shortcuts. Thus, rather than looking for a command, users can, for example, simply type Ctrl-C when they want to copy something.
Consistency doesn't require that generic commands work identically across different contexts — just that users perceive that they do so. For example: cutting a piece of an image using a graphics editor typically leaves a blank area on the canvas, while cutting words using a word processor closes up the remaining text without leaving a gap.
You could expose these different operations by using separate user interface commands — such as cut picture and cut words — but doing so would add unnecessary complexity. Yes, when users issue a cut command in the two contexts, different subroutines execute, but it's better to hide this difference and create the user illusion that a single command performs these similar operations.
On the Web, a simple example of a generic website command is "go to the homepage." Often, sites support this command using a logo in the page's upper left corner that links to the homepage. Unfortunately, not all sites do this, which seriously reduces usability for the Web as a whole.
Currently, the only generic Web commands that truly work are those in browsers rather than on individual sites. Examples include Back, Forward, and Print. In the latter case, it would be much more useful if the generic Print button subsumed a page's Printer-friendly version feature; clicking Print should print a printer-friendly view, not the view on the screen. You can implement this improved user interface by providing two CSS style sheets for the page: one for displaying on the screen and one for printing.
iPod Touch: Examples of Generic Commands
Generic commands don't have to be issued through menus and command-key shortcuts. As the following screenshots show, the iPod Touch — a touch-screen tablet device that's basically an iPhone, minus the crappy phone service — uses gestures and icons instead:
Three iPod Touch applications, shown in both vertical and horizontal tablet orientations.
Left to right: photo viewer, music player, and Web browser.
Turning the device is a generic command that alternates vertical and horizontal display modes. In the photo viewer, when users turn the tablet in the same direction as the photo's orientation, it makes the image larger. In the music player, turning doesn't make the record covers larger (since they're square), but rather lets users scroll through albums. In the Web browser, alternating between vertical and horizontal provides different Web page views, both of which are useful.
The point? One operation — turning — has multiple effects that are recognizably similar, but differ in their specifics depending on the individual application's demands.
The device also provides generic commands in the form of VCR-style icons: a right-pointing triangle means "play" (or "forward"), a left-pointing triangle means "rewind" (or "go back"), and a double triangle means "do it faster" than a single triangle.
VCR icons have achieved the status of super-generic commands, and it's highly recommended that you use them if your application has player-style functionality.
Unfortunately, the iPod user experience is degraded by poor attention to detail in the generic-command design. For example, in the photo player, the player buttons don't move as you turn the tablet, making the "play" button look like an upward-pointing triangle in the horizontal orientation. In the music player, horizontal orientation removes most of the buttons and changes the play button's appearance (putting it inside a circle). Of the three applications, only the Web browser treats the play commands correctly when you turn the tablet.
Generic commands give users increased power without increasing user-experience complexity. But, to be truly generic, such commands must be available everywhere in your user interface.
Share this article: Twitter | LinkedIn | Google+ | Email