Monkeys at the Keyboard

Up to the early nineteen-eighties, most computers were like supertankers. They were large and expensive, they served an extremely specific purpose, and only highly trained operators could use them. In those days, computer designers didn't much care about computer users because the very idea of users as distinct from designers was unthinkable. That's all changed now. Today, computing power is cheap and widespread, and users far outnumber designers and builders. Perceptions within the computer industry, however, haven't changed much with the times. Computer people still force computers to behave much as they did in the fifties. Consequently, the computer's users---you and me---have to jump through all sorts of unnecessary hoops.

For example, imagine that you're using a computer program that's patiently waiting for you to give it a word. Suppose the word you have in mind is `Stradivarius,' but you actually give it a small misspelling, say, `Stadivarius.' Most of us would know exactly what you meant. Typically, though, the program wouldn't have a clue.

As far as it's concerned, `Stadivarius' is as close to `Stradivarius' as it is to `strawberry' or `couch' or `waffle iron' or anything else that isn't exactly `Stradivarius.' Today's computer programmers apparently assume that we're monkeys using the computer. They apparently assume that everything we say---unless it's exactly what they want us to say---is equally arbitrary.

If the program had a rough idea of the nearness and farness of words, however, it could save you time and trouble Then when you say `Stadivarius' because you're in a hurry, or because you're dyslexic, or because you don't remember exactly how to spell the word, or because you just spilled orange juice on your computer, or for whatever reason, the program might have a chance of figuring out what you probably meant.

Not only would that lower your blood pressure because it lets you be less insanely careful, but it would also give the programmer the chance of letting the program notice errors you make regularly by seeing how close they come to what you actually intended. Perhaps it could even start noticing patterns in the kinds of errors you make. Maybe it might even start noticing when you're most likely to make those errors. Maybe it's just before lunch that your attention starts flagging, or perhaps it's just after lunch when you start to feel drowsy, or perhaps it's when you're using an especially tricky part of the program.

Or again, say you're issuing a complex command and you make an error when specifying one part of the command. Most of today's computer programs would simply beep, forcing you to reissue a corrected version of the command. As you reissue the command, however, you're justifiably a little annoyed at having to be bothered, so you don't make the original error, but you now make an error in another part of the command. The program again beeps, issuing some fairly meaningless error message.

So once again you issue the command, but this time you do the human thing and focus only on the part that caused you trouble last time, completely forgetting the rest of the command. As far as you're concerned, you've clarified your meaning completely because you're used to talking to people. Based on the context, they would usually understand exactly what you mean. Alas, since this third version of the command is incomplete, the program beeps for the third time, and your blood pressure soars.

Why couldn't the computer see that if you mess up a command the very next thing you're likely to do is to repeat the command? Further, why doesn't it know that if you mess up one part of a command, you're likely to focus only on that part when you repeat the command? If it kept at least that much context, it would know enough to compare the first two command versions you issued and perhaps be able to extract the correct form of the command you intended.

Most computer programs aren't that forgiving---partly because their programmers can't be bothered, and partly because they think it's too hard. And sometimes it is, but often it isn't.

We all blunder while using our computers---programmers included. And when the computer beeps at us, all we can do is curse, because to us it's obvious what we want done---given the context of our previous work. Why can't the computer figure it out too?

If you ask programmers that question they usually say that the computer isn't very smart. It's a mere machine, they say with a superior chuckle, so you simply have to grin and bear it. They're just hoping you'll go away. What they've forgotten---or what they hope you don't know---is that all the smarts the computer has they've given it.

Now, many kinds of errors really do require a very smart helper to interpret what you really meant---that's why lawyers can charge so much---but many others aren't that hard to figure out. The computer's programmer could let the computer recover a lot of what we mean just by keeping in mind that we usually have goals when using it, we're not just fooling around. We have particular problems to solve, and we always establish contexts to do that in. We aren't monkeys at the keyboard. Alas, today's programmers prefer to emphasize the letter of the law, rather than its spirit. It makes their job easier, at least in the short term. They still seem to think of computers as supertankers.