There are many things that can cause users frustration and annoyance with software. In the previous post, we discussed some “do’s” for creating a positive user experience. Let’s now consider some “don’ts” that can create a negative user experience.
Some usability problems can be seen as violations of design principles. Here is how violating Donald Norman’s principles of usability can impair the user experience:
- Lack of consistency: An interface that exhibits inconsistencies in visual layout, labelling, behavior, etc. makes it harder for users to detect and learn patterns and form mental models. Inconsistencies force users to memorize and remember exceptions to rules, increasing the cognitive load.
- Poor visibility of controls: Frustration and lost productivity can result when users can’t locate the controls they are looking for, or when users are looking for means to carry out actions but cannot find appropriate controls.
- Poor affordance cues for controls: When controls don’t give visual clues as to how they can be operated, users must figure out what the controls do by means of time-consuming trial-and-error. Some controls may not even be perceived as controls, and some functionality may be “hidden” when the user cannot discover the means of activating it (for instance, a user may not realize that a context menu can be opened by right-clicking on an icon).
- Poor mapping cues for controls: When controls don’t clearly indicate what actions they perform, confusion can result when behavior does not match users’ expectations, or when users cannot find appropriate controls for actions they want to perform.
- Insufficient feedback: Without prompt and clear feedback, the user can be left wondering whether a control was properly activated and whether the action was successfully performed.
- Lack of constraints: Without constraints, users may be able to perform invalid operations, use controls in invalid ways, or enter invalid data. These problems can cause the system to enter an unstable, unpredictable state.
There are many other general problems that can contribute to a poor user experience. For instance:
- Unreliability, bugginess, flakiness, and instability: If the software crashes, or exhibits unpredictable behavior, it impairs the user’s trust in the software. The user may fear losing his work or having his data corrupted. The user has to waste time discovering and applying workarounds to avoid bugs.
- Poor performance: Lag, latency (delayed responses), and excessively long processing times are annoying and jarring because they interrupt the flow and rhythm of work.
- Disorganized, cluttered, or otherwise unappealing visual design: Unaesthetic, crowded, and poorly-designed screen or page layouts make it hard to find things, and are just simply depressing to look at.
- Conceptual model mismatching the user’s model: If the product’s view of the world or the domain (including things like terminology and processes) doesn’t match what users already understand, then users will have a hard time learning and conforming to the product’s alien way of thinking.
- Behavior not meeting expectations: Users can become disappointed when the product doesn’t work the way they expect.
- Excessive complexity: Too many steps and options and settings for seemingly simple tasks can be overwhelming. Complex products are harder to learn, and error rates will be high because users are more likely to make mistakes. The difficulty can cause the user to feel inadequate, incompetent, and embarrassed.
- Too much work: Users resent products that make them carry out repetitive, mundane tasks that could have been automated.
- Too much thinking: The product makes the user think too hard to figure out how to do things.
- The product makes it tedious or impossible to produce good quality output: For example, one diagramming tool I’ve used has no way to ensure that elements are aligned, and allows elements to be moved by two or more pixels, but not by one pixel, making it extraordinarily difficult and painstaking to create diagrams with aligned elements.
- The work that the product does is of low quality: For example, a paint program may render unaliased, “jagged” fonts, or a software development tool may generate code that doesn’t compile.
- Error correction is tedious: People make mistakes, and it shouldn’t be an ordeal to correct them.
To find usability problems such as the above, you should conduct usability testing on your designs, your prototypes, or your actual product. User observation is the most reliable way to discover where your users will have difficulties with your application.