Thursday, March 31, 2011

Don't Blame The Developer!

Recently, I read yet another blog post in which a user ranted against an annoying feature of the latest word processing consumer software that wiped out work back to an autosave. The problem, he seemed to think, lay with those annoying developers who kept adding features to products that weren’t really needed, making it harder to understand and use, and increasing the chance of accidental mistakes causing a meltdown. Sorry, but I disagree. And having helped develop a word processor back in the late 70s and a file system back in the late 80s, and followed the field as an analyst since, I’ve seen the world from both sides now, as a computer scientist and as a marketer; so I think I have a good perspective on the problem.

There are two related problems with most software used by consumers: what I call orthogonality (in math, elegance) and metaphor. Orthogonality says that your basic operations on which everything else is built are "on the same level" and together they cover everything -- power plus intuitive sense to the user. Metaphor says that the idea of how the user operates with this software is a comparison to a model -- and that model should be as powerful as possible.

In the case of word processing (and most other consumer software) all products are not as orthogonal as they should be. One of the reasons the original Word succeeded was that it was more orthogonal than its competitors in its commands: file, edit, etc. are a pretty good take. That means that necessary additions and elaborations are also more orthogonal; the rich get richer.

Where everyone (including Apple and Google) really falls down is in metaphor. To take one example we are still haunted by: the original metaphor for word processors and other desktop software was, indeed, a physical desktop, with a one-level filing system underneath. It took a while for people to accept a wholly unfamiliar metaphor, the folder within folder within folder -- even though it was far more powerful, easier to program and upgrade, and, on average, made things easier for the user who learned the new metaphor. For the last 25 years, all consumer software vendors have consistently rejected an even better metaphor: what is called in math the directed acyclic graph. This would allow multiple folders to access the same folder or file: essentially, incredibly easy cross-filing. I know from design experience that using this approach in a word processor or other consumer software would be almost as intuitive as the present "tree" (folder) metaphor. Instead, software vendors have adopted kludges such as "aliases" that only make the product far more complicated. The same is true of supporting both dynamic and static file storage on the desktop (too long a discussion).

The reason orthogonality and good metaphor rarely get done or last is that almost never do a good developer and a good marketer (one who understands not only what consumers say they want but what they could want) connect in software development. Sorry, I have watched Steve Jobs for 30 years now, and while he is superb at the marketing end, he does very badly at understanding metaphor plus orthogonality from the mathematical/technical point of view. And the rest are probably worse.
The net result for Word, and, sorry Mr. User, for all those "better" previous word processors, is that time makes all these problems worse, and it results in either failure to incorporate valuable new metaphors (and I do think that spell- and grammar-checking are overall better than the old days, and worth the frustrations of poor orthogonality and awkward usage in isolated cases) or retrofitting of a more orthogonal approach. Specifically, I suspect (because I think I've seen it) that supporting the old WordPerfect ctrl-a approach for both the old Word command interface and the new toolbar style plus new features added just one too many dangerous key combinations next to the ones traditionally used. You miss, you pay -- and yes, the same thing will happen with touch screen gestures.

Whether this business game is worth the candle I leave to anyone who is a user. I know, however, from long experience, who to blame -- and it's not primarily the latest developer. Fundamentally, I blame a long series of marketers who at least are told about the problem -- I've told many of them myself -- and when push comes to shove, keep chickening out. The reasons for not doing orthogonality with a better metaphor always seem better to them at the time, the development time longer, the risks of the new higher, the credibility of the trouble-maker suspect, and they won't be around to deal with the problems of playing it safe. These are all good superficial reasons; but they're wrong. And we all suffer, developers not least – because they have to try to clean up the mess.

So give a little blame, if it makes you feel better, to the latest developer or product upgrade designer, who didn’t understand how the typical consumer would use the latest version; give a little blame, if you can figure out how, to the previous developers and designers, who didn’t anticipate these problems. But the marketer, be he the CEO or a lowly product marketer, who makes the fundamental decision about where to go next is really the only person who can hear both the voice of the consumer and the voice that understands the technical/mathematical usefulness of orthogonality and a good metaphor. The marketer is the one who has a real opportunity to make things better; to him, the user should assign the primary blame.

The writer Peter Beagle, commenting favorably on JRR Tolkien’s anti-heroes, once wrote “We worship all the wrong heroes.” I won’t go that far. But I will say that we need to hold our present consumer software marketing heroes to higher standards. And stop reflexively making the developer the villain.

No comments: