π Lecture 36 β Behavior & Form β Part IV
π Overview: This lecture explores the complexities of the undo function in user interfaces, moving beyond a simple "mistake reversal" tool to consider it as a primary support for user exploration and confidence. It also critically examines the file and save paradigm, arguing that the implementation model of file systems creates significant confusion for users and proposes a unified file model aligned with the user's mental model.
ποΈ Topics Covered
The lecture begins by redefining the purpose of undo from a user-centered perspective, emphasizing its role in exploration. It then categorizes different types of undo, including incremental vs. procedural, blind vs. explanatory, and single vs. multiple undo, detailing their respective advantages and limitations. The discussion extends to other undo-like behaviors such as group multiple undo, comparison tools, category-specific undo, and milestoning. The second half of the lecture shifts focus to the file system, identifying problems with the implementation model, including the "Save Changes?" dialog and the "Save As" function, before outlining a design for a unified file presentation model.
π Lecture Summary
36.1 Understanding undo
Undo is a remarkable facility that lets users reverse a previous action. From a computational standpoint, undo has no merit as computers make no mistakes. However, humans make mistakes as a part of everyday behavior, making undo a facility for their exclusive use. The design of undo should be modeled most like the user's mental model, not the computer's implementation model. Users don't typically include error in their mental model, so software should absolve the user of blame and treat all user actions as valid.
Undo is critically important for supporting exploration. When users experiment with a tool, they inevitably probe into dead ends. Undo acts as a "rope ladder," providing psychological reassurance that they can always return to a safe state. This encourages further exploration, as users are more willing to try new things if they know they can easily reverse their actions. Undo is primarily a tool for supporting exploration, not just for reversing errors.
π Definition β Undo: A facility that allows a user to reverse a previous action, supporting exploration and recovery from mistakes. π‘ Why this matters: Viewing undo as an exploration tool rather than an error-recovery tool fundamentally changes its design, making it more forgiving and encouraging user experimentation.
36.2 Types and Variants of Undo
The software industry lacks adequate terminology for the different types of undo, which contributes to a lack of innovation. This section defines several distinct undo variants to clarify their behaviors.
36.3 Incremental and procedural actions
All user actions have a procedure component (what the user did) and an optional data component (what information was affected). Actions with a data componentβsuch as cutting, pasting, typing, and deletingβare called incremental actions. Undoing them involves removing or replacing the affected data. Actions that are data-free transformationsβsuch as paragraph reformatting or rotationβare called procedural actions. Most existing undo functions do not discriminate between these two types.
Blind undo is invoked by a menu or toolbar control with an unchanging label or icon. The user knows it undoes the last operation but has no indication of what that operation was. Explanatory undo, by contrast, includes a textual or visual description of the particular operation that will be undone. For example, if the user last typed "design," the menu says "Undo Typing design." Explanatory undo is generally a much more pleasant feature.
π Definition β Incremental Actions: User actions that include a data component (e.g., typing, deleting, cutting). π Definition β Procedural Actions: User actions that are data-free transformations with only a procedure component (e.g., reformatting a paragraph, rotating an image). π Definition β Blind Undo: An undo function that reverses the last operation without indicating what that operation was. π Definition β Explanatory Undo: An undo function that includes a textual or visual description of the operation to be undone.
36.4 Single and multiple undo
Single undo is the most basic variant, reversing the effects of the most recent user action. Performing a single undo twice usually undoes the undo, bringing the system back to its previous state. This is very effective because it is simple to operate. The biggest limitation is when the user accidentally short-circuits the capability. For example, if a user deletes six paragraphs, then deletes one word, performing undo only brings back the one word, and the six paragraphs are lost forever. The program acted literally, not practically.
Multiple undo can be performed repeatedly in succession to revert more than one previous operation in reverse temporal order. The program maintains a stack of operations. In the scenario above, the user can restore the deleted word with the first undo and the six paragraphs with a second invocation. However, multiple undo also has limitations. It operates in a strict LIFO (Last In, First Out) order. If a user performs several interlaced functions, only some of which are undesirable, they must undo all intervening actions, even valid ones, to reach the desired point. The model models code and data structures instead of user goals.
π Definition β Single Undo: An undo that reverses only the most recent user action. Performing it twice typically toggles the action. π Definition β Multiple Undo: An undo that can reverse a sequence of actions in reverse chronological order, typically using a LIFO stack. π Formula: LIFO (Last In, First Out) β The last action performed is the first to be undone. Redo is a function that resulted from the implementation model of undo, allowing the user to "undo the undo." It avoids the problem of clicking Undo one time too many. Group multiple undo, as seen in Microsoft Word, is a variation where the user can see a list of past operations and select one to undo. However, this undoes all operations back to that point, not just the selected one.
36.5 Other Models for Undo-Like Behavior
The simple single undo conforms to the user's mental model, but it diverges as complexity grows. This section discusses alternatives.
Comparison: What would this look like? The paired undo-redo function can serve as a convenient comparison tool, allowing the user to toggle back and forth between two states to see the visual effect of a change. This is akin to a "Jump" button on a TV remote, which switches between the current and previous channel.
Category-specific Undo targets a specific class of operation. The Backspace key is a prime example, acting as an incremental undo that only reverses the last characters typed, ignoring other, intervening functions. Using this model, one could create format-undo, pigment-undo, or transformation-undo functions that only undo actions within their specific category.
Deleted data buffers provide a repository of all deleted text or data, independent of the procedural stack. The user can open this buffer as a document and browse it to recover desired data, rather than having to reverse complex sequences of commands.
Milestoning involves making a copy or "snapshot" of the entire document at a specific point in time. The user can then make experimental changes and later revert to any saved milestone. A reversion facility would allow the user to load any saved version.
Freezing is the opposite of milestoning. It locks specific data in a document so it cannot be changed, while allowing new data to be added.
Undo Proof Operations are actions that cannot be undone because they trigger a device not under the program's control (e.g., sending an email, turning off the computer). However, many operations masquerade as undo-proof, like saving a file under a new name. A filename undo is rarely provided, even though it is technically feasible.
π Definition β Milestoning: A function that saves a copy of the entire document, like a snapshot, that the user can later revert to. π Definition β Freezing: Locking specific data in a document so it cannot be changed, while allowing new data to be added.
36.6 Rethinking Files and Save
The file system is the most difficult part of modern computers for users to understand. The "Do you want to save changes?" dialog box is a primary source of confusion.
What's Wrong with Saving Changes to Files? Every program exists in two places: in memory and on disk. The "Save Changes?" dialog appears when closing a document because the program must reconcile the difference between the two copies. From the user's mental model, they are simply putting their document away, and the question is absurd. The program asks about saving changes at the end of the work, not when the changes were made, which is disconnected from the user's workflow.
Problems with the Implementation Model The file system is an internal facility that shouldn't affect the user, but its influence pervades the interface, affecting menus, dialogs, and program structure. Most software treats the file system as the operating system shell does, forcing users to think like mechanics.
Closing and unwanted changes Experienced users use the "Save Changes?" dialog to abandon unwanted changes by choosing "No." However, the proper time to reject changes is when they are made, using the Undo function.
Save As This dialog forces users to understand the file system intimately, including file names and directory navigation. Many users give up on directories. The dialog also has inconsistencies; it allows renaming other files but not the one being worked on, and trying to rename an open file in Explorer results in a confusing "sharing violation" error message.
36.7 Archiving
There is no explicit function for making a copy of a document. Users must use "Save As," which leads to dangerous traps. If a user edits a document "Alpha" and uses "Save As" to make an archival copy as "New Alpha," the program saves the old version of "Alpha" (without recent edits) to disk and leaves the user editing "New Alpha" with all the recent changes. The user mistakenly believes their work is backed up, but it is not.
π Example: A user edits "Alpha" for 20 minutes, then uses "Save As" to create "New Alpha." The program saves the original "Alpha" (without the 20 minutes of changes) to disk. All the recent changes are in "New Alpha," the only copy in memory. The user has no backup.
36.8 Implementation Model versus Mental Model
The file system's implementation model violates the user's mental model in two key ways: First, users imagine there is only one document, but there are always two (on disk and in memory). Second, users feel the document belongs to them, but the program treats it as its own. The user's mental model is like a journal that comes off the shelf, gets edited, and then is put back. The computer makes a copy of the journal, edits the copy, and then asks if the original should be replaced.
36.9 Dispensing with the Implementation Model of the File System
The solution is not to get rid of the file system, but to hide its existence from the user. The user interface should present a unified model of a single document. This would remove confusing dialogs and allow interface designers to structure commands according to user goals, not the needs of the operating system. This would significantly lower the barrier for new users.
36.10 Designing a Unified File Presentation Model
Properly designed software should treat documents as single instances, not as a copy on disk and a copy in memory: a unified file model. It is the file system's job to manage the second copy on disk, but the application software should conspire to hide this from the user. If a file is in use, the file system could indicate this visually (e.g., with a red filename or a special symbol) rather than causing a confusing error message. The software should also help the user understand non-intuitive actions, like how a program can still appear in the Start menu even after it has been launched.
β Key Takeaways
- Undo is an exploration tool, not just an error recovery tool. Design it to reassure users and encourage experimentation, making them feel safe to probe the unknown.
- Single undo is simple but limited; it fails when users don't notice a mistake until after several subsequent actions. Multiple undo (LIFO) solves this but forces users to reverse all intervening actions, even valid ones, which can be painful.
- The file system is the greatest source of user confusion. The implementation model (two copies of every file) violates the user's mental model (one single document). This leads to perplexing dialogs like "Do you want to save changes?" and dangerous traps.
- The "Save As" dialog is a poor tool for archiving. It should not be the primary way to make a copy of a document. A dedicated "Milestone" or "Archive" function would be far more intuitive and safe.
- The goal is a unified file model where the software hides the duality of disk/memory storage from the user, treating the document as a single instance. This makes software far more accessible to non-technical users.
π§ Quick Revision Questions
- Why is it important to design undo from the user's mental model rather than the implementation model?
- Explain the primary limitation of single undo. Give a specific example of when it would fail a user.
- What is a "deleted data buffer," and how does it solve a problem that multiple undo (LIFO) cannot?
- According to the lecture, what is the fundamental problem with the "Do you want to save changes?" dialog box from a user's perspective?
- What is the key design principle for a "unified file presentation model"?
π Lecture 37 β Behavior & Form - Part V
π Overview: This lecture explores how to redesign software interfaces to be more considerate and intelligent, moving beyond traditional file management paradigms. It introduces unified document management, considerate software design principles, and smart software that uses memory to anticipate user needs, fundamentally shifting how we think about human-computer interaction.
ποΈ Topics Covered
The lecture covers unified document management as an alternative to traditional file dialogs, including automatic saving, snapshot copies, milestoning, renaming, and format specification. It then explores the concept of considerate software with twelve key characteristics, followed by smart software techniques that leverage idle processor cycles and task coherence through memory systems that remember user patterns, choices, and behaviors across sessions.
π Lecture Summary
37.1 Unified Document Management
The established standard suite of file management consisting of the Save As dialog, Save Changes dialog, and Open File dialog is confusing for some tasks and incapable for others. A different approach manages documents according to the user's mental model, rendering the document as a single entity with goal-directed functions.
Automatically saving the document abolishes all user interface recognition of the two copies (memory and disk), so the Save function disappears completely from the mainstream interface. The program should automatically save when the user closes, writing changes to disk without asking for confirmation. To prevent data loss from crashes, the program should save during the session β ideally after each keystroke, though word processors may save when the user pauses typing rather than using a countdown clock that interrupts work. Manual save controls (like Ctrl+S) should remain for paranoid users, but not be prominently forced on all users.
Creating a copy should be an explicit function called Snapshot Copy, making it clear the copy is identical to and not tied to the original. The new copy should automatically be named "Copy of Alpha" (or "Second Copy of Alpha" if that name exists) and placed in the same directory without any dialog box interruption.
Naming and renaming should be simple: the document name appears on the application's title bar, and users can click and edit it in place.
Placing and moving documents: Most edited documents already exist and have established positions. New files should be put somewhere reasonable automatically. If users want to explicitly place a document, they can request a function from the menu β a relative of the Save As dialog appears with the current document highlighted for moving.
Specifying stored format should not be tied to the Save function, as this adds unnecessary complexity to a common operation. Physical format (rich text, ASCII, Word format) is a characteristic of the document, not the disk file. It belongs in a Document Properties dialog, with significant cautions built in. For drawing programs, an Export dialog is appropriate.
Reversing changes should use the undo tool, not the file system as a surrogate for undo. The concept of going directly to the file system to undo changes undermines the undo function.
Abandoning all changes should be explicitly supported via an Abandon Changes function on the main menu, with clear warning signs since it involves significant data loss. Making this function undoable is highly desirable.
π‘ Why this matters: These redesigns eliminate confusion by matching the user's mental model rather than the implementation model of separate disk and memory copies.
37.2 Creating a Milestone Copy of the Document
Milestoning is similar to the Copy command, but the copy is managed by the application after it is made. A Milestone dialog box lists each milestone with statistics like time recorded and length. With a click, the user can select a milestone as the active document; the current document becomes milestoned itself (e.g., "Milestone of Alpha 12/17/03, 1:53 PM"). Milestoning is a lightweight form of versioning.
A new File menu would include: New and Open as before; Close closes without dialog after automatic save; Rename/Move lets users rename or move files; Make Snapshot Copy creates a copy; Print collects all printer controls; Make Milestone creates managed copies via a dialog summoned by Revert to Milestone; Abandon Changes discards all changes; Document Properties lets users change physical format; Exit closes document and application.
A new name for the File menu is needed since we present a unified storage model. Two alternatives: label the menu after the document type (e.g., "Sheet" for spreadsheets, "Invoice" for invoicing programs) or use a generic label like "Document." Programs that represent disk contents as files (operating system shells and utilities) should keep "File" since they address files as files.
37.3 Are Disks and Files Systems a Feature?
From the user's point of view, there is no reason for disks to exist. From the hardware engineer's perspective, three reasons exist: disks are cheaper than solid-state memory, they retain data when power is off, and they provide physical means of moving information. However, non-volatile RAM and networks can serve the latter two purposes. Cost is the real reason disks exist.
Disk drives have many drawbacks: much slower than RAM, less reliable due to moving parts, consume more power, take up more space, and the CPU cannot directly read/write to them β data must first be brought into solid-state memory. This makes processing with disks orders of magnitude slower and more complex than working with RAM. Disks make computers weaker, slower, and more complex β a compromise dilution of solid-state architecture. Wherever disk technology has left its mark on software design, it has done so for implementation purposes only, not in service of users.
37.4 Time for Change
Two arguments favor the file system model: "our software is already designed that way" and "users are used to it." Neither is valid. New programs with a unified file model can coexist with older implementation model applications, much like toolbars invaded interfaces. The second argument is more insidious β users may reject new solutions because they abhor change, but users are not always the best predictors of design successes. The Chrysler minivan example shows that the public initially rejected a superior design that later became hugely successful. Users cannot be expected to visualize interaction paradigm shifts, but the market shows people will gladly give up painful software for better alternatives.
37.5 Making Software Considerate
Research by sociologists Clifford Nass and Byron Reeves discovered that humans instinctively treat interactive artifacts as sentient beings β our reaction to software as sentient is both unconscious and unavoidable. The implication: if we want users to like our software, we should design it to behave like a likeable person; if we want productivity, design it to behave like a supportive human colleague.
Designing Considerate Software: Nass and Reeves suggest politeness, but considerate is preferred β putting the needs of others first. Considerate software has users' goals and needs as its primary concern beyond basic functions. If software is stingy with information, obscures its process, forces hunting for common functions, and blames users for its own failings, users will dislike it regardless of visual appeal.
What Makes Software Considerate? Twelve characteristics:
Considerate software takes an interest: It remembers likes and dislikes to please users in the future. Most software doesn't know or care who is using it, remembering nothing about us despite constant use. Software should remember work habits and everything users tell it.
Considerate software is deferential: It defers to the client β the user is the boss. Software can suggest an action and explain consequences, but if users wish to proceed, software should do as told. (The word "Submit" is a reversal of this deferential role.)
Considerate software is forthcoming: It volunteers useful collateral information beyond answering precise questions. When we tell a word processor to print, it should tell us when paper is low or other documents are queued.
Considerate software uses common sense: It doesn't place controls for constantly used functions adjacent to never-used or dangerous functions.
Considerate software anticipates needs: Like a human assistant who reserves a hotel room without being asked, software should anticipate needs. A web browser could preload visible links while users read.
Considerate software is conscientious: It has a larger perspective on task performance β like washing dishes and also wiping counters and emptying trash, a conscientious program does related tasks.
Considerate software doesn't burden you with its personal problems: Software should keep quiet about its problems and show interest in ours. It whines with error messages, interrupts with confirmation dialogs, and brags with unnecessary notifiers. Software should have the intelligence to fix its problems on its own.
Considerate software keeps us informed: While not pestering, it provides modeless feedback about what matters to us.
Considerate software is perceptive: It observes user patterns and offers relevant information. If a user asks about widgets once, it's a clue they want to know again. Software should watch preferences and remember them without being asked.
Considerate software is self-confident: It stands by its convictions β if told to discard a file, it shouldn't ask "Are you sure?" Instead, it should anticipate changes of mind by being prepared to undelete.
Considerate software doesn't ask a lot of questions: Excessive choices become an ordeal. Choices should be offered like window shopping (peering at leisure) rather than interrogation.
Considerate software fails gracefully: When discovering a fatal problem, it should prepare for failure without hurting the user β tidying up affairs, preserving data in recoverable format β rather than crashing and taking work with it.
Considerate software knows when to bend the rules: Fudgeability is the characteristic of manual systems that lets humans perform actions out of sequence or before prerequisites are satisfied. It's one of the first casualties when systems are computerized. By allowing small temporary mistakes and trusting humans to correct them, we avoid bigger permanent mistakes. Inflexible rules cast human and software as adversaries.
Considerate software takes responsibility: Too much software takes the attitude "It isn't my responsibility," passing jobs along without follow-through. In a typical print operation, when the user cancels but the printer continues printing buffered pages, the software lies by saying the function was canceled while pages still print.
37.6 Considerate Software Is Possible
Software irritates us because it isn't considerate, not because it lacks features. Considerate software is usually no harder to build than rude software β it simply requires envisioning interaction that emulates sensitive and caring friendship. None of these characteristics conflict with pragmatic business computing goals; behaving more humanely can be the most pragmatic goal of all.
37.7 Making Software Smarts
Programmers optimize code for the CPU's single-file instruction processing, keeping instructions minimal for snappy performance. However, once the CPU finishes work, it waits idle until the user issues another command. We invest enormous efforts in reducing reaction time but little in putting the computer to work proactively when not busy. The division of labor is clear: the computer does the work, the user does the thinking. Users don't need help thinking β they need help with information management work. Smart software means programs capable of working hard even under difficult conditions and when the user isn't busy.
37.8 Putting the Idle Cycles to Work
Users must remember too many things (file names, locations) while the processor wastes billions of cycles waiting. Most software takes no notice of context β offering the same help whether the user is struggling on a tight deadline or noodling casually. Most users can't do anything in less than a few seconds β enough time for a desktop computer to execute at least a billion instructions. With pre-emptive threaded multitasking, programs can perform extra work in the background without affecting performance. Every time a program puts up a modal dialog box, it goes into an idle waiting state β this should never happen. We need a more proactive way of thinking about how software can help with goals and tasks.
37.9 Giving Software a Memory
Memory here means a program facility for tracking and responding to user actions over multiple sessions β not RAM. If a program remembers what the user did last time and how, it can use that remembered behavior as a guide. This is one of the most effective tools for designing software behavior. Continually interrogating users is not only excise but subtly expresses doubt about their authority. Most software is forgetful, remembering little from execution to execution, and when it retains information, it's usually for the programmer's convenience, not the user's.
37.10 Task Coherence
Task coherence is the principle that our goals and how we achieve them through tasks is generally the same from day to day. When a consumer uses a product, the functions they use and how they use them will be very similar to what they did last time β working on the same or similar documents in similar places. With significant reliability, you can predict user behavior by remembering what they did the last several times they used the program.
Remembering choices and defaults: If it's worth the user entering, it's worth the program remembering. Instead of hard-wired defaults, the program should use the previous setting as the default. Options should remain in effect until manually changed. If users ignored facilities or turned them off, they should not be offered again.
Remembering file locations: Programs must remember more than just the last place files were accessed β they must remember the last place files of each type were accessed. Window positions should also be remembered.
Remembering patterns: Memory reduces excise β useless effort devoted to managing the tool rather than doing work. A significant portion of excise involves explaining things to the program it should already know. If the program noticed patterns (like repeated two-step formatting operations), it could automatically create new format styles or toolbar controls.
π Definition β Task Coherence: The principle that user goals and task achievement methods are generally the same from day to day, allowing prediction of future behavior by remembering past actions.
37.11 Actions to Remember
Everything users do should be remembered β there's plenty of storage, and memory is a good investment. If a word processor saved 1 KB of execution notes per run, 10 times daily for 200 workdays per year, the annual consumption is only 2 MB.
File locations: All file-open facilities should remember source directories and offer them on a combo box β users should never have to step through the tree to a directory more than once.
Deduced information: Software should also remember useful information deduced from facts. For example, tracking changed-byte-count per session: if the count suddenly jumps from ~100 to 5000, the program might keep a milestone copy before changes were made, just in case.
Multi-session undo: Programs should write the undo stack to a file, reloading it when the user reopens the document β even if it was a week ago.
Past data entries: Memory reduces errors by reducing manual entry. If the program remembers zip codes and city names, it can indicate uncertainty (yellow field) or ambiguity (pink field) when mismatches occur.
Foreign application activities on program files: Applications might leave a small thread running between invocations to track where files go and who reads/writes them, helping users find moved files and informing about other functions performed.
37.12 Applying Memory to Your Applications
When developers accept task coherence's power, their thinking takes on new quality. Instead of popping up dialog boxes, designers ask questions: How much should the program remember? Which aspects? Should it remember more than the last setting? What constitutes a pattern change?
Decision-set reduction: People tend to reduce infinite choices to a small, finite set. Even when not doing the exact same thing, users choose from a small repetitive set of options. Simply remembering the last action can fail if the decision set has two elements (user alternates between two directories). The solution: remember more than one previous choice. The program should look for subtle clues to differentiate from the small set β like remembering payees and amounts on an account-by-account basis for check writing.
Preference thresholds: Decisions fall into two categories: important and unimportant. Most decisions are insignificant. Software can use this to simplify tasks β after a user asks to print, we don't need to ask how many copies or orientation. Make assumptions the first time, remember them, and let users access options if they want changes.
Mostly right, most of the time: Task coherence predicts with reasonable (not absolute) certainty. If we can predict correctly 80% of the time, offering a choice would bother users with an unnecessary dialog 80% of the time. Instead, the program should do what it thinks appropriate and allow override or undo. If undo is sufficiently easy, users handle it only 2 times out of 10 instead of dealing with redundant dialogs 8 times out of 10.
π Definition β Decision-Set Reduction: The human tendency to reduce an infinite set of choices to a small, finite set of regularly used options.
π Formula: Memory-based prediction = Task Coherence + Decision-Set Reduction + Preference Thresholds β "Mostly right, most of the time" without asking unnecessary questions
37.13 Memory Makes a Difference
One main reason software is difficult to use is that designers make rational, logical assumptions that are very wrong β assuming user behavior is random and unpredictable, requiring interrogation to determine the proper course. While human behavior isn't deterministic like digital computers, it's rarely random. Applying memory via task coherence yields great advantages in user efficiency and satisfaction. A program that makes effective use of memory becomes like a self-motivated assistant β remembering helpful information and personal preferences without needing to ask. Simple things make the difference between a tolerated product and one users love. The next time a program asks users a question, it should ask itself one instead.
β Key Takeaways
Unified document management eliminates the confusing separation between memory and disk copies, replacing Save/Save As with automatic saving and explicit functions like Snapshot Copy, Milestone, and Abandon Changes that match the user's mental model. Considerate software should behave like a supportive human colleague β taking interest, being deferential, forthcoming, perceptive, self-confident, and knowing when to bend rules rather than interrogating users with questions. Smart software uses memory through task coherence to predict user behavior by remembering past actions, reducing excise and eliminating unnecessary dialog boxes. The principle of "mostly right, most of the time" means programs should act on predictions and allow easy undo rather than asking for confirmation. Applying memory to applications through decision-set reduction and preference thresholds transforms software from a tolerated tool into a beloved assistant.
π§ Quick Revision Questions
- What are the seven goal-directed functions in unified document management, and how does automatic saving differ from traditional Save functionality?
- List and explain five characteristics of considerate software that directly reduce user frustration.
- How does task coherence enable prediction of user behavior, and why is "mostly right, most of the time" better than asking questions?
- What is fudgeability, and why is its absence in computerized systems a key contributor to inhumanity in digital systems?
- How can a program apply decision-set reduction and preference thresholds to remember user patterns without needing to interrogate the user?
π Lecture 38 β Behavior & Form β Part VI
π Overview: This lecture explores the critical role of visual design in Human Computer Interaction, distinguishing it from visual art and explaining why many graphical user interfaces still fail despite their graphical nature. It introduces key principles of visual interface design to help create interfaces that are both aesthetically pleasing and functionally clear, emphasizing how to leverage human visual processing capabilities for better communication of software behavior.
ποΈ Topics Covered
The lecture begins by examining the difference between visual art and visual design, clarifying that designers create artifacts to meet others' goals rather than for self-expression. It then contrasts graphic design, visual interface design, and visual information design, each with distinct focuses. The core of the lecture details five principles of visual interface design: avoiding visual noise and clutter, using contrast and layering to organize elements, providing visual structure and flow, using cohesive imagery, and integrating style and function. Specific techniques like dimensional/tonal/spatial contrast, layering, figure-ground perception, and the squint test are explained in depth.
π Lecture Summary
38.1 Designing Look and Feel
Graphical User Interfaces (GUIs) are often considered superior to character-based interfaces, yet many GUIs remain difficult to use. This is because creating an effective GUI requires more than just graphics; it requires a deep understanding of visual design in the context of interaction. Visual design in interfaces is about finding the representation best suited to communicate specific information and the behavior of the software, not just about making things look pretty.
Visual Art versus Visual Design Practitioners of visual art produce artifacts to provoke an aesthetic response, serving as a means of self-expression on emotional or intellectual topics. Few constraints are imposed, and uniqueness is highly valued. In contrast, visual designers create artifacts to meet the goals of people other than themselves. They are "concerned with finding the representation best suited to the communication of some specific information." Visual interface designers specifically focus on communicating the behavior of the software they are designing.
π‘ Why this matters: Understanding this core difference is foundationalβa beautiful interface that is confusing to use is a failure of visual design, not a success of visual art.
Graphic Design and Visual Interface Design Graphic design historically focused on print media (packaging, advertising, documents). Digitally-fluent graphic designers excel at creating rich, clean, visually consistent, and aesthetically pleasing "surfaces" of an interface, including corporate branding. Their design priorities are first legibility and readability of information, then tone and style, and finally communicating behavior through affordances.
Visual interface designers share graphic design skills but focus more on the organizational aspects of the design and how affordances communicate behavior. They are more knowledgeable about principles of interaction, matching the visual structure of the interface to the logical structure of both the user's and the program's behavior. They are also concerned with communicating program states and cognitive issues like layout, grids, and figure-ground.
Visual information designers perform a similar role but for content and navigation, especially in Web design where content often outweighs function. Their primary focus is on controlling information hierarchy through visual language.
Industrial design plays a growing role in interactive products (handheld devices, appliances). Some industrial designers focus on the shape and "skins" of objects, while others focus on the logical and ergonomic mapping of physical controls to match user behaviors. As more physical artifacts become software-enabled, close collaboration between interaction, industrial, and visual designers is crucial.
38.2 Principles of Visual Interface Design
The human brain is a superb pattern-processing computer that makes sense of visual information by discerning visual patterns and establishing a system of priorities. Visual interface design must take advantage of our innate visual processing capabilities to help programs communicate their behavior and function. The key principles, based on the work of Kevin Mullet and Darrell Sano, are that visual interfaces should:
- Avoid visual noise and clutter
- Use contrast, similarity, and layering
- Provide visual structure and flow
- Use cohesive, consistent, and contextually appropriate imagery
- Integrate style and function comprehensively and purposefully
Avoid visual noise and clutter Visual noise is the result of superfluous visual elements (e.g., over-embellished 3D, overuse of rules, insufficient white space, overuse of color). This is like trying to hold a conversation in a loud restaurantβit makes communication impossible. Cluttered interfaces provide excess functionality in a constrained space, resulting in controls that visually interfere with each other and raise the cognitive load for the user.
To counter this, interfaces should use simple geometric forms, minimal contours, and less-saturated colors. Typography should be limited to one or two typefaces. Elements with a similar logical purpose should share visual attributes (shape, size, color, alignment). Elements intended to stand out should be visually contrasted. A popular technique is to remove individual elements to test their contribution to clarity.
π Definition β Leverage: Using an element in an interface for multiple, related purposes. For example, a visual symbol that communicates the type of an object in a list, which when clicked also opens a properties dialog for that object type.
π Example: Instead of having a small icon for "File Type" and a separate button to "Open Properties", a single icon (e.g., a PDF symbol) in a list next to a filename serves both purposesβit identifies the file type and, when clicked, opens the file's properties dialog. This combines two functions into one visual element.
Use contrast and layering to distinguish and organize elements Contrast serves two needs: 1) To provide visual contrast between active (manipulable) and passive (non-manipulable) elements, and 2) To contrast different logical sets of active elements. Unintentional contrast causes confusion. Proper use of contrast creates visual patterns that users can remember, allowing faster orientation and communication of function.
DIMENSIONAL, TONAL, AND SPATIAL CONTRAST
- Dimensional contrast: Using pseudo-3D to give the feel of a manual affordance. Buttons are given a raised look, while text fields are given an indented look.
- Tonal contrast: Varying hue, saturation, or value to distinguish controls from the background or to group them logically. It is best to vary along a single "axis" (hue or saturation or value). Using hue can exclude users with color perception problems; saturation or brightness is a safer alternative.
- Spatial contrast: Positioning related elements together to show task relationships. This includes grouping by position (considering eye-scanning patterns like left-to-right, top-to-bottom), shape (square checkboxes vs. round radio buttons), orientation (vertical document icons vs. horizontal folder icons), and size (for indicating importance or scope).
LAYERING Interfaces can be organized by layering visual cues. Color affects this: dark, cool, de-saturated colors recede, while light, warm, saturated colors advance. Size also affects layering: large elements advance, small ones recede. To layer effectively, use minimal contrast between items you wish to associate in a layer. Maximize differences between layers, but minimize differences within a layer.
FIGURE AND GROUND Figure refers to the visual elements that should be the focus of the user's attention, and ground is the background context. People tend to perceive light objects as figure and dark objects as ground. A successful design integrates both, with figure and ground having an equal visual weight and with the figure centered on the ground.
THE SQUINT TEST A technique to evaluate contrast, layering, and figure-ground is the squint test: Close one eye and squint at the screen to see which elements pop out, which group together, and whether figure or ground seems dominant. Other tests include viewing the design through a mirror (mirror test) or looking at it upside down to uncover imbalances in composition.
β Key Takeaways
- The primary goal of visual design in HCI is to communicate software behavior and function to the user, not just to create an aesthetically pleasing artifact. This distinguishes it from visual art.
- An effective visual interface relies on a team of designers (graphic, visual interface, visual information, industrial) each bringing specialized skills like typography, interaction principles, information hierarchy, and ergonomics.
- The five core principles for a good visual interface are: avoid noise/clutter, use contrast/layering, provide visual structure, use consistent imagery, and integrate style and function.
- Key techniques include using dimensional, tonal, and spatial contrast to distinguish active from passive elements; layering to organize information by importance; and using the squint test for self-evaluation. The concept of leverage (using one element for multiple purposes) is crucial for simplicity.
π§ Quick Revision Questions
- What is the fundamental difference between the goal of a visual artist and the goal of a visual interface designer?
- Explain the concept of "leverage" in visual interface design and give a practical example.
- List three types of contrast (dimensional, tonal, spatial) and give a concrete example of how each is used in a typical GUI to communicate function.
- How does the visual phenomenon of figure-ground affect interface design, and how can the squint test be used to evaluate it?
- According to the principles for a good visual interface, what is the problem with "visual noise" and what are three common ways it manifests in an interface?