10 Heuristics Flashcards
Visibility of system status.
The system should provide feedback, in a timely manner, to tell users what’s going on and to acknowledge user interaction to let them know if an interaction was successful or not.
This reduces uncertainty by showing a user that the system is working and makes a system feel reliable and predictable and the user feels in control of the system, which in turn creates trust.
Decide what information a user needs to know and how to deliver it in a timely manner. (progress bars, messages, color, shape and position changes)
Match between system and the real world
Related to “You are not your user”.
The system should speak the users’ language, with words, phrases and concepts familiar to the user, rather than system-oriented terms. Follow real-world conventions, making information appear in a natural and logical order.
User control and freedom:
Users often choose system functions by mistake and will need a clearly marked “emergency exit” to leave the unwanted state without having to go through an extended dialogue. Support undo and redo.
Consistency and standards:
Words, features, symbols, etc. should be used in the same way throughout the product. This makes a system predictable and learnable. Users should not have to wonder whether different words, situations, or actions mean the same thing.
Internal consistency: Refers to the consistent use of conventions within your site, such as colors and fonts.
External consistency: Means the ui is consistent with convention. Jacobs law states that users spend most of their time on websites other than yours, which means that making your ui consistent with conventions used on other sites the user is already familiar with, makes it easer to for users to use your site.
5: Error prevention
Even better than good error messages is a careful design which prevents a problem from occurring in the first place. Either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
Design the system so users are unable to make mistakes—or at least make users confirm before allowing them to do something that’s prone to mistakes.
The term “user error” implies that the user is at fault for having done something wrong. Not so. The designer is at fault for making it too easy for the user to commit the error. Therefore, the solution to user errors is not to scold users, to ask them to try harder, or to give them more extensive training. The answer is to redesign the system to be less error prone.
Error prevention
Even better than good error messages is a careful design which prevents a problem from occurring in the first place. Either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
Design the system so users are unable to make mistakes—or at least make users confirm before allowing them to do something that’s prone to mistakes.
The term “user error” implies that the user is at fault for having done something wrong. Not so. The designer is at fault for making it too easy for the user to commit the error. Therefore, the solution to user errors is not to scold users, to ask them to try harder, or to give them more extensive training. The answer is to redesign the system to be less error prone.
2 types of errors and how to avoid them
Slips
Slips occur when users intend to perform one action, but end up doing another (often similar) action. For example, typing an “i” instead of an “o” counts as a slip; accidentally putting liquid hand soap on one’s toothbrush instead of toothpaste is also a slip. Slips are typically made when users are on autopilot, and when they do not fully devote their attention resources to the task at hand.
Prevent slips by: helpful constraints, offering suggestions, good defaults, use forgiving formats.
Mistakes
Mistakes occur when a user has developed a mental model of the interface that isn’t correct, and forms a goal that doesn’t suit the situation well For example, if I misunderstood the meaning of the oil-pressure warning light in my car, and thought it was the tire-pressure monitor, no matter how carefully I added air to my tires, it would not fix the issue with my oil pressure. This would be a mistake, since the goal that I was attempting to accomplish was inappropriate for the situation, even though I made no errors in executing my plan. Mistakes are conscious errors, and often (though not exclusively) arise when a user has incomplete or incorrect information about the task, and develops a mental model that doesn’t match how the interface actually works. It often is the result of a mismatch between the developer and the user’s mental models
Preventing errors:
- User research to understand user mental models,
- follow design convention,
- Communicate affordances,
- Preview results
- Use confirmation dialogues, -warnings,
- undo buttons,
- placement and colors of buttons,
- remove memory burdens etc.
Recognition rather than recall
When the user is likely to need a feature, make it visible to them in order to reduce the load on their memory in trying to remember the thing. Minimize the user’s memory load by making objects, actions, and options visible. The user should not have to remember information from one part of the dialogue to another. Instructions for use of the system should be visible or easily retrievable whenever appropriate
Flexibility and efficiency of use:
Make things easy for new users, but also give experts a way to do things fast. Accelerators(like shortcuts) can be used to allow expert users to speed up their interaction. Alternate methods for accomplishing a frequent action in a user interface support expert users by speeding up their interactions, without hindering novices.
Balancing learnability with productivity
Common accelerators:
• Keyboard shortcuts (drop down menu)
• Macros
• Touch gestures (hints)
Aesthetic and minimalist design Don’t overwhelm
users with unnecessary or irrelevant information. Dialogues should not contain information which is irrelevant or rarely needed. Every extra unit of information in a dialogue competes with the relevant units of information and diminishes their relative visibility.
Signal to noise ratio is the ratio of relevant to irrelevant information. Anything that users have to process could count as either signal or noise. You should aim for high signal to noise ratio
Communicate. Don’t decorate
Help users recognize, diagnose, and recover from errors
Error messages should be straightforward, actionable and in plain language. They should be explicit, human readable, polite, precise and offer constructive advice.
- Inform user of errors
- Tell user what the problem is
- Offer users a solution, (reduce the work: offer shortcuts and preserve user’s work: undo/restore)
- Use as an opportunity to educate users (links can be used to link to page with additional background experience)
Help and Documentation
If possible, make the system intuitive so it can be used without help; Even though it is better if the system can be used without documentation, it may be necessary to provide help and documentation. Any such information should be easy to search, focused on the user’s task, list concrete steps to be carried out, and not be too large.
Using popups with suggestions can be a great way to help users learn the system
5 steps in performing a heuristic evaluation
- Find 3–5 experts. These should be people who know about usability principles and are familiar with the product.
- Come up with heuristics as a team. You can adapt Nielsen’s heuristics to fit your product.
- Identify tasks. What are the critical user journeys? For example: For an online shopping site, one critical user journey could be how to purchase an item.
- Conduct individual evaluations. Have each expert evaluate the design separately. You can use a spreadsheet or a doc to track all the issues. List out each issue and identify how severe it is. For severity, you can use a point-system (5 is super severe, 1 is not really an issue) or use “critical” “major issue” “minor issue” and “cosmetic issue”.
- Aggregate results. Pool the results from the individual evaluations. What does the team agree on?
Why is recognition easier than recall?
Often psychologists think of memory as organized in chunks: basic interconnected units. Each chunk can be described by its activation: a measure of how easily that chunk can be retrieved from memory. For example, your name is a chunk in memory; it has very high activation — if someone woke you up in the middle of the night and asked you what your name was, you’d be able to produce it fairly quickly. On the other hand, if you had to remember the name of your first-grade teacher, that answer would likely be harder to come up with: its activation is lower.
The activation of a chunk is influenced by three different factors:
• Practice: how many times a chunk has been used in the past
• Recency: how recently a chunk has been used
• Context: what is present in the person’s focus of
attention.
The big difference between recognition and recall is the amount of cues that can help the memory retrieval; recall involves fewer cues than recognition.
Answering a question such as Did Herman Melville write Moby Dick? involves recognition: you simply have to recognize whether the information provided is correct. If instead I asked you Who wrote Moby Dick? you would use a process of recall to retrieve the right answer from your memory.
Recognition is easier than recall because it involves more cues: all those cues spread activation to related information in memory, raise the answer’s activation, and make you more likely to pick it. It’s the reason for which multiple-choice questions are easier than open questions, where the respondent has to come up with an answer.
10 Heuristics
- Visibility of system status
- Match between system and the real world
- User control and freedom
- Consistency and standards
- Error prevention
- Recognition rather than recall
- Flexibillity and efficiency of use
- Aesthetic and minimalist design
9 Help users recognize, diagnose and recover from errors - Help and documentation
