It seems that language in software is on the mind of interaction designers. A few bright folks over at UX Matters have thought about whether software should speak to users from a first person or second person perspective. I have been thinking about similar issues after a client recently asked me about whether a piece of software should ever refer to itself. “If we already think about computers as other people, why wouldn’t we?”
What’s he talking about? For those unfamiliar with The Media Equation, in 2003 Stanford professors Reeves and Nass published a series of experiments they conducted which show that humans essentially treat computers as if they were other humans.
From Publishers Weekly:
“People are polite to computers, respond to praise from them and view them as teammates. They like computers with personalities similar to their own, find masculine-sounding computers extroverted, driven and intelligent while they judge feminine-sounding computers knowledgeable about love and relationships.”
So if this is the case, my client asked, why shouldn’t the computer talk to us like it’s another human? The answer is a little nuanced so I thought I’d write it down.
The first and easiest-to-realize thing to realize is that The Media Equation doesn’t really say that we treat computers exactly like other humans. We don’t worry that they’re hungry, need a haircut, or expect them to say “gesundheit ” when we sneeze. The research shows that we treat computers more like humans than we might imagine—given that they’re hunks of plastic and metal shuttling bits back and forth. They influence our opinions and behaviors subtly, because they appear to use language, symbol processing, and exhibit some complex behavior—all very human attributes. But we don’t think of them as actually human.
The second and more nuanced question-under-the-question is whether software should refer to itself with the first person singular, “I?” Imagine when a piece of desktop software expects to connect to the Internet and fails. The user needs to be informed. What should it say? It could speak in the first person and say something like:
“I’m having trouble connecting to the internet.”
Certainly this is clear, there’s little ambiguity to what is meant, and it’s pretty concise. Warm, even. But this takes us, as so many things do, to Clippy. Clippy was the default character in Microsoft’s reviled Office Assistant. Though probably well-intentioned, the implementation of the office assistant felt invasive, pandering, and annoying as all get out.
I’ll posit that another reason Clippy rubbed most everyone the wrong way is because it overpromised. Anthropomorphic embodiment changes the way we think about something. It’s no longer a complex machine, but a person, and we have much higher functional expectations of people: human-like language and reasoning, an ability to seamlessly recognize the context of any utterance or action, the ability to recognize a user by sight, and even understand human intentions. Software isn’t anywhere near this sophisticated yet. (We’re getting quite close in parts, and science fiction is setting our expectations that we’ll probably talk to them one day, like with HAL, but the next version of your operating system probably still won’t understand your sarcasm or know what to do with it.)
What about first person plural?
First person plural, i.e. “we,” should only be used to speak for the organization behind the software, not the software itself. This is OK for informative websites, but not for applications. After all, people think of applications as single things, and if a collection of programs started speaking as a plurality, it would imply not only personhood, with all of the improper implications mentioned above, but a super creepy
Village-of-the-Damned hive mind.
What about “the computer”?
The computer is a complex machine with many interconnected programs and functions. Trying to wrap it up in a single abstract noun like “the computer” is too vague. What part of the computer can’t connect to the internet? The user needs this information to know what to do with it. If it’s the OS, you’ll need to do something different than if it’s the software. (“I” has this problem of ambiguity, too.) You don’t want to be too specific, because the user doesn’t care that it was a function in the sys/socket.h library. Applications are the “things” that users think about, and knowing the application that is telling them something gives it a meaningful and actionable context.
So avoid the trappings of anthropomorphism and ambiguity by having software refer to itself only in the third person, by name, such as:
“SavingsPro is having trouble connecting to the internet.”
This may force you into some complex linguistic circumstances every now and then as you try and avoid it, but in the end the result will feel more professional and more respectful to your users. More importantly, should also keep their expectations in line with what software can actually do.