I've been reading a fun new book lately that every Windows programmer ought to have on her bookshelf. It's called GUI Bloopers, by Jeff Johnson (Morgan Kauffman, 2000). It is a catalogue of the mistakes programmers have made, and are still busily making, in user interface design. It helps explain why so many GUIs are a pain to use, even though they may sport fancy new widgets or come in exciting colors. You would think that after two decades of GUI development we would have the design problems licked. Not hardly. We may have solved the technical problems, but from a user's perspective, too many GUIs are still clunky, inconsistent, or just plain broken.
I am sure every reader of this magazine could name their most hated GUI foibles. Tops on my list are the solicitous paper clip of Word fame, and what I call the "worry-wart" GUI, that asks "Are you sure?" before every conceivable operation. (Why not just combine all these questions into one: "Are you sure you're not an idiot?") But let us not dwell on our GUI laundry list; we could be here all night long.
The question is why GUIs are so unfriendly. The answer may be because a GUI isn't really a GUI at all; it's a PUI, or Programmer-User Interface (aptly pronounced "pooey"). It is where two very different world views collide. Most PUIs make poor user interfaces, because they act like one-way mirrors. Users are on the transparent side, and they see two things they should never see: the programmer's vast ignorance of users' needs, and implementation details, revealed in cryptic error messages like corrupted node at 0x0F00BAAA. On the other side of the mirror, programmers see only a reflection of their own thought processes and assumptions. Clearly, to turn a PUI into a usable GUI, we must flip the mirror around. It should reflect the needs of users, not programmers.
Flipping the mirror around is far easier said than done, but not for the reasons often given. That is, it is not because programmers are biologically incapable of understanding users. I dislike the popular stereotype, although usually repeated in jest, that portrays programmers as socially retarded, pizza snarfing geeks, who relate better to machines than to other human beings. Come on, we're not that bad, are we? I just cannot believe that programmers are genetically determined to communicate poorly and to wear stripes with plaid.
That said, programmers are necessarily focused on their code, and this can lead to a form of myopia. The problems encountered in designing GUIs are akin to the problems in writing articles or documentation. When you have such intimate knowledge of your own code, it's hard to know how much other people don't. It might make sense to you to provide three Options menus, if the code comes in three major modules. But it will most assuredly drive users nuts.
It would be better if programmers could just forget everything about their code when it came time to design the GUI. Alas, selective memory seems to be a talent reserved for sociopaths and politicians. One obvious solution, though seldom practical, is to design the GUI before writing any code. Another is to employ the services of a usability consultant — preferably one less pompous than that job title sounds. A cheap solution is to get a book like GUI Bloopers and read it cover to cover. You may not agree with everything the author calls a blooper, but the next time you commit one you will at least think about it for a while. And even if that was all you did, you would be advancing the state of the art.
P.S. Check out our new "C/C++ Tips" feature in this issue, and consider sending in one yourself. If you can describe a useful programming idea in less than 400 words, you may receive a cool CUJ shirt (not another tee shirt — these are high-quality duds) and a free CUJ CD-ROM.
Marc Briand
Editor-in-Chief