A Joke Too Far

Alan Cooper's second book, The Inmates Are Running the Asylum: Why High-Tech Products Drive Us Crazy and How to Restore the Sanity, is definitely not "one too far" -- it makes too many important points about why software is hard to use for that to be the case. Cooper is the father of Visual Basic, and by all accounts (including the ones quoted in the front pages of his book) he is a very good user-interface designer. I learned a lot from About Face, and hoped that this one would be equally insightful and iconoclastic.

Well, iconoclastic it certainly is. Take the diagram on page 35, for example. It shows "power users," "computer literate users," and "naive users" stacked on top of each other, but is captioned "Euphemism Pyramid." As the accompanying text explains:

"Naive user" is industry code for "stupid, incompetent user." And certainly these people are made to feel stupid, but they are not. It is the bad design of the interaction that is at fault. The apologists in the computer industry dismiss naive users as not significant, but that flies in the face of good sense. Why would a vendor write off the lion's share of the market? Because it removes the blame for failure from the executives and software engineers and places it squarely onto the shoulders of the innocent users...The phrase "computer literate user" really means the person has been hurt so many times that the scar tissue is thick enough so he no longer feels the pain.

Bravo, Mister Cooper -- it's refreshing to hear someone finally say that the emperor's butt is showing. Cooper argues that most software is hard to use because most engineers are disdainful of the way most people think. The only way to fix what's fundamentally broken in so much of today's software is to give interaction designers as much real authority in the product development process as engineers.

Cooper's points are important, and he has a clearer view of our industry and profession than most writers. However, I think that the book's occasional glibness and one-sidedness weaken his case. For example, the two-dollar psychoanalysis of nerds on page 103 might be an accurate description of some engineers, but when applied to the profession as a whole, it becomes the kind of grossly misleading generalization that I associate with paradigm-shift-per-second marketing gurus. More troubling is the fact that he never discusses how the interaction-centered methods he advocates can go wrong. I understand how frustration with current practices can turn into stridency, but I think the major audience for this book would find even-handed exposition more persuasive than naked advocacy. I don't believe anyone's method works all of the time, and when someone suggests (even by omission) that theirs does, it makes me suspicious of everything else they've said. Despite this, I think that Inmates is an important book, and I hope that Cooper will turn his hand to writing a textbook one day.

Next in this month's pile are Ready-to-Run Java 3D, by Kirk Brown and Daniel Petersen, and The Java 3D API Specification, by Henry Sowizral, Kevin Rushforth, and Michael Deering. Both books are about Java 3D, the 3D graphics entry in the JavaMedia suite of interfaces. As with the rest of Java, there is little in the library that is actually new. Instead, it repackages established technology (primarily OpenGL) for use in Java. The library includes the usual graphics primitives and transformations, along with behaviors, handlers for input devices, picking, and so on.

The first major difference between the two books is how much context each provides. Almost all of The Java 3D API Specification is devoted to a method-by-method description of the library's contents, while Ready-to-Run spends a bit more time showing how those methods can be stitched together. I wouldn't recommend trying to find your way around the former book unless you are already familiar with 3D computer graphics, but if you are, it's a handy reference and is refreshingly free of typos.

Which brings us to the other big difference between the two books: their quality. Ready-to-Run is, quite frankly, sloppy. The first figure is unreadable because of gratuitous 3D chart junk, matrices are laid out as ASCII art (honestly, how hard would it have been to make them look like proper mathematics?), Arthur Clarke is misquoted, someone's spellchecker has turned the "Locale" class into "Local" sporadically, and some of the listings include Sun's lengthy disclaimers verbatim, along with the source code that the reader is supposed to be interested in. And do we really need yet another slapdash description of how to nest applets in HTML documents for different browsers?

I really wish Ready-to-Run had been a better book, as I don't think novices will be able to make sense of the API Specification. As hardware graphics accelerators are getting cheaper, and 3D graphics are growing more and more accessible, I hope its authors will try again.

Further down in my pile is Michi Henning and Steve Vinoski's Advanced CORBA Programming with C++. I've been waiting for this book for a while, and I can honestly think of nothing to complain about except its inordinate fondness for acronyms. It is well written, comprehensive, and contains lots of useful bits of code for its readers to study and copy. It isn't particularly easy going, but that is merely an honest reflection of the complexity of its subject. The book does not merely describe CORBA, it explains it -- why certain features were necessary compromises, for example, or what errors can be made when this or that feature is misused. I think this book is going to be as essential a part of CORBA programmers' lives as Stevens's UNIX Network Programming has been for everyone who has had to wrestle with TCP, UDP, and their ilk. And wonder of wonders, its index is actually useful...

Finally, there is Inside the JavaOS Operating System, by Tom Saulpaugh and Charles Mirho. Jointly designed by Sun and IBM to be a universal platform for Java programmers, the JavaOS specifies services, device-driver interfaces, memory management, interrupts, a microkernel, miscellaneous events, and a boot interface. The book surveys all of these, discussing both how they fit together, and how they can be used. Except for a couple of paragraphs of marketing spiel in the introduction, the book is relatively hype free (at least by Java standards). If JavaOS had taken off, this would probably have become the equivalent of Chappell's Understanding ActiveX and OLE.

Now, have you heard the one about the three little Ethernet hubs?

DDJ