What Makes Software Polite?


Humans have many wonderful characteristics that make them "polite" but whose definitions are fuzzy and imprecise. Nass and Reeves say that the "four basic principles that constitute the rules for polite interaction [are] quality, quantity, relevance, and clarity." Those are good but a little too vague to be helpful. Here is my list of what improves the quality of interaction, either with a human or a high-tech, software-based product rich in cognitive friction.

Polite software is interested in me

Polite software is deferential to me

Polite software is forthcoming

Polite software has common sense

Polite software anticipates my needs

Polite software is responsive

Polite software is taciturn about its personal problems

Polite software is well informed

Polite software is perceptive

Polite software is self-confident

Polite software stays focused

Polite software is fudgable

Polite software gives instant gratification

Polite software is trustworthy

Polite Software Is Interested in Me

A friend would ask about me and be interested in who I am and what I like. He would remember my likes and dislikes so he could please me in the future. Any supportive service provider would make an effort to learn to recognize the face and name of her customers. Some people appreciate being greeted by name and some don't, but everyone appreciates being treated according to his own personal tastes.

Most software doesn't know or care who is using it. In fact, none of the personal software on my personal computer seems to remember either me or anything about me. This is true in spite of the fact that it is constantly, repetitively, and exclusively used by me. Larry Keeley jokes that the automatic-flush urinal in an airport bathroom is more aware of his presence than his desktop computer is.

Every bit of my PC's personal software should work hard to remember my work habits, and particularly, everything that I say to it. To the programmer writing the program, it's a just-in-time information world, so whenever the program needs some tidbit of information, it simply demands that the user provide it. But the thoughtless program then discards that tidbit, assuming that it can merely ask for it again if it ever needs it. Not only is the computer better suited to doing the remembering, but it is impolite for it to forget.

For example, there are 11 people named Dave in my email program's name-and-address directory. I rarely communicate with most of them, but they include my best friend Dave Carlick, to whom I send email all of the time. When I create a new email and type an ambiguous "Dave" in the TO: block, I expect the program to have learned from my past behavior that I mean Dave Carlick. If I want to send something to another Dave David Fore, for example I'll type in "Dave F," "D4," "David Fore" or something else to indicate my out-of-the-ordinary choice. Instead, the program behaves stupidly, always putting up a dialog box and making me choose which of the 11 Daves I mean. The program just doesn't care about me and treats me like a stranger even though I'm the only human it knows.

Polite Software Is Deferential to Me

Any good service person defers to her client. She understands the person she is serving is the boss, and whatever the boss wants, the boss should get. When a restaurant host shows me to a table in a restaurant, I consider his choice of table to be a suggestion, not an order. If I politely demur and choose another table in an otherwise empty restaurant, I expect to be accommodated immediately. If the host refuses, I am likely to walk out and choose another restaurant where my desires take precedence over the host's.

Impolite software supervises the assumed-to-be-incompetent human's actions. It's okay for the software to express its opinion that I'm making a mistake, but it is not okay for it to judge my actions. Likewise, it is all right for software to suggest that I cannot "submit" my entry until I've entered my Social Security number, but if I go ahead and "submit" without it anyway, I expect the software to do as it is told. (The very word submit and the concept it stands for are a reversal of the deferential role. The software should submit to the user, and any program that proffers a Submit button is, ipso facto, impolite. Take notice, most every active site on the World Wide Web.)

Polite Software Is Forthcoming

At the airport, if I ask an airline employee at which gate I can find Flight 79, I would expect him not only to answer my question, but also to volunteer the extremely useful collateral information that Flight 79 is 20 minutes late.

If I order food at a restaurant, it should be obvious that I also want a knife, fork, and spoon, a glass of water, salt, pepper, and a napkin.

Most software won't do this. Instead, it only narrowly answers the precise questions we ask it, and it is typically not very forthcoming about other information even if it is clearly related to my goals. When I tell my word processor to print my document, it never tells me that the paper supply is low or that 40 other documents are queued up before me, but a helpful human would.

Polite Software Has Common Sense

Although any good restaurant will happily let you tour its kitchen, the hostess's simple common sense directs you to the dining room instead when you first walk in the front door. Most software-based products don't seem to differentiate between kitchen and dining room, putting controls for constantly used functions adjacent to never-used controls. You can commonly find menus offering simple, harmless functions along with deadly, irreversible ejector-seat-lever functions that should only be used by trained professionals. It's like seating you at a dining table right next to the grill.

Offering inappropriate functions in inappropriate places is a hallmark of software-based products. The panic button on my car's remote keyless entry is a fine example of this lack of common sense. The earlier "about $500" example is a good illustration of putting common sense to work in an interface.

There are numerous horror stories of customers permanently offended by irrationally rational computer systems that repeatedly sent them checks for $0.00 or bills for $8,943,702,624.23. Most of the customer-service nightmares have gone away through the judicious isolation of customers from computer systems, but most employees still have to interact with computers. The employees are paid for doing so, so they tend not to complain too loudly, and they typically have no one to complain to the customer-service department is normally not for them.

Polite Software Anticipates My Needs

My assistant knows that I will require a hotel room when I travel to another city to a conference. She knows this even though I don't explicitly tell her so. She knows that I like a quiet, nonsmoking room, too, and will request one for me without any mention on my part. She anticipates my needs.

My Web browser spends most of its time idling while I peruse various Web sites. It could so easily anticipate my needs and prepare for them instead of just wasting time and effort. Why can't it use that idle time to preload links that are visible? Chances are good that I will soon ask the browser to examine one or more of those links. It is easy to abort an unwanted request, but always time consuming to wait for a request to be filled. If the program were to anticipate my desires by getting prepared for my requests during the time it would otherwise be idling, waiting for my commands, it could be much more responsive without needing a faster Internet connection.

Polite Software Is Responsive

When I am dining in a restaurant, I expect the waiter to respond appropriately to my nonverbal cues. When I am deeply engaged in intense conversation with my tablemates, I expect the waiter to attend to other duties. It would be highly inappropriate for the waiter to interrupt our discussion to say, "Hello, my name is Raul, and I'll be your waitperson for the evening." On the other hand, when our table conversation has ended and I am swiveling my head and trying to make eye contact with Raul, I expect him to hustle over to my table to see what I want.

My computer normally runs in a video mode that gives me 1024x768 pixels onscreen. When I do presentations, I am required to change temporarily to 800x600-pixel mode to accommodate the lower resolution of my video projector. Many of the programs that I run, including Windows 2000, react to the lowered resolution by changing their window size, shape, and placement on the screen. However, I invariably and quickly change my computer back to 1024x768-pixel mode. But the windows that changed to accommodate the lower resolution don't automatically change back to their previous settings for the higher-resolution screen. The information is there, but the program just doesn't care about responding to my obvious needs.

Polite Software Is Taciturn About Its Personal Problems

In saloons, salons, and psychiatrists' offices, the barkeep, hairdresser, and doctor are expected to keep mum about their problems and to show a reasonable interest in yours. It might be unfair to be so one-sided, but that's the nature of the service business. Software, too, should keep quiet about its problems and show interest in mine. Because computers don't have egos or tender sensibilities, they should be perfect for the role of confidant but they typically behave the opposite way.

Software is always whining at me with confirmation dialog boxes and bragging to me with unnecessary little status bars. I don't want or need to know how hard the computer is working. I am not interested in the program's crisis of confidence about whether to purge its recycle bin. I don't want to hear its whining about not being sure where to put a file on disk. I don't need to hear the modem whistling or see information about the computer's data-transfer rates and its loading sequence, any more than I need information about the bartender's divorce, the hairdresser's broken-down car, or the doctor's alimony payments.

Two issues are lurking here. Not only should the software keep quiet about its problems, but it should also have the intelligence, confidence, and authority to fix its problems on its own.

Polite Software Is Well Informed

On the other hand, we all need more information about what is going on. That same barkeep helps me out by posting his prices in plain sight on the wall and also writing on the chalkboard what time the pregame party begins on Saturday morning, along with who's playing and the current Vegas spread.

Shopkeepers need to keep their customers informed of issues that might affect them. I don't want my butcher to tell me on November 21 that he is out of Thanksgiving turkeys. I want to know well in advance that the supply is limited and that I need to place my order early.

When I search a topic on the Web using a typical search engine, I never know when link rot will make the engine's findings useless. I'll click on the URL of something I'd like to see, only to get a nasty "404 Link Not Found" error message. Why can't the engine periodically check each link to see if it still exists? If it has rotted away, the useless entry can be purged from the index so I won't waste my time waiting for it.

Programs constantly offer me choices that, for some reason, are not currently available. The program should know this and not put them in front of me.

Polite Software Is Perceptive

The concierge at a hotel I frequent in New York noticed my interest in Broadway shows. Now, whenever I visit, the concierge without my asking puts a handy listing of the current Broadway shows in my room. She was perceptive enough to notice my interest, and this allows her to anticipate my desires and provide me with information I want before I even think about it. It takes very little effort for the concierge to exploit the value of her acute perceptions, yet it draws me back to this hotel again and again.

Whenever I use an application, I always maximize it to use the entire available screen. I then use the Windows taskbar to change from one program to another. But the applications I run don't seem to notice this fact, especially new ones. I frequently have to tell them to maximize themselves even though they should be able to see that my preference is clear and unequivocal. Other users keep their applications in smaller windows so they can see icons on their desktop. This is just as easy for software to spot and anticipate.

Polite Software Is Self-Confident

I expect the service people with whom I interact to have courage and confidence. If they see me emerge from the men's room with my fly unzipped, I want someone to tell me quickly, clearly, and unobtrusively before I walk into the ballroom to give my speech. It takes some courage to do this, but it is courage appreciated. Likewise, if my assistant can't book me the flight I want, I expect him to confidently book something very close to the one I want without bothering me with details.

If I tell the computer to discard a file, I don't want it to come back to me and ask, "Are you sure?" Of course I'm sure, otherwise I wouldn't have asked. I want it to have the courage of its convictions and go ahead and delete the file.

On the other hand, if the computer has any suspicion that I might be wrong (which, of course, is always), it should anticipate my changing my mind and be fully prepared to undelete the file. In either case, the product should have confidence in its own actions and not weasel, whine, and pass the responsibility off onto me.

I have often worked on a document for a long time, clicked the Print button, and then gone to get a cup of coffee while it prints out. Then I return to find a mindless and fearful dialog box quivering in the middle of the screen asking me, "Are you sure you want to print?" This insecurity is infuriating and the antithesis of polite human behavior.

Polite Software Stays Focused

When I order salad in a good restaurant, they bring me a good salad. In a bad restaurant, I get the third degree along with it: "Spinach, Caesar, or mixed greens? Onions? Croutons? Grated cheese? Parmesan or Romano? Full serving or dinner size? French, Italian, oil and vinegar, or Thousand Island? Dressing on the side? Served before or after the main course?" Even the most demanding gourmet just doesn't care that much about the salad to be subjected to such a grilling, but interactive systems behave this way all of the time. Adobe's Photoshop program is notorious for peppering the user with lots of obnoxious and unnecessary little questions, each one in a separate dialog box.

Impolite software asks lots of annoying questions. Choices are generally not all that desirable, and being offered them is not a benefit but an ordeal.

Choices can be offered in different ways, too. They can be offered in the way that we window-shop. We peer in the window at our leisure, considering, choosing, or ignoring the goods offered to us. Alternatively, choices can be forced on us like a hostile interrogation by a customs officer at a border crossing "Do you have anything to declare?" with the full knowledge that we can dissemble as much as we like, but the consequences for getting caught can be more than just embarrassing. We don't know the consequences of the question. Will we be searched or not? If we know that a search is unavoidable, we would never lie. If we know there will be no search, we would be tempted to smuggle in that extra carton of Marlboros.

Polite Software Is Fudgable

When manual information-processing systems are translated into computerized systems, something is always lost in the process. Manual systems are typically computerized to increase their capacity, not to change their functionality. But manual systems are typically very flexible, which is not a function that can easily be isolated. An automated order-entry system can handle millions more orders than a human clerk can, but the human clerk has the ability to work the system.

In an automated system, the ability to work the system disappears. There is almost never a way to jigger the functioning to give or take slight advantages.

In a manual system, when the clerk's friend from the sales force calls on the phone and explains that getting the order processed speedily means additional business, the clerk can expedite that one order. When another order comes in with some critical information missing, the clerk can go ahead and process it, remembering to acquire and record the information later. Typically, this flexibility is absent in computerized systems.

In computerized systems, there are only two states nonexistence and full compliance and no intermediate states are recognized or accepted. In any manual system, there is an important but paradoxical state unspoken, undocumented, but widely relied upon of suspense, wherein a transaction can be accepted while still not being fully processed. The human operator creates that state in his head, on his desk, or in his back pocket.

For example, a digital system needs both customer and order information before it can post an invoice. The human clerk can go ahead and post an order in advance of detailed customer information, but the computerized system will reject the transaction, unwilling to allow the invoice to be entered without it.

I call this human ability to take actions out of sequence or before prerequisites are satisfied fudgability. It is typically one of the first casualties when systems are computerized, and its absence is a key contributor to the inhumanity of digital systems. It is a natural result of implementation model. The programmers don't see any reason to create intermediate states because the computer has no need for them. Yet there are strong human needs to be able to bend the system slightly.

One of the big benefits of a fudgable system is the reduction of mistakes. Much bigger, more-permanent mistakes are avoided by allowing many small, temporary mistakes into the system and entrusting and helping the human to correct them before they cause problems downstream. Paradoxically, most of the hard-edged rules enforced by computer systems are imposed to prevent just such mistakes. These inflexible rules cast the human and the software as adversaries, and because the human is prevented from fudging to prevent big mistakes, he soon stops caring about protecting the software from really colossal problems. When inflexible rules are imposed on flexible humans, both sides lose. It is invariably bad for business to prevent humans from doing what they want, and the computer system usually ends up having to digest invalid data anyway.

graphics/kolam.gif

Fudgability is one of the few human-politeness traits that can be difficult to build into a computer system. Fudgability demands a much more capable interface. In order to be fudgable, systems have to reveal their process to the moderately skilled observer. The clerk cannot move a form to the top of the queue unless the queue, its size, its ends, the form, and its position can be easily seen. Then the tools for pulling a form out of the electronic stack and placing it on the top must be present. These have to be made as visible as they are in a manual system, where it can be as simple as moving a sheet of paper. Physically, fudgability requires extra facilities to hold records in suspense, but an undo facility has very similar requirements. The real problem is that it admits the potential for fraud and abuse.

Fudging the system can be construed as fraud. It is technically a violation of the rules. In the manual world, fudging is tacit and winked at. It is assumed to be a very temporary, very special case, and the fudger will tidy up all such accounts before leaving for the night, vacation, or another job. Certainly, all such examples are cleaned up before the auditors are allowed in. If this process of temporary rule suspension were well known, it might encourage people to use the technique to the point of abuse.

Especially if the fudging has been documented in detail in the company manual, investing it with respectability, those with weaker characters might see in it a way to avoid doing accurate and complete work, or they might see in it a way to defraud the company of money. It is not fiscally responsible for the company to support fudging.

But fudgability has a powerful effect on the way users regard the system. All of the reasons for not having a fudgable system are very rational and logically defensible (probably legally defensible, too). Unfortunately, the idealized state of affairs that they describe is simply not an accurate description of the way the world works. Everyone in all areas of business uses the fudgability of manual systems to keep the wheels of business of life greased and turning easily. It is vital that automated systems be imbued with this quality despite the obstacles.

The saving grace with respect to abuse is that the computer also has the power to audit all of the user's actions easily, recording them in detail for any outside observer. The principle is a simple one: Let the user do whatever he wants, but keep very detailed records of those actions so that full accountability is easy.

Polite Software Gives Instant Gratification

Computer programming is all about deferred gratification. Computers do nothing until you've put enormous effort into first writing a program. Software engineers slowly internalize this principle of deferred gratification, and they tend to write programs that behave in the same way. Programs make users enter all possible information before they do even the tiniest bit of work. If another human behaved that way, you'd actively dislike him.

We can make our software significantly more polite by ensuring that it works for, and provides information to, the user without demanding a lot of up-front effort. Ted's TV should let him watch programs before it makes him configure parameters.

Polite Software Is Trustworthy

Friends establish trust with one another by being dependable and by a willingness to give of themselves. When computers behave erratically and are reluctant to work for users, no trust is generated. Whereas I trust the bank teller because she smiles at me and knows my name, I always count my cash at the ATM because I simply don't trust the obtuse machine.

graphics/kolam.gif

Our software-based products irritate us because they aren't polite, not because they lack features. As the preceding list of polite-software characteristics shows, polite software is usually no harder to build than impolite software. It simply means that someone has to envision interaction that emulates the qualities of a sensitive and caring friend. None of these characteristics is at odds with the other, more obviously pragmatic goals of business computing. Behaving more human can be the most pragmatic of all.



Inmates Are Running the Asylum, The. Why High-Tech Products Drive Us Crazy and How to Restore the Sanity
The Inmates Are Running the Asylum Why High Tech Products Drive Us Crazy &How to Restore the Sanity - 2004 publication
ISBN: B0036HJY9M
EAN: N/A
Year: 2003
Pages: 170

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net