Developing User Interfaces

by Dan R. Olsen Jr., Morgan Kaufmann, 1998

Introduction

Browsing through this book, I felt that a lot of it was familiar. A quick look at the Endnotes told me why. The list of reference material read like 2' of my bookshelf. Titles by Alan Dix et al, Eberts, Don Norman, Deborah Mayhew, Jakob Nielsen and most noticably Foley, van Dam, Feiner and Hughes, Computer Graphics:Principles and Practice - what was that doing here?

The Preface tells us that this book is not intended for UI Designers but for coders. Curiously then, the first two chapters are about design.

The introductory chapter wastes our time with pointless background on the history of computers and then tells us about Computer Graphics, Human Factors, Usability, Object Oriented Software, a process for User Interface Design including background material from Don Norman. There is a page and a half on "Designing the Functional Model". I thought about how to summarise this for a long time and the best I could do was - Simplistic Nonsense. It is followed by two pages on presentation which is covered in much greater depth by Mullet & Sano. In summary, the process described tells us nothing. It certainly isn't a methodology.

Chapter 2 expands on the Functional Model nonsense from earlier. It gets better as we go into greater depth and a few good points are made. There is 12 pages on Task Analysis and a worked example for a Student Registration system. A very good point is made that most Users cannot abstract their job and are incapable of radically rethinking their working practices, while they may have some simple ideas for localised improvement. This is an important point for System Designers and Architects everywhere. The tail end of section 2.4 is also good. It advises programmers that UI Design is best done by UI Designers and these people are often not programmers but should be given respect for their own abilities in design, psychology, anthropology etc.. When we move onto Functional Design it all goes pear-shaped. A section entitled "Object-oriented functional design" - surely an oxymoron! Its hard to talk about good UI code design without talking about OO, but this is so superficial as to be largely useless.

Graphics

Chapter 3 gives an overview of computer graphics. This is laying the ground for talking about windows and widgets but it really doesn't belong here. The author could have assumed a basic understanding and should have given a reference to other material. Chapters 9 through 12 give a lot more detail on Graphics and really this doesn't belong on a book on UI Development and can be better found elsewhere such as the Foley et al book which is referenced.

UI Technical Architecture

Most of the book talks about UI Technical Architecture and Design for code implementations. It does so in a platform independent manner. The discussion pre-dates Java and therefore, the Java 1.1 Event Model is missing from the discussion, as too are Interfaces. The author consistently refers to Abstract Classes for interface definitions.

Chapter 4 covers the Event Model. Its aimed squarely at the absolute novice. 10 years ago this might have been useful but nowadays it is covered much more adequately elsewhere. The Main Event Loop is really a specific reference to older technology.

Chapter 5 introduces us to MVC architecture. It has some good elementary discussion of the benefits and uses examples like screen rendering and an E-CAD package to make its points. A lot of nonsense gets talked about MVC but this is refreshingly clear. The author then states that in this book he will couple View and Controller into one class. He could have made more of this and pointed out to us that it is usually done this way in reality. As he gets deeper into these architecture issues, there is a lot of unexplained OO Design and use of inheritance. This could mislead the novice. The lack of OO Diagrams makes it difficult to follow what is going on. Curiously, Design Patterns (from the Gang of 4) never get a mention. Surely a major oversight in a book on UI Architecture!

When it comes to notification, the author fails to point out that the notification mechanism is best delegated away from the model classes to avoid polluting them with mere plumbing. He also fails to provide any credible design for such a notification mechanism. Another hole in this book. Overall, Chapter 5 was just enough to confuse a novice and perhaps arm him with a dangerous level of insufficient knowledge.

Chapter 6 is an introduction to widgets and UI Look and Feel with discussion on topics like enable/disable, active/inactive, focus gained/lost. There is an overview of the advantages of parameterising the look into Resource Files.

Chapter 7 moves onto real development - composing widgets together to build an interface. There is also a discussion on layout strategies such as Struts and Springs. Chapter 8 looksat Input syntax and correctly points out that Finite State Machine just doesn't scale to UI problems. We are walked through the actions, events, and states for a collection of widget types such as Scrollbar, Menu, TextField, introducing PPS notation as a useful alternative to state machine.

Chapter 13 is about Cut, Copy and Paste. We get an introduction to Clipboards, Publisher/Subscriber architecture and Embedded Editing.

Chapter 14 covers Undo and Macros and introduces the concept of clearly bounded commands. There is no mention of Command Pattern, or any Object Model design offered. The chapter is divided by a curious section on Groupware - what is that doing in this book?

Summary

This book reflects the fact that the author has a mastery of a bunch of stuff related to computer screens and has chosen to collect it all together for teaching purposes. It just doesn't gel together. It is superficial and unfocused. It covers UI Design, UI Technical Architecture and Computer Graphics. You just can't write a book that broad in subject and remain platform non-specific in 1998. This book is 10 years too late.

The author has missed a real opportunity to address elementary UI Technical Architecture in depth. Coming as it does in 1998, it ought to contain references to Design Patterns which were invented for UI Toolkits and it ought to be riddled with Object Model diagrams explaining the designs that he is using.

I couldn't think of any good purpose for this book until I read a review at Amazon.com which suggested that it was useful as a college primer for a quarter introductory course. Even then I am unsure. There is sufficient bad advice on OO Design to give a novice the wrong impression.

Recommendation

1/5 - Too wide and no depth. Serious UI developers need to read this stuff in greater depth in specialist books.