One of the most fundamental things about being human is making numerous errors. The cause of these errors may vary — some occur due to insufficient knowledge (like not knowing what a button on an interface does and using it erroneously), others are due to wrongly applying an action rule to a situation that calls for a different one (like seeing a traffic light turn green and moving your vehicle to turn, while a pedestrian is on the crosswalk); and sometimes, we mess up even when we have the knowledge and apply the correct rule (like making typos while texting or turning on the wipers instead of the turn signal).
Some of these errors are funny, others irritating, and a few are downright dangerous. Whereas a lot of time and effort is spent on reducing errors, either through training or replacement by machines, it is difficult to envision a human world that is completely free from error. However, as designers, we may be able to immunize our interfaces and systems from error in some cases. Listed below are some ways to do so:
1. Minimize Perceptual Confusions
Controls intended to perform different functions must be made distinct from each other to reduce the chance of users mistakenly using the wrong one. Discernibility can be added in many ways, from using different colors and shapes to spatially separating the controls, making the controls feel different, or even using different control motions. For example, in your car, the stalk behind the steering wheel performs several functions. But, the turn signals are controlled using a different motion than turning on the headlights. This makes it difficult for a driver to mistakenly turn on the headlight instead of the turn signals. However, many of us have mistakenly turned on the wipers instead of the turn signals before, because both functions are executed by the same control motion.
2. Use system constraints to “lockout” errors
When common error points are known — whether after analyzing a new system or from a preexisting system now being redesigned — certain safeguards against those errors can be implemented. For example, certain applications ask users to perform verification actions once or twice before permanently deleting a file.
3. Offer reminders
Many errors occur due to lapses of memory. For example, forgetting to turn on the alarm before going to sleep or forgetting to take your car in for its scheduled service. To account for these types of errors, designers can build reminders into the system, like having the car remind its user about maintenance by turning on a light on the dashboard or having the phone remind the user to turn on the alarm around bedtime.
4. Account for multimode systems
In multimode systems, the same control actions often mean different things depending on which mode the system is in. A simple example would be lending an angry tone to an innocuous text by mistakenly sending it in all CAPS. In this case, the user committed a mode error because they forgot that the keyboard was in CAPS Lock mode. The easiest way to avoid these errors would be to not design a multimode system at all, but often this is not possible. For example, it is difficult to design a keyboard without different modes such as CAPS lock, emoji, or symbols. In such cases, what designers can do is to make the indication of a mode change as salient as possible, so the user is cognizant of the fact that the system mode has changed.
Human users and operators lead to many gains in terms of flexibility and creativity. Unfortunately, in the process, humans also commit errors. An understanding of why and how these errors happen has led to an acceptance that errors are inevitable. However, we can improve our designs to make them more tolerant of these errors, hopefully alleviating some human frustration along the way!