In his book “The Essentials of Interaction Design”, Alan Cooper shares a lot of design principles which, if followed, can enhance your application by significantly improving user experience. For this post, we have selected 10 key principles, which we never forget in the development process.
1. Imagine users as very intelligent but very busy.
As an interaction designer, it’s best to imagine that users are simultaneously very intelligent and very busy. They need some instruction, but not very much, and the process has to be rapid and targeted. If a ski instructor begins lecturing on snowpack composition and meteorology, he will lose his students regardless of their aptitude for skiing. Just because a user needs to learn how to operate a product doesn’t mean that he needs or wants to learn how it works inside.
2. Don’t make the user feel stupid.
“Good design” has meaning only for a person using a product for some purpose. You cannot have purposes without people. The two are inseparable. This is why personas are such an important tool in the process of designing behavior; they represent specific people with specific purposes or goals. We can reliably say that we make the user feel stupid if we let her make big mistakes, keep her from getting an adequate amount of work done, or bore her. This is probably the most important interaction design guideline. The essence of good interaction design is devising interactions that achieve the goals of the manufacturer or service provider and their partners without violating the goals of users.
3. Provide choices, don’t ask questions.
Contrary to what many software developers think, questions and choices don’t necessarily make users feel empowered. Asking users questions makes them feel irritated or inferior. Dialogue boxes (confirmation dialogues in particular) ask questions. Toolbars offer choices. The confirmation dialogue stops the proceedings, demands an answer, and it won’t leave until it gets what it wants. Toolbars, on the other hand, are always there, quietly and politely offering up their wares like a well-appointed store, giving you the luxury of selecting what you would like with just a flick of your finger.
4. Allow input wherever you have output.
Many applications have one place where the values (such as filenames, numeric values, and selected options) are displayed for output and another place where user input to them is accepted. This follows the implementation model, which treats input and output as different processes. A user’s mental model, however, doesn’t recognize a difference. He thinks,”There is the number. I’ll just click on it and enter a new value.” If the application can’t accommodate this impulse, it is needlessly inserting excise into the interface. If options are modifiable by a user, he should be able to do so right where the application displays them.
5. If it’s worth the user entering, it’s worth the application remembering.
Any time your application finds itself with a choice, and especially when that choice is being offered to a user, the application should remember the information from run to run. Instead of choosing a hard-wired default, the application can use the previous setting as the default, and it will have a much better chance of giving a user what he wanted. Instead of asking a user to make a determination, the application should go ahead and make the same determination a user made last time, and let her change it if it was wrong. Any options users set should be remembered, so that the options remain in effect until manually changed. If a user ignores aspects of an application or turns them off, they should not be offered again. The user will seek them out when and if he is ready for them.
6. Take things away until the design breaks, then put that last thing back in.
Unnecessary variation is the enemy of a coherent, usable design. If the spacing between two elements is nearly the same, make that spacing exactly the same. If two typefaces are nearly the same size, adjust them to be the same size. Every visual element and every difference in color, size, or other visual property should be there for a reason. If you can’t articulate a good reason why it’s there, get rid of it. Good visual interfaces, like any good visual design, are visually efficient. They make the best use out of the minimal set of visual and functional elements. A popular technique used by both graphic designers and industrial designers is to experiment with the removal of individual elements in order to test their contribution to the clarity of the intended message.
7. Save documents and settings automatically.
Applications should automatically save documents. For starters, when a user is done with a document and requests the Close function, the application should go ahead and write the changes out to disk without stopping to ask for confirmation with the Save Changes dialogue box. It’s important that this automatic save function be performed in such a way as to not affect the responsiveness of the user interface. Saving should either be a background function, or should be performed when the user has stopped interacting with the application. Nobody types continuously. Everybody stops to gather his thoughts, or flip a page, or take a sip of coffee. All the application needs to do is wait until the user stops typing for a couple of seconds and then save.
8. A dialogue box is another room; have a good reason to go there.
If we imagine our application as a house, each window is a separate room. The house itself is represented by the application’s main window, and each room is a pane, document window, or dialogue box. We don’t add a room to our house unless it has a purpose that cannot be served by other rooms. Similarly, we shouldn’t add windows to our application unless they have a purposes that can’t or shouldn’t be served by existing windows. It’s important to think through this question of purpose from prospective users’ goals and mental models. The way we think about it, saying that a room has a purpose implies that using it is associated with a goal, but not necessarily with a particular task or function.
9. Make errors impossible.
Making it impossible for users to make errors is the best way to eliminate error messages. By using bounded widgets (such as spinners and drop-down list boxes) for data entry, we can prevent users from entering bad numbers. Instead of forcing a user to key in his selection, present him with a list of possible selections from which to choose. Instead of making a user type in a state code, for example, let him choose from a list of valid state codes or even from a picture of a map. In other words, make it impossible for the user to enter a bad state.
10. Do, don’t ask & Make all actions reversible.
Three design principles provide a way to eliminate confirmation dialogue boxes. The best way is to obey the simple dictum: Do, don’t ask. When you design your software, go ahead and give it the force of its convictions. Users will respect its brevity and its confidence. Of course, if an application confidently does something that a user doesn’t like, it must have the capability to reverse the operation. Every aspect of the program’s action must be undoable. Instead of asking in advance with a confirmation dialogue box, on those rare occasions when the program’s actions were out of turn, let the user issue the Stop-and-Undo command.
More on Interaction Design
To learn more about the design principles we use in our work, click here.