There's a lot to like about the very idea of considerate software. If I'm using a piece of software, I want it to do something for me. I'm going to be devoting a great deal of attention to it, asking it to do this or that and expecting responses to those requests. Ideally, someone or something I'm working with that closely will treat me considerately, just as I should make every effort to treat a person I'm working with considerately.
More subtly, the metaphor of considerate software cuts the designers and implementors of the software completely out of the picture. This is surely deliberate and completely appropriate. Once software is deployed, the designers and implementors are out of the picture. I can't come and ask them how to deal with some puzzling or frustrating bit of behavior (and lucky for them, sometimes). As far as I'm concerned it's the software that's being helpful or annoying.
There are clearly limits on how considerate software could possibly be. If I decide to type in a long treatise on considerate software into the "shipping address" field of some form, I wouldn't expect the app to respond "Why yes, that's very interesting. I personally find Cooper's work exemplary. Shall we continue this conversation over coffee?" However, it doesn't seem too much to expect a politely phrased, helpful response pointing out that "I first heard the motto ..." followed by several paragraphs does not look like a valid street address.
I don't need to go into detail here about how far short much software falls in this regard. I'm sure you've got your own examples. Neither do I want to go into how and why software comes to be inconsiderate, though that's an interesting topic in itself. Instead, I'd like to go into what qualities make software considerate or inconsiderate.
The list I referred to above hits a lot of interesting points, but it feels more like a list of this and that than a thorough taxonomy. In particular, the headings, while snappy, don't always seem to match up well with what they head.
Some of the points fall under "Considerate software remembers":
- "Considerate software takes an interest" is really just saying it shouldn't ask for the same information over and over. That is, it should remember what you've already told it.
- "Considerate software is perceptive" says that software should remember what we do. It also says that it should adapt its behavior based on what it knows. More on that shortly.
- "Considerate software takes responsibility." says that software should remember where it is and be able to restore its state as closely as possible to where it had been before something derailed it.
Other points assert that software should know the kinds of things that we know and it can reasonably be expected to know:
- "Considerate software uses common sense." Common sense is not some magical filter that separates sensible behavior from senseless. It's largely a body of knowledge, whether learned or instinctive. To keep from, say, sending a check for $0, it needs to know that checks should only be sent for positive amounts.
- "Considerate software anticipates needs." To anticipate needs, a piece of software needs to know what those needs are.
- "Considerate software knows when to bend the rules." Is saying that it should know how (and when) to do more than just the narrow definition of its task.
- "Considerate software is forthcoming." says primarily that software should actually tell us useful information that it knows, but to do that it may need to know information outside a narrow view of what it should be doing.
A third set has more to do with knowing when and when not to offer information
- "Considerate software keeps you informed/is forthcoming." Not only should it know useful things we didn't specifically ask it to know, it should let us know that and modify its behavior accordingly. But ...
- "Considerate software doesn't burden you with its personal problems/is self-confident/doesn't ask a lot of questions." It should limit itself to interactions useful to us, present information in ways that are easy for us to absorb and ask for information in ways that are easy for us to present.
A couple seem more about letting us exercise our judgment instead of trying to exercise it for us
- "Considerate software is deferential." Software should not prohibit things that might be useful. Instead it should make sure we know the consequences of a choice and then let us make it. It occurs to me that the "undo" feature is particularly helpful here.
- "Considerate software is conscientious." The principle here seems to be that software should know that some things are dangerous and not simply assume that we mean to do them.
Taking a stab at boiling this all down:
- Considerate software knows as much as reasonably possible about its domain.
- Considerate software remembers what's happened, what we've told it and what it's told us.
- Considerate software modifies its behavior where appropriate based on the above.
- Considerate software gives us ways to access to what it knows (including the state of the world as it used to be).
- Considerate software actively tells us important things we might not already know.
- Considerate software communicates efficiently -- taking into account how human minds work.
These principles seem fairly universal, but it's worth noting that one of the first extensions to the original web protocols, and one that enabled major improvements in the experience of using the web, was the cookie -- a way of letting a web site remember things that have happened before and, ideally, act accordingly.
2 comments:
I know it's just a style thing, but you (and Atwood) write almost as though you thought the thing were self-aware.
To be fair, one might write, say,"good architecture does not force itself on the occupant," or the like.
First, I did say up top that the whole concept of considerate software is a metaphor.
That said, though, I'm completely comfortable with saying that software "knows" things, or "thinks" things, and with statements like "It's confused because it still thinks the file is on the network drive."
I'll flat-out assert that a computer can know things in a meaningful sense. That may or may not be the same sense in which we know things but -- this is really something for the other blog -- one who would claim that there is a different sense in which we know things has the burden of defining that sense and making the case. It's not an axiom.
I hadn't thought I'd implied that considerate software is self-aware, but after re-reading in that light ... maybe. Again, though, we need to define what we mean by "self-aware".
Post a Comment