Given that 99% of all usability problems related to response times are caused by user interfaces being too slow, it might be dangerous for me to write about those few cases where the computer is too fast. After all,
computers are usually too slow, and
snappy response times enhance usability. Human memory decays rapidly, so people might forget some of what they were doing while waiting for a slow computer.
Further, while young users are notoriously impatient, even older users won’t linger long on a slow site.
Caveats enough, I hope; a snappier user experience is almost always better.
That said, there is such a thing as too fast. My latest example came a few days ago when we were user-testing tablet applications for the next update of our courses on Mobile Apps for Touchscreens and Visual Design for Mobile and Tablet: The user repeatedly failed to connect to the correct WiFi network, because she repeatedly touched the wrong entry in the list.
Making such a mistake once might be excused as an example of the inherent problem in gestural interfaces — that people sometimes touch a spot that’s a bit off the target.
But this user hit the wrong target several times. Why? The intended target kept moving without her noticing it because the tablet was continually scanning the airwaves and adding or removing entries on its list of available WiFi networks.
The interaction went as follows:
The user scanned the list to locate the intended network (for which she had the proper login info).
She started moving her hand toward the target, intending to touch the line for the network found in step 1.
During the fraction of a second that her finger was moving toward the tablet surface, the list would gain or lose an entry, causing the intended target to jump to a different place on the screen.
The user selected a different target than intended because the new network was now occupying the spot of the one she wanted (and she didn’t notice that she was touching the wrong name because her finger obscured the target).
The user attempted to log in to the selected network, but was refused because she was using credentials from a different network.
Although these steps occurred in rapid succession, the poor user repeated the exact same sequence so many times that I figured out what was happening without needing to replay the usability video.
(Of course, obeying a basic tenet of usability testing, we couldn’t tell the unfortunate test participant what she was doing wrong; we had to sit in silence and watch her fail repeatedly until she finally got lucky enough to select the network during a period in which the WiFi software didn’t detect any updates to the list.)
Fast Might Be Missed
When the screen changes in the proverbial blink of an eye, users might blink and miss the change. Or, as in my WiFi example, they might not be looking at that particular part of the screen during the brief interval in which the change occurs.
When changes happen on their own — without any user prompting — people don’t even know to look for them and are likely to miss things that change rapidly. To alleviate this problem, one useful tactic is to slow down the change, using, for example, an animation that lasts a second or two. But don’t over signal; there’s nothing more annoying than an aggressively blinking screen.
Rapid screen updates are great when they’re the result of user-initiated actions. When you touch a slider on a tablet, for example, you want it to highlight immediately to indicate that it has been activated. And, as you move the slider, you want the corresponding screen elements to update immediately.
As long as users do something, they know to look for the result. But even in these cases, there’s a potential usability issue if the update is far removed from the action. Changes outside the user’s field of vision might be overlooked and require stronger signaling than simply replacing the old information with something new. A classic example is e-commerce shopping carts that are positioned in the screen’s far corner and simply count up when the user clicks Add to Cart. In testing, we often find that users overlook such subtle updates when they occur far away from the button they clicked.
Fast Might Be Difficult
A second class of usability problems occurs when users do notice a rapid change, but can’t understand what happened quickly enough. This often happens in carousel, rotators, and other auto-forwarding design elements. Once you decide that something might be of interest, it’s yanked off the screen — replaced by something you don’t want.
This is particularly problematic for slower users, such as international customers who don’t read your language well or old or disabled users who might need extra time dealing with the user interface and are thus disproportionally harmed by rapidly changing screens.
Let’s establish a simple usability principle: avoid taunting the customers.
And, to circle back to the beginning, it’s important to remember that, as problems go, being too fast is far less common than being too slow. Whether fast or slow, the point is to pay attention to the time aspect of the user experience. After all, a key differentiator of interaction design compared to most other forms of design is that we deal with time-changing phenomena.