, as well as for speech
input (Marx & Schmandt, 1994), pen input (Goldberg & Goodisman, 1991),
and a mixture of the two (Suhm et al., 1996b).
Once a mistake has been identified, the system can take action to correct it, or ask the user's help in correcting it (through some sort of error handling interface). Alternatively the system can support error handling in an integrated fashion. For example, the interactive beautification system shown in Figure 2A displays alternatives after every stroke. The same interface also supports notification --if the user selects an alternative, the system can infer that the original default was wrong and the alternative is correct.
Most of the tasks being supported require the selection of a single correct interpretation of user input (one exception to this is search engines, which may have multiple correct responses). One important choice facing the designer of error handling techniques is how active the system should be in selecting this interpretation. Essentially, the designer must choose whether to accept the most certain choice by default, or to wait for user confirmation. The first part of this section discusses where each choice has shown up in the literature, and why. The remaining parts discuss two commonly used techniques for error handling, encouraging less ambiguous input, and mimicking natural human correction strategies.
The number of answers returned by an error prone system is often larger than the number of answers expected by the user. This leaves the interface designer with the choice of selecting none of the answers, or selecting one (or more) of the answers as ``correct'' by default. For example, the drawing understanding system mentioned above selects one line by default (shown bold in Figure 2A) (Igarashi et al., 1997). The interface designer should use information about the probability of correctness and the overhead for correcting a mistaken choice of default to decide when it is appropriate to choose a default. In the case of the drawing understanding system, the interface is designed so that the user does no more work when the system selects a default than when it doesn't. And if the system selects the correct choice, the user does less work (since they don't have to select it themselves before they continue drawing).
An example of a system which does well to select nothing by default is Rhodes & Starner's (1996) remembrance agent. The remembrance agent retrieves documents based on their relevance to the current text in an editor. Rather than immediately displaying the most relevant document, it has a small permanent window where it shows a single line from each of three potentially interesting documents. Actually selecting a document and displaying it would be far more invasive, difficult to correct, and often not what the user wants. Even if the system has found relevant documents, the user may not want to be interrupted in order to read them.
Word prediction systems also demonstrate why the designer may choose not to select a default. If, for example, the system assumes its top prediction is correct, it will insert it. But word prediction is a particularly difficult task in which the top choice is often wrong. And it will most likely take more keystrokes for the user to delete the mistake and continue typing than it would to have simply typed the whole word out in the first place, especially if similar mistakes happen automatically after every character typed.
Even when it is appropriate to choose a default for the user, this choice may be wrong, and because of this the user interface needs to support error correction. One way to support this is to display alternatives from which the user can select a correct choice. Another approach is to unobtrusively provide ways to change the default without necessarily displaying alternatives. For example, Goldberg & Goodisman (1991) suggest using a simple gesture (a tap) to select the next choice. As another example, consider the Tivoli system in which some inputs are interpreted as gestures and others simply as ink to be drawn on the screen (Moran et al., 1997). If a user draws a gesture which could trigger an action, such as ``move'', the system by default assumes that the action is intended (and not simply drawing on the screen). However, if the user doesn't follow through (by selecting an object to move in this case), Moran et al. automatically undo it, replacing it instead with its alternate interpretation as plain ink.
Certain modes of input are known to be less error prone than others
(compare typing to handwriting recognition), and there are times when
it is appropriate to make use of this fact. For example, Suhm found
that recognition accuracy actually decreases by 10-65% during
this sort of error repair in a speech recognition system
(Suhm, 1997). One option is for the computer to offer a less
ambiguous input method as an alternative. This technique has been
used effectively in the Apple MessagePad , as well as for speech
input (Marx & Schmandt, 1994), pen input (Goldberg & Goodisman, 1991),
and a mixture of the two (Suhm et al., 1996b).
Alternatively, an interface designer may choose to encourage a less
error prone input from the outset. For example, the designers of the
PalmPilot chose to use a unistroke alphabet
(Goldberg & Richardson, 1993). It is easier to recognize unistrokes
than to recognize handwriting because there is no possibility of
segmentation errors since each letter is exactly one stroke (pen up to
pen down). In another example, Goldberg & Goodisman (1991)
suggest using on-screen marks (boxes) to reduce segmentation errors
and discourage cursive handwriting.
Several researchers have made use of a human's tendency to mimic the output of whatever they are communicating with. Zoltan-Ford (1991) found that people will mimic sentence structures of the computer's responses, something that helps to make natural language processing easier. Kurtenbach et al. (1994) investigated the use of crib sheets which display gestures for a user to copy. The user can request an animation of a command by clicking on its picture on the crib sheet. Crib sheets have also been found to successfully improve recognition in a character recognition system (Wolf, 1990).
Although computers are a major source of errors, humans also make mistakes. Both experience and research have shown that humans already have ways of correcting mistakes. They may cross out a letter or add another letter or word to what they just wrote. When they mis-speak, they may pause, or repeat the correct word; with or without the addition of non-speech audio cues to indicate an error. These are what we call `natural' correction strategies.
These ``corrections'' are so natural that users may do them even though most recognizers don't know how to interpret the corrections. Huerst et al. (1998) have experimented with a handwriting pre-processor which looks for and applies these corrections before sending handwriting to the recognizer. Essentially what the user is doing in this strategy is correcting their original input in its original form, perhaps even in the midst of entering it. This is done with handwriting, speech, and more novel types of input. For example, we support this strategy in our unistroke keyboard (Mankoff & Abowd, 1998). BrennanHulteen:95 work in applying linguistic research to interface design (described above in the section on Error Discovery) also demonstrate the usefulness of mimicking humans. One human strategy which they don't mimic is the pause. However, the questions of when and how long to pause have been investigated by several researchers (Aref et al., 1995; Kato & Nakagawa, 1995; Lopresti & Tomkins, 1995; Kurtenbach, et al., 1994).
For example, Kurtenbach et al. (1994) use a pause to allow a user to request guidance when drawing a gesture. Each gesture is really a selection from a pie menu, which is only displayed if the user pauses (these gesture sets are called marking menus). A pause can also be used to support delayed, or lazy recognition. Schomaker (1994) suggests echoing the input in the case of ``invisible'' commands such as gestures. The system could then provide a moment in which the user can act to undo a command before it becomes permanent.