Shneiderman’s Eight Golden Rules
Get introduced to Shneiderman’s eight golden rules of interaction design.
“A picture is worth a thousand words. An interface is worth a thousand pictures”
–Ben Shneiderman–
Shneiderman’s eight golden rules are heuristics that are applicable to most design situations. They cover all the important principles of the interface design we studied in the previous lesson. These eight golden rules are as follows:
Note: Try to relate these principles to the abstract usability principles we studied in the last lesson.
Strive for consistency
Similar situations should have consistent sequences of actions. Colors, font, style, layout, etc. should be consistent throughout the interface. The information displayed should be consistent as well. Confirmation notifications and other exceptions should be limited in number and understandable.
Here is an example of an online shopping website. An item has been added to the cart but the cart icon on the top right corner still displays zero items in the cart. This is not consistent.
Seek universal usability
The design should facilitate the needs of diverse users. The difference between users can be their expertise level, disability, age range, region, and more. In order to increase design usability, facilitate novice users with instructions and explanations, and expert users with abbreviations, shortcuts, faster pacing, etc.
A very common example is the use of shortcuts. For example, Google Docs offer three alternative ways to copy/cut/paste a text, targeting users from novice to experienced. These methods include key shortcut methods, a context menu brought up by a right mouse click, and from the top bar menu.
Offer informative feedback
The system should provide informative feedback for every action. It should be moderate and simple for frequent, simple, and minor actions. On the other hand, it should be substantial and considerable for infrequent, complex, and major actions.
For example, when a user deletes emails from Gmail inbox, they are moved to the trash, and a message to undo the action is displayed for a short period of time. This step is reversible and has less severity, hence, modest feedback is displayed. But when deleting emails from the trash, a more substantial message is displayed and it stays until the user responds to it, as this action is not reversible and carries a higher severity level.
Design dialogs to yield closure
The system should provide informative feedback at the completion of a task. This reduces the
For example, an online shopping website notifies the user when an item has successfully been added to the cart and provides the user further action, i.e. to continue shopping.
Prevent errors
In the first place, designers should design an interface that prevents the user from making errors. If the user makes a mistake, the system should provide clear and informative feedback for recovering from the mistake. Mistakes and errors should not change the system state. If it does change, informative feedback should be provided to restore the state. For example, the system should ask the user before deleting a file to prevent error.
Permit easy reversal of actions
The system should offer reversal of as many actions as possible. This helps the user to explore the system freely and without the fear of making irreversible mistakes.
For example, Gmail has a feature to undo a sent mail within a specific time duration. This allows the user to simply unsend a wrong or incomplete email and fix it rather than sending another email.
Support internal locus of control
Keep the user in control of the interaction. The system should allow the user to initiate actions. This gives the user the sense that they control the actions. Text editing applications like Google Docs or Microsoft Word are good examples where almost all actions are initiated and controlled by the user throughout the interaction.
Reduce short-term memory load
Recall the STM rule we studied in the human memory lesson, which states that humans can remember 7±2 chunks of information.
The human STM has limited capacity to process information so the design should not require the user to remember lots of information during the interaction. The interface should not require the user to remember the information from one display and then use it on another display. For example, a command line interface requires users to remember commands, files paths, etc. to perform actions. On the other hand, menus do not require users to remember these details, which reduces the load on their STM.