The next book doesn't have such a trendy title. The buzz words here are distinctly middle-aged and due to be pensioned off. Evidently the copy writers at Yourdon aren't so sharp, but how does the book measure up?

Practical Analysis & Design for Client/Server & GUI Systems

by David A. Ruble, Yourdon Press, 1997

The Foreword to this book by Ed Yourdon almost put me off reading it. He talks about Structured Analysis and Design and criticises the younger generation for ignoring it as out-dated and irrelevant. It would have been a pity, as I would have missed two key additions to the field of User Interface Design which sneaked into this general book on Client/Server development. The author introduces a measure of Window Cohesion, based on the measure of cohension for functional code, and also a Notation for Window Navigation - of which more later.

It is obvious from the title of the book that the author is more confident with User Interface Design than Cantor. As it happens, GUI is the subject of 3 of the 13 chapters. Chapter 6 describes developing an Interface Prototype, Chapter 10 is titled "Graphical User Interface Concepts" and Chapter 11 titled "External Interface Design" takes us into the area of documenting a UI Design and presenting it to the customer.

Outline

This book seeks to cover the whole topic of analysing, architecting, designing and documenting a Client/Server system of, what is now called, the "traditional" variety. That is to say, a system with a big multi-user database on the server and a lot of fat clients running a GUI application which accesses the database, in a safe controlled transactional manner. Building such a system involves a project and inevitably Project Management, and organisation does get a mention. In fact chapter 2 is almost dedicated to it.

Chapter 3 takes us through some basic revision on DFDs and Context models. Chapter 4 is about the Event model which I detail later. Chapter 5 covers the Information model along with Entity Relationship Diagrams and State Transition Tables. Chapter 7 on wrapping up analysis with some good stuff on documenting business issues and moving from profound to merely simple ignorance of a domain - a process which sees the number of issues rise, not fall. Chapter 8 is about Client/Server Architecture and 9 covers RDBMS design. With 12 covering an introduction to OO, that wraps up the quick tour. A book which brushes across all the issues in traditional Client/Server systems with a big database. So what is there in this book which is really interesting? Plenty!

Analysis and Design

Chapter 1 has some excellent insights on analysis and the characteristics of a good methodology. The author looks in turn at design and then analysis methodologies. For the UI designer, this was one particularly memorable point

Good design should encourage decision-making by helping to evaluate choices.

User Interface gets its first mention on page 22 as the author lays out his "Software Development Pyramid" with Interface Prototype very close to the top. He elaborates by saying, "I am a strong advocate of an early prototype....... On some projects, I have used prototyping ... to drive out business event requirements..."

Events

The real action starts in Chapter 4. We are told

Event Modelling is a way of defining the system's requirements from the User's point of view.

This begins to sound important! This Chapter goes on to detail a wholly different way to describe the requirements . There are no Use Cases in this methodology. The Event model is useful to the Interface Designer

the event model provides the business rationale for navigatoin and window content

The rest of Chapter 4 goes on to tell us how to build an Event Model and carefully detail what is an Event and how to recognise one. We are told how to analyse them with Event Matrices and classify them into types. There is a good section detailing strategies for uncovering events including how to interpret a User Interview and translate it into events. Unfortunately this section is all too brief. The section on classification of events is also too brief as it hints at patterns which apply to different kinds of events and acknowledges that pattern recognition is a key element in re-usablility. A lot more work could have been done here to expand all of this theory. The classification strategies continue with suggestions like sequence events by time, group by User Role and group by Object. The chapter finishes up with a brief discussion on dialogue level events and identifying when and where a detailed discussion with the User is necessary.

Interface Prototype

Leading on from the Event Model and the classification of events along with the information model, the book moves on to explain how to turn this into a prototype User Interface. This is being done early as part of the analysis. We are reminded that

Prototyping should always be done with a specific learning objective in mind

and that the Interface Prototype will for the first time draw the Users into the system development and give them a real interest in the outcome. The author also observes that you cannot finish the information or event models until this is done as change is inevitable. Prototyping also causes business issues to surface. This is the phase of moving from profound ignorance to simple ignorance. There follows some debate on the pros and cons of prototyping and some attempt to describe the detail involved. There is a hint of one or two strategies for determining the fidelity of the prototype required. Using a worked example, the author goes on to show us how the event model and the classification we obtained earlier can be used to determine the outline shape of the User Interface. This chapter is littered with strategies for, and patterns of, User Interface. They come thick and fast. without real recognition of their significance. This is a section which is worth reading carefully a few times over. Finally there is a section on reviewing with the Users - such a necessary step. Chapter 6 is excellent and I haven't seen any other book which tried to tackle practical UI prototyping in this way. The real pity with it is that it is rushed and too thin. There is so much more that could have been said here.

GUI Concepts

Chapter 10 comes back to UI and introduces the very interesting concept of Window Cohesion which is a measure of the number and type of business events which are managed within a window. Just like code cohesion, window cohesion gives us a measure of how re-usable a window will be, by indicating how detached or de-coupled it is from the rest of the system. The author has chosen to lift the names for the cohesion levels directly from the earlier work by Constantine and Yourdon for code cohesion. Programmers will find the language familiar. I found this section most thought provoking, as the author walks us through Functional, Sequential, Communicational, Procedural, Temporal, Logical and Coincidental cohesion. I wanted to go back and analyse some of my old designs and see how they measured up.

Before arriving at this interesting stuff, we have to wade through a lot of background. The Microsoft guidelines get a mention and so does Galitz. This stuff has been covered in a lot more depth elsewhere. The usual set of rules are regurgitated. The text is interspersed with some more strategies and patterns but you have to read carefully to extract these. The author firmly lays out his belief that Object-Action is best. Hmmm.

External Interface Design

Chapter 11 takes us to documenting the UI Design. A good design specification of the windows, navigations and data descriptions, we are told, makes an excellent tool for communicating the design proposal to the Users. Take note - all you Use Case fans! The author introduces a 7 piece document including Window Navigation Diagram, Window Layout, Window Description, Window Mini-spec & Field description. This collection he calls his External Interface Design. I recognised this. I call it a High Level Design.

A Notation for Navigation

To draw a Window Navigation Diagram, the designer needs a notation to describe the windows and the inter-window navigation. We are introduced to a technique derived from Entity Relationship Diagrams - not my own favourite choice but the industry has needed something like this and I think the development of a notation similar to an object modelling notation is long overdue.

We are then given a walk-through of window type e.g. Main Window, Pop-up Window, MDI Frame etc.. I thought that this was a little too operating system specific and it only helps to confuse at this stage. It may have been clearer simply to leave it out.

Unit of Work

If you don't develop line of business applications which talk to databases, you may never have had to consider anything more complex than a file "save". If you do develop big business apps then you'll know that the database transaction scoping is a real issue. Ruble tackles it here by showing how the transaction scoping - the unit of work - can be determined whilst documenting the navigation. He overlays the unit of work onto the Window Navigation Diagram. I found this a clear and well-thought-out technique. There are a few more tips in the form of strategies and pattern observations, if you read carefully.

Chapter 11 concludes with a section on testing UI. This section describes how UI testing can move to ever increasing scope from characters and graphics through field lengths out to window navigation and business events. It then makes the very, very important point that the testing should be performed in reverse order! How often have you been told that a label is mis-spelled or a field is too short but when you ask, did the transaction happen or is the business logic complete, the test team can't tell you yet!

Summary

A very thought-provoking book which is aging fast due to lack of OO content. However, it does add significantly to the body of work on UI Design. Unfortunately, tries to cover too big a field in insufficient depth. It does provide an interesting alternative to Use Cases for describing and capturing the requirement. The author is firmly in the Object-Action UI Camp and it shows too often. Pity. If you're involved in a "traditional Client/Server" project using a big database at the server end, then this is an important book for you.

For me the best part was the final chapter. The 10 Myths of Client/Server Development. They are real! Don't get caught. The cartoons are good too. :-)

Recommendation

4/5 - Well enough written, hopefully someone will pick up the UI ideas in this book and take them further.

The author can be contacted at http://www.ocgworld.com

The authors feedback to this review can be read on the Feedback page.