Dr. Dobb's Journal November 2000
Person asks me, "What makes a book a classic?" (I know it's more usual to say, "People ask," but it's only actually happened once...) The answer is the same as it is for software: utility, clarity, and brevity. Not surprisingly, the authors of one of the clearest, most useful, and most compact collections of software ever created -- the original UNIX -- have also been responsible for some of the best practical books about the craft of programming.
One of these, Jon Bentley's Programming Pearls, is now in its second edition, and has only grown better with age. The book grew out of the practical programming columns Bentley wrote for Communications of the ACM, and includes some new material and some rethinking of the original. The topics range from the surprising subtleties of common data structures and algorithms, to performance tuning (a subject that the authors of both major web browsers would do well to study), and some rules of good coding style. Bentley's writing and examples are exceptionally clear, and everything is directly relevant to real-world programming. As a bonus, this new edition includes the "27 Rules for Code Tuning" from his 1982 book Writing Efficient Programs (sadly, now out of print).
Greg Andrews's Foundations of Multithreaded, Parallel, and Distributed Programming isn't as short, or as wide-ranging, but is still a very good book. Like his earlier Concurrent Programming, it surveys the weird and wonderful tricks that programmers have invented for handling concurrency, from simple spin locks to channels, rendezvous, RPC, and more. Discussion of the theory underlying concurrent programming (based on assertions about preconditions and post conditions) is interleaved with examples of tie-breaking algorithms, barrier synchronization, and task farms. Like Bentley, the author writes clearly and succinctly. My only criticism is that the examples are not all done in a single, well-known programming language (such as Java or Python). Despite this, FMPDP is a good textbook, and probably the best general reference on the subject available today.
Despite its whimsical title, Jeff Johnson's GUI Bloopers is an equally good book. Johnson, a user-interface consultant, presents dozens of examples of good and bad interfaces, and explains why some things work and other things don't. Some of his examples are simple, such as giving menus more informative names than "Special," or laying out GUI controls according to normal workflow. Others, such as formatting links in web pages so that it's clear whether they will jump to the same page or a new page, are more subtle. Throughout, Johnson uses widely known packages and web sites to illustrate his points, and always justifies his design rules in concrete terms. He even includes a section on "Management Bloopers," and two case studies (the Eudora Pro 4.0 installer and Kodak Picture Disk 1.2).
GUI Bloopers is the best practical guide to GUI design I have read to date, and I hope it has the impact it deserves. It is very close in both spirit and presentation to the "Case Studies in User Interface Design" that I preemptively reviewed in "Not on the Shelves" (http://www.ercb.com/ feature/feature.0012.html). It might never be a classic as revered as with Programming Pearls, but I'm sure it will help make a lot of software much easier to use.
Jef Raskin's The Humane Interface is more ambitious than GUI Bloopers, but probably less useful to rank and file GUI designers. Raskin, a former DDJ editor, was involved with the Macintosh in its early days (the blurb on the book's back cover credits him with being its creator). As he accurately points out, interface design has advanced little, if at all, in the 15 years since the Mac revolution. This book is his look at what is wrong with what we're doing, and with some of the alternatives we can explore. Like Alan Cooper's The Inmates are Running the Asylum (reviewed here in November 1999), Raskin backs up his critique with many real-world examples. Unlike Cooper, and most other popular books on interfaces, he also uses theoretical models, such as the GOMS keystroke model, to back up his claims. His ideas are thought provoking, but his language is occasionally ponderous, and his arguments can sometimes be one-sided. Like Cooper's Inmates, this book would have been stronger if it had been more even handed.
Lawrence Graham's Legal Battles That Shaped the Software Industry is certainly even handed, and also vastly informative. The rise of open-source development, and the ongoing courtroom battle between Microsoft and its many enemies have made patents, trademarks, intellectual property rights, and other legal complexities a favorite topic of programmers' bull sessions. Unfortunately, "bull" is the best description of most of these discussions: Their signal-to-noise ratio is often close to zero, with hearsay and fabrication being presented as gospel.
Graham's book shovels much of the misinformation out of the way. It describes and analyzes the landmark court cases that have shaped American software law. Terms and concepts are clearly explained (sometimes several times), and the wider implications of important rulings are sketched out. Its international coverage is thin, and it is already slightly out of date (as is anything more than two weeks old in this industry), but these are minor flaws. It isn't quite Intellectual Property Made Simple (another book I asked for in "Not on the Shelves"), but it was an engrossing read.
The same cannot be said for David Barron's The World of Scripting Languages. This book is a survey of languages like Perl and Visual Basic, which are primarily used for automating administrative tasks, gluing applications together, or rapid prototyping. I had hoped that the book would compare and contrast the ways in which various languages try to meet these needs, and at how they are best used. Instead, most of the book is taken up with abbreviated summaries of these languages' syntactic quirks. These are too short to be good tutorials for newcomers, and too shallow to be of benefit to experienced programmers. Much of the material also feels out of touch: It is hard, for example, to understand how anyone could claim that Python isn't a scripting language...
Tomasz Muldner's C for Java Programmers is much more useful. As the title suggests, it is an introduction to the world's most portable assembly language for students who already know its most portable descendent. With 80 percent of introductory college computing courses now using Java, but many upper-level courses still using C/C++ for graphics, operating systems, and networks, there is a clear need for help in going from one to the other. This book meets that need well.
Features that are common to both languages, such as the structure of loops and conditionals, are covered relatively quickly. This gives the author plenty of room to discuss memory management, pointer manipulation, and other features of C that bind it more closely to hardware than Java. The writing and examples are solid, the layout is very readable, and the index didn't let me down once.
Students will have a much harder time coming to grips with XML, unless the quality of books on the subject starts to improve. Simon St. Laurent's XML Elements of Style is better than most in that it contains very little hype, weighs less than 15 pounds, and says some sensible things about structuring XML DTDs and documents. However, it sometimes loses its way in a swamp of jargon or in lengthy descriptions of minutiae that could usefully be interrupted by a few examples. For instance, the discussion of the 10 different types of attribute starting on page 55 would have been more comprehensible if each had been illustrated by an example in turn.
More irritating is the fact that the more obscure parts of the XML Standard are explained in less detail than the bits that most people are already familiar with. Parameters, external entities, and namespaces are going to be new to most people, and I will be very glad when a book appears that explains them as well as Jon Bentley explains quicksort.
DDJ