Tom Zillner, Editor
Designing with Web Standards
By Jeffrey Zeldman. Indianapolis, Ind.: New Riders, 2003. 456p. $35 (ISBN 0-73571-201-8).
About Face 2.0: The Essentials of Interaction Design
By Alan Cooper and Robert Reimann. Indianapolis, Ind.: New Wiley Pub., 2003. 540p. $35 (ISBN 0-7645-26413).
Designing with Web Standards opens with a statement intended to shock: 99.99 percent of today’s Web sites are obsolete. The first part of the book explains why and outlines the remedy as Zeldman promotes Web standards with conviction, clarity, and humor.
Tracing the problem to the beginnings of the Web, the author explains that the Web was originally designed for text. HTML was designed to mark up documents structurally, <h> for headings, <p> for paragraphs, and so on. As the Web took off, Web designers began to create visually rich pages. To do this required using HTML in a way it wasn’t intended—marking up Web pages to make them look a particular way, rather than for their structure.
The browser wars of the 1990s made things worse. Catering to the desire for visually exciting pages, and attempting to win market share, competing browsers implemented nonstandard, incompatible techniques designed to create visual effects. Pages created for one browser didn’t work well—or worse, not at all—in another. This meant Web designers had to create multiple versions of pages in order to achieve the same look in different browsers.
The result was bloated pages that took too long to download, and pages that were difficult and expensive to create and maintain. Sites were often inaccessible to the increasing numbers of people accessing the Web with new types of Internet appliances such as personal digital assistants (PDAs) and Web-enabled cell phones. For persons with disabilities—the visually or motor impaired—these sites were especially inaccessible.
In 2001, a series of browsers began appearing that implemented Web standards that made it possible to design pages with leaner, cleaner coding. As a result, they loaded faster and were easier and cheaper to create and maintain. A core group of technologies designed by the World Wide Web Consortium (W3C), these standards allow designers to create a single version of a site that, with the help of appropriate style sheets, can be accessed by, among other things, multiple browsers, PDAs, and screen readers. Following these standards means not having to solve today’s problems by creating others for tomorrow. It also means knowing there won’t be some incompatible new technology in the future that will require expensive recoding to incorporate.
While Web standards are a major step forward, they haven’t solved all the Web’s problems, as Zeldman makes clear. Browsers have their quirks and don’t implement the standards in exactly the same way. Zeldman discusses the white-space and box-model problem, among others, and shows how to get around them. He devotes an entire chapter to typography. Unfortunately, different browsers don’t agree on standard font sizes. Thus, the Web designer must choose between coding font sizes relatively, which allows user control but runs the risk that fonts will appear too large or small in particular browsers, or using absolute font sizes, which display uniformly in all browsers, but restrict the user’s ability to modify the font size in Internet Explorer for Windows, the most used browser.
He ends with a brief section discussing and comparing the various browsers that are compliant with Web standards.
Zeldman is as qualified as anyone to write a book on Web standards. He can speak authoritatively about the history and development of Web standards, as he has been instrumental in promoting their implementation and use.
In 1998, Zeldman cofounded A List Apart (www.alistapart.com), a widely used “magazine for people who make Web sites,” as well as the Web Standards Project (WaSP) (www.webstandards.org). WaSP was influential in promoting the term Web standards (called “recommendations” by the W3C, the standards-making body for the Web), and in urging browser manufacturers to make their browsers standards-compliant. WaSP has also worked directly and indirectly with companies marketing
Web editors, including Macromedia (Dreamweaver) and Adobe (GoLive) in an effort to promote standards-compliance in those products.
His personal Web site, The Daily Report: Jeffrey Zeldman presents Web Design News (www.zeldman.com) is an important resource for the Web-design community. He is owner of a Web-consulting company, Happy Cog, where he applies Web standards in his practice.
Designing with Web Standards is an important book for anyone involved in Web design. It is both a wake-up call and a call to action. It deserves a place next to Eric Meyer on CSS and Joe Clark’s Building Accessible Web Sites on the Web designer’s bookshelf .—Thomas E. Lehman, University of Notre Dame Libraries, Indiana
About Face 2.0: The Essentials of Interaction Design
By Alan Cooper and Robert Reimann. Indianapolis, Ind.: New Wiley Pub., 2003. 540p. $35 (ISBN 0-7645-26413).
Alan Cooper is a big name in user interface design, although he is probably less well known outside the world of software design than, for example, Jakob Nielsen. Perhaps his biggest claim to fame is the design of the initial version of Visual Basic (VB), a wonderful piece of workmanship. One could write an entire essay on the good and evil unleashed upon the world by offering the almost infinitely malleable user interface of VB, but this is not the place. Suffice it to say that software wrought from Alan Cooper’s masterpiece is both praised and scorned. But Cooper is not resting on his laurels: he heads a design firm that is turning out first-rate products embodying the best in what he calls “interaction design.”
Interaction design is more than just the look and feel of a piece of software; it encompasses both its appearance and behavior. It is defined in About Face as “the design of complex, user-focused behaviors of interactive systems” (page 31 of front matter). Software (and Web pages) must do more than just look good; they must also serve their functions well. Too often there is a mismatch between the user interface and the underlying functioning of software: either the interface is seductive and the underlying function is a morass, or, more commonly, an elegant (or at least useful) piece of software is hard to use and unintuitive because of lousy interface design. Why? Because for most developers, design of the user interface is secondary to design of the underlying code.
The actual interaction with the user is often phoned in at the end of a project—an afterthought. Cooper believes that user goals are paramount, and user goals are ill met by clever coding wrapped in ornate but unusable screen design. He presents a process called Goal-Directed Design (GDD) that starts with users and ends with them. The stages of GDD are research, modeling, requirements definition, framework definition, and refinement. About Face first provides a broad overview of each of these stages before moving on to more in-depth coverage of each.
Research, the first stage of interaction design, focuses most heavily on user goals, as revealed through ethnographic techniques that meet users in the wild, as they go about their working tasks. This observation is informed by some initial hypotheses about the behavior variables representing a spectrum that can distinguish various users. The authors point to the example of an e-commerce application (47). Among the possible variables are frequency of shopping (infrequent to frequent), desire to shop (hates-to-shop to loves-to-shop), and motivation to shop (bargain hunting to searching for just the right item). This articulation of behavior variables will be used in the next stage of the design process, but it is first employed here in order to ensure that the users who are interviewed exhibit behavior across the full range of variables.
Cooper and Reimann believe that it is crucial to observe users as they work and to interview them in the work context. So if they were designing an interface to an online catalog, they would watch and interview people interacting with the current catalog software. A key to the usefulness of the interviews is to find users who fit all of the various roles possible in the interaction. For example, users of a catalog might be casual beginners, expert researchers, or almost anywhere between these poles. It is important to capture the full range of possible user stances in order to ensure a good design.
Actual observation interviews are not set up until there is an initial “persona hypothesis,” a preliminary idea of who uses the product, how their needs and behaviors vary, and what behaviors and environments need to be explored. This and other behavioral and environmental information are used to put together the interviews. The observation and interviewing must focus on goals rather than tasks. After all, the software should help the user achieve her goals, rather than simply providing her with more efficient or otherwise better ways to perform tasks. Tasks are means to achieve goals, not ends in themselves. The authors provide useful tips for conducting the interviews (48–52), although they do not really cover the concomitant techniques of observation. Other types of research (focus groups, marketing studies, and usability and user testing) are mentioned but given short shrift. It’s the interviewing that sets the stage and provides the underpinning for the next stage, modeling users.
Cooper and Reimann call modeling “the most powerful interaction design tool” they use (55). It is here that the research conducted in the previous phase is codified and formalized through the construction of personas (or, if you prefer it more pedantic, personae). A persona is, as its name suggests, a set of goals and behavior patterns that is represented as a single person. How are personas constructed? First of all, the behavioral variables hypothesized in the research stage are examined in light of the user interviews. There may be some adjustment to their characteristics or gradation based on what was actually observed. Perhaps a few new variables were discovered along the way. If enough unexpected variables emerge, it may be necessary to perform some additional interviews with these in mind. In any case, at some point a set of behavioral variables emerge, against which each of the interviewees has been measured. The next step is to map every subject’s responses across the behavioral variables, looking for behavior patterns. These are evidenced by clusters of subjects falling on the same point in the spectrum of behavior across multiple variables. Using the authors’ e-commerce example, perhaps multiple users would say they love to shop, do it all of the time, and are looking for bargains. This cluster could then be used as the raw material for a persona.
The persona itself incorporates the behavior patterns and also includes goals discovered during the research process, either through observation or targeted questions. Then the persona narrative is written. “The best narrative quickly introduces the person in terms of his job or lifestyle . . . and briefly sketches a day in his life, including peeves, concerns, and interests that have direct bearing on the product” (71). Cooper and Reimann believe it is important to name the persona and provide a photograph. In other words, this must seem like a sketch of a real person. Unfortunately, the authors provide no example of a persona narrative. This is an aspect of a larger problem that will be discussed later.
Next comes what the authors call “framework definition,” (or “build the interaction design”). A set of scenarios is developed as a prelude to the actual design. The scenarios are stories about the people depicted in the personas solving the problems and meeting the needs articulated during the research phase. It’s actually not quite as simple as that: there is a five-stage process from which a “context” scenario emerges. Context scenarios are stories about a day in the life of the users (personas) and how they interact with the system under design. (A good example of one of these scenarios can be found on pages 81–82.) The context scenario is not an end product; it leads into a needs-identification stage. This is an extraction process. The context scenario forms the input to the needs identification stage. The resulting user needs are expressed in terms of objects and actions.
The needs identified serve as input to the design stage itself—“defining the interaction framework” (83–88)—again a five-step process. One of the outputs of this stage is another scenario. The “key-path” scenario takes the desired interactions identified in the context scenario and spells out the actual tasks (actions and pathways) that will be embodied in the design product. It is during this set of stages that sketches and storyboards of the actual user interface finally emerge. The key-path scenarios are worked on iteratively, in top-down fashion, becoming more detailed as the design is elaborated, starting with key functions and moving progressively toward less important features off the beaten path. At the same time, the principles of good design presented elsewhere throughout the book are brought to bear, approaching the design in a bottom-up fashion. So the central core of the design stage is driven from both the top down and the bottom up, obtaining the best of both worlds.
Finally, there is refinement. The least coverage is spent on this in the first chapters, partly because much of the rest of the book is spent on tips and techniques that constitute a key piece of the refinement stage. However, this is also a stage at which another set of scenarios, “validation scenarios,” are constructed (89). These are simply scenarios for “less-traveled interactions,” and use the same method of construction as key-path scenarios.
It’s significant to note that all of these stages of interaction design are iterative. Although it is most obvious, perhaps, in the design and refinement stages, at each of the other earlier stages there is a back-and-forth honing process. This does not seem to be stressed by the authors, but it is a key to ultimate success of the design.
The preceding has been a more-or-less detailed exposition of the stages of interactive design. Yet this only constitutes the first ninety pages of the book. And that’s a problem with About Face 2.0—the design process is spelled out with just enough detail to convince the reader that this could be a useful process that should be incorporated into the activities of any software design team, yet there does not seem to be enough detail to recreate it effectively. One thing sorely missing is an entire case study, laying out the documents created at each step, the research, personas, and scenarios that embody the implementation of interaction design. The few examples that are provided of small pieces in the larger scheme—for example, the sample context scenario (81–82)—leave the reader hungry for more. A case study for a single piece of software, with each of the example pieces placed in the context of the concepts as they are spelled out, rather than presenting the whole of a case study as a separate lump in a separate chapter or appendix, would be the most helpful and effective method to make practitioners out of those who are believers. But this reviewer would settle for the lump version instead—anything that illuminates and elucidates interaction design as Cooper and Reimann envision it.
If the exposition of interaction design is the meat, the remaining sections and chapters are the potatoes. Although potatoes are denigrated in the Atkins age, in this book these chapters provide plenty of nutrition. One theme that echoes throughout becomes something of a hobbyhorse, but an important one: don’t make the user feel dumb, especially through seemingly meaningless dialog boxes. Good examples are offered in chapters 10 (“Eliminating Excise”) and 13 (“Rethinking Files and Save”). The authors make important points, particularly that dialog boxes often offer the implicit message “You have made a mistake; you are stupid.” Chapter 13 (“Eliminating Errors”) deals with this most directly and at greatest length, offering methods to avoid errors and resultant error messages. Better and harder work by programmers is the key. One failure in this discussion: although Cooper and Reimann loathe error dialogs, they do offer an example of how they should look in case all other error suppression and correction actions fail. The example (444) is awful: a huge box with way too much information. Most users may find all of this overwhelming rather than helpful. While it attempts to be humane, it is humane with a vengeance. Still, the idea that most error dialogs can be avoided altogether is important and may be achievable to some degree.
An entire section of the book is devoted to direct manipulation and its permutations (part 5, “Mice and Manipulation”). There is a quite helpful discussion of the power of the mouse and the intricacies of the operations it can perform. There are separate chapters devoted to “Selection” and “Drag-and-Drop” (chapters 22 and 23), as well as a quite good chapter on manipulating objects (chapter 24). All of the material outlining direct manipulation material in relation to good design is first-rate. Even the coverage of 3-D manipulation is interesting.
Another whole section is devoted to “Controls and Their Behaviors,” offering important insights and tips for dealing with windows, menus, toolbars and tooltips, and dialogs. Cooper and Reimann are particularly fond of tooltips, alluding to them in passing in multiple chapters, but more clearly spelling out their use and superiority to balloon help in pages 384–86. As elsewhere in the book, the material in this section is clear and thoughtful.
There are asides concerning Web applications throughout About Face 2.0, but there is also a fairly short chapter devoted exclusively to the Web (chapter 37, “Designing for the Web”). The authors first distinguish between Web sites and Web applications. Web sites are information-centric and users simply navigate or search the site, finding the specific pieces of information they seek. More of the chapter is devoted to Web applications, which are characterized by their heavily transactional nature. Because of this, Web applications are more solidly in the applications world than the Web world. The chapter’s treatment of Web applications mainly serves to connect up concepts presented throughout the book with the specific functionality of the Web. For example, “sovereign-posture” applications are introduced much earlier as “programs that are best used full-screen, monopolizing the user’s attention for a long period of time” (103). A word processor like Microsoft Word is a good example of such a desktop application. In this chapter, the authors discuss how sovereign Web applications might be realized through a Web-browser interface although they favor a nonbrowser-based implementation. Similarly, specific sorts of sites are connected to previously covered concepts. While the chapter is too short, particularly on specific examples, to make it a primary resource for designers of Web interaction, it does illustrate that the key concepts discussed elsewhere in the book can be brought to bear on Web-design projects. It’s not simply about the appearance of static pages anymore. Sophisticated Web applications require sophisticated thinking. The chapter is helpful, and Cooper and Reimann provide pointers to several other books that have Web design as a primary focus.
When all is said and done, what Cooper and Reimann reveal again and again in this book is that “design concerns the whole of the product or service—not just what it does, but what it is and what goals it serves” (480). The user interface is, as the term suggests, where the user connects with the behavior of the software. Design of user interaction encompasses far more than cosmetic changes to the user interface. This is not something that can be grafted on at the end, after the underlying software has been written. Users’ goals must be met, and the best way to meet them may be to design software from the outside in. Turning the coders loose certainly hasn’t done the job.
About Face 2.0 is a book worth reading. Even though this reviewer has serious reservations about the chapters that spell out the interaction-design method, much can be learned from them. Additionally, the rest of the book is chock-full of important insights and useful examples. Although, as noted, Web-based interaction-design methods are not covered at great length, the principles spelled out here can be usefully applied in constructing Web pages and sites, particularly those that are transaction-rich.
Read this book if you develop software or Web applications. Read the first section in its entirety. Consider reading the remainder in its entirety as well, but if you don’t have time, dip into the function-specific chapters as you need to. It’s worth the time.— Tom Zillner