Reviewed by
C. Kevin Clark
Aplington Middle School, Polo, Illinois
October 1997

Borenstein, Nathaniel S. (1991). Programming as if People Mattered: Friendly Programs, Software Engineering, and Other Notable Delusions. Princeton: Princeton University Press.

 

Summary
In Programming as if People Mattered, the author attempts to outline some difficulties with designing software user-interfaces. In the first part of the book, he tries to explain some of the downfalls of the existing interfaces and also elaborates on who is responsible for causing, maintaining, and compounding the problems that exist. The history and ideas of these groups and individuals, who at times try to solve the dilemmas, and at other times add to them, are described as a way of giving the reader some background information on the history of user-interface design. In the latter part of the book, Borenstein gives us his "Ten Commandments" for the principles of user-interface design. Apparently, ten are not enough, because he extends the number to eleven. Finally, Borenstein has a few parting words of wisdom as a seasoned software programmer and designer. This book, although getting rather mature in the fast-paced world of technology, provides a good starting point for those interested in user-interface design. It is interesting that even though there is absolutely no mention of Microsoft Windows and few references to the Apple Macintosh, the information present is still pertinent to the designing and programming of todayís multimedia, super powerful, megabyte eating behemoths that the computer community is becoming inundated with. Both experts and beginners can benefit from some of the simple, yet often overlooked or ignored, principles that Borenstein puts forth.

Strengths and Weaknesses
The strengths of the book are many. As mentioned above, even though the book is rather dated, the principles outlined are general enough that they can be applied to the many and varied platforms that exist today. In addition, the principles are extremely relevant to the designing obstacles and blessings of todayís extremely capable hardware. It is both interesting and perhaps saddening to find out that the problems faced in user-interface design several computer generations ago are similar, if not identical, to the ones that we are faced with now. As another strength, the book gives the reader an adequate, basic overview of what forces have shaped the realm of user-interface design. These forces include hardware capabilities, research into topics such as Human-Computer Interaction and cognitive psychology, research and developments in the computer lab, and the dictates and whims of what Borenstein calls the "men in suits:" lawyers and upper-level managers. Finally, the book is useful because it can be read by a wide audience. Experts and beginners, programmers and designers, managers and underlings can all take part in this non-technical discussion of what approaches make or break software design. Borenstein has definitely written to programmers, but the nature of the book and the casualness of his style make it enjoyable for all involved parties. Not every written work, however, can be perfect to all situations. Even though it was stated earlier that the design principles were general and pertinent enough to have withstood the test of time, there is still a lack of examples and anecdotes that can be applied to todayís Windows dominated world. If the reader were able to see particular instances where todayís software has failed the user, then perhaps this information and learning would be understood and acted upon more easily by todayís designers. Furthermore, at the time of the bookís authoring, Borenstein could not possibly have known that the power and speed of todayís machines would surpass those of only a few years ago many hundreds of times. He makes little mention that processing speeds might actually get faster or that machines would become more reliable (Have they?) and so some of his principles and suggestions may seem simple-minded or juvenile.

Important Points
It is felt, however, that there are several excellent points brought to the forefront in this book. First of all, Borenstein urges designers and programmers to listen to users. What may seem obvious is apparently unclear enough to some that he feels it deserves to be restated. Users are not experts. However, users use software! In order to design clever interfaces and worthy software, it is essential that experts critically examine and give ear to what users need, want, and hope for: a software package that can be understood and operated. A second valuable lesson examined by this book is that programmers should not sacrifice power for simplicity or ease of use. Instead, software should be designed so that it takes full advantage of the available hardwareís capabilities, making it as loaded as possible, without, however, causing such confusion by its complexity that it takes too long for a user to learn how to manipulate the program. Often software is either simple but ineffective, or effective but very involved. There needs to be a fusing of concepts: simple and powerful. Lastly, it is felt that the most important lesson learned from this text is for the designer or programmer to be humble. The main point of this concept is that the designer should have an open mind, accepting constructive criticism and helpful advice without turning up an "expertís" nose. When working on a design or program, it is often easy for the experts to ignore their own obvious bad judgements or misguided frameworks because they feel that they are the ultimate "authorities" and know what they are doing. More often than not, however, the intuition of experts about how a piece of software functions is completely opposite of how normal, everyday users interpret it. Be prepared as the designer to let go of the reins and allow someone else to use their own expertise in assisting you to develop the best package possible. As a final word, it is recommended that this book, although dated, be read and hearkened to by both beginning and expert programmers and designers. The principles outlined and lessons set forth span the gap between platforms and processors. Following these recommendations will improve upon any user interface.