Achieving Usability Through Software Architecture
4 Categorization By Usability Benefit
As stated in Section 3, we organized the general usability scenarios into a hierarchy by benefit to the user. The hierarchy that results was presented in Table 1, is shown again as Table 2.
Table 2: Usability Benefits Hierarchy
Increases individual user effectiveness
Expedites routine performance
Accelerates error-free portion of routine performance
Reduces the impact of routine user errors (slips)
Improves non-routine performance
Supports problem-solving
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Accommodates mistakes
Reduces the impact of system errors
Prevents system errors
Tolerates system errors
Increases user confidence and comfort
This hierarchy is of benefit as a screening mechanism for the scenario. That is, if you are a system designer or evaluator, you can characterize the usability requirements for your system in terms of the categories in the hierarchy. The scenarios that appear are those that may be necessary to achieve your requirements.
We now enumerate the scenarios again and justify placing the scenarios in particular categories. A single scenario may appear in multiple categories. For example, undo supports routine performance (correcting slips) but it also supports exploration (the user can always recover from a test path).
The form of each section is the same. We repeat the scenario and present its entry in the benefit hierarchy. We then provide a brief argument that justifies the scenarios placement in the hierarchy.
4.1 Aggregating Data
A user may want to perform one or more actions on more than one object. For example, an Adobe® Illustrator® user may want to enlarge many lines in a drawing. It could become tedious to perform these actions one at a time. Furthermore, the specific aggregations of actions or data that a user wishes to perform cannot be predicted; they result from the requirements of each task. Systems, therefore, should allow users to select and act upon arbitrary combinations of data.
Allocation to Benefit Hierarchy
Increases individual user effectiveness
Expedites routine performance
Accelerates error-free portion of routine performance
Data aggregation makes the system rather than the user responsible for iteration. This often saves time, thereby accelerating routing performance [Bhavnani 2000].
Increases individual user effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Operating on aggregates usually requires fewer human actions (e.g., typing, mouse movements) than working on each member of the aggregate in turn. Since performing more actions introduces more opportunities for error, the presence of data aggregation functionality can prevent slips [Miller 1987]. Some opportunities for error still exist, however, and errors committed on aggregates can be "larger" in a sense. For instance, if you change a Microsoft Word style to italic when you intended to enter bold, you have changed text throughout the document instead of only in one place. Still, aggregation functionality may facilitate recovery from such mistakes, so error analysis might be useful to understand the tradeoffs particular to a given system. Generally, the benefits of supporting aggregation far outweigh the risks.
Increases individual user effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes (Dependant on Search)
When working with aggregates, a robust search system can help accommodate user mistakes. In particular, a user may forget the members of an aggregate. To accommodate such errors, the user must be able to search by aggregate. Other mistakes can be accommodated by enabling the system to search by the criteria that users employed to create aggregates (type, modification date, etc.).
4.2 Aggregating Commands
A user may want to complete a long-running, multi-step procedure consisting of several commands. For example, a psychology researcher may wish to execute a batch of commands a data file during analysis. It could become tedious to invoke these commands one at a time, or to provide parameters for each command as it executes. If the computer is unable to accept the required inputs for this procedure up front, the user will be forced to wait for each input to be requested. Systems should provide a batch or macro capability to allow users to aggregate commands.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Accelerates error-free portion
The ability to aggregate commands enhances routine performance by allowing users to work on multiple tasks at the same time. For example, a user can get coffee while the computer prints a queue of documents. (This is an aggregation of individual print commands.)
Increases individual effectiveness
Expedites routine performance
Reduces impact of slips
Executing a macro, batch, or script requires fewer human actions (e.g., typing, mouse movements) than executing commands in turn. Since performing more actions introduces more opportunities for error, the presence of command aggregation functionality can prevent slips.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Executing a macro, batch, or script requires little thought and presents fewer opportunities for user mistakes than applying commands one by one in sequence. Thus, once the macro or script is written, tested, and debugged, subsequent use of that macro or script will be virtually error-free. Analogous to the problem with aggregation of data, there is the danger of producing an incorrect macro or script that will have far reaching consequences, but the potential for benefit provided by this capability usually far outweighs the potential for damage.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes (Dependent on Search)
When working with command aggregates, a robust search system can help accommodate user mistakes. In particular, a user may forget the name of the macro or script. The forgetting of the name of the macro or script is a trade-off with forgetting the elements included in the macro or script. To accommodate the forgetting of the name of the macro or script, the user must be able to search by whatever criteria users might employ (content, type of file it works on, modification date, etc.) to create command aggregates.
4.3 Canceling Commands
A user invokes an operation, then no longer wants the operation to be performed. The user now wants to stop the operation rather than wait for it to complete. It does not matter why the user launched the operation. The mouse could have slipped. The user could have mistaken one command for another. The user could have decided to invoke another operation. For these reasons (and many more), systems should allow users to cancel operations.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Reduces impact of slips
Cancellation reduces the impact of slips by allowing users to revoke accidental commands.
Increases individual effectiveness
Improves non-routine performance
Supports problem-solving
Cancellation facilitates problem-solving by allowing users to apply commands and explore without fear, because they can always abort their actions.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
Cancellation accommodates user mistakes by allowing users to abort commands they invoke through lack of knowledge.
Reduces the impact of system errors
Tolerates system errors
Cancellation helps users tolerate system error by allowing users to abort commands that aren’t working properly (for example, a user cancels a download because the network is jammed).
4.4 Using Applications Concurrently
A user may want to work with arbitrary combinations of applications concurrently. These applications may interfere with each other. For example, some versions of IBM® ViaVoice and Microsoft® Word contend for control of the cursor with unpredictable results. Systems should ensure that users can employ multiple applications concurrently without conflict.
(See: Supporting Multiple Activities)
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Accelerates error-free portion
When applications interfere with each other, they disrupt routine performance. Also, when systems are designed to support concurrent applications, users may switch more easily from task to task or work on several tasks at the same time.
Increases individual effectiveness
Improves non-routine performance
Supports problem-solving
Interfering applications may inhibit a user’s ability to solve problems. A user may take an action while exploring a path that has an unintended and undesirable result because of an application interaction, rather than because the action itself was incorrect. This may cause the user to abandon paths of exploration that would have led to solutions.
Increases individual effectiveness
Improves non-routine performance
Facilitates learning
When applications interfere with each other, users may learn superstitious behavior. For example, a user may think that a system crash was caused by a personal mistake, when in fact two applications interfered with each other.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Application interference is an instance of a system error. Systems that are designed to support concurrent applications prevent this problem.
4.5 Checking for Correctness
A user may make an error that he or she does not notice. However, human error is frequently circumscribed by the structure of the system, the nature of the task at hand, and by predictable perceptual, cognitive, and motor limitations. For example, users often type "hte" instead of "the" in word processors. The frequency of the word "the" in English and the fact that "hte" is not an English word, combined with the frequency of typing errors that involve switching letters typed by alternate hands, make automatically correcting to "the" almost always appropriate. Computer-aided correction becomes both possible and appropriate under such circumstances. Depending on context, error correction can be enforced directly (e.g., automatic text replacement, fields that only accept numbers) or suggested through system prompts.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Reduces impact of slips
When systems are designed to correct very predictable slips (e.g., typing "hte" instead of "the"), the effects of user slips can be reduced.
Increases individual effectiveness
Improves non-routine performance
Supports problem-solving
Since undetected human errors can lead users down paths in the problem space that have nothing to do with solutions, correctness checking can help keep users on a more context-appropriate and direct path when problem-solving.
Increases individual effectiveness
Improves non-routine performance
Facilitates learning
As described above, undetected human errors can lead users down paths in the problem space that have nothing to do with solutions. Correctness checking can help keep users on a more context appropriate and direct path when problem solving. Direct paths are easier to learn. Furthermore, a system that corrects errors and informs users of their mistakes can facilitate learning by providing additional feedback, and sometimes even the correct answer. For example, a person can learn the correct spelling of a word from a spell checker.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
When systems are designed to correct errors, user mistakes can be prevented. For example, a system could ensure that only certain numerals are entered into the ID search field of a document.
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
As with slips, when systems are designed to correct errors, the effects of user mistakes can be reduced. Finding and fixing mistakes also can be much easier. For instance, a user can spell a word by guessing, use the automatically generated suggestions of a spell-checker to find the correct spelling, and insert it.
4.6 Maintaining Device Independence
A user attempts to install a new device. The device may conflict with other devices already present in the system. Alternatively, the device may not function in certain specific applications. For example, a microphone that uses the Universal Serial Bus (USB) may fail to function with older sound software. Systems should be designed to reduce the severity and frequency of device conflicts. When device conflicts occur, the system should provide the information necessary to either solve the problem or seek assistance. (Devices include printers, storage/media, and I/O apparatus.)
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Accelerates error–free portion of routine performance
If the user swaps peripherals frequently, (for example, swapping a CD-ROM drive for a 3.5" drive) then device independence will accelerate routine performance.
Increases individual effectiveness
Improves non-routine performance
Supports problem-solving
If a user encounters an unfamiliar or undesirable device in an occasional situation, device independence will allow the user easily to switch to a more familiar or desirable device. For example, a user with Repetitive Stress Injury may have a special keyboard. If it can be transported and installed to any system easily, the user will be able to type anywhere.
Reduces impact of system errors
Prevents system errors
Device errors are system errors. Systems that are designed to support multiple, independent devices prevent these errors from occurring.
4.7 Evaluating the System
A system designer or administrator may be unable to test a system for robustness, correctness, or usability in a systematic fashion. For example, the usability expert on a development team might want to log test users’ keystrokes, but may not have the facilities to do so. Systems should include test points and data gathering capabilities to facilitate evaluation.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Expedites routine performance
Accelerates error-free portion of routine performance
Testing is a routine part of programming. Systems that are easy to evaluate are easier to test. This, in turn, can accelerate the routine performance of software developers.
Increases individual effectiveness
Improves non-routine performance
Supports problem solving
When testing uncovers a bug, software developers must problem-solve. Systems that are easy to evaluate enable programmers quickly to see the results of the changes they make at various checkpoints.
4.8 Recovering From Failure
A system may suddenly stop functioning while a user is working. Such failures might include a loss of network connectivity or hard drive failure in a user’s PC. In these or other cases, valuable data or effort may be lost. Users should be provided with the means to reduce the amount of work lost from system failures.
Allocation to Benefit Hierarchy
Reduces impact of system errors
Tolerates system errors
System failure is the most extreme case of system error. Though systems that support failure recovery are no less prone to failure, they at least help users tolerate such mishaps by facilitating data restoration.
4.9 Retrieving Forgotten Passwords
A user may forget a password. Retrieving and/or changing it may be difficult or may cause lapses in security. Systems should provide alternative, secure mechanisms to grant users access. For example, some online stores ask each user for a maiden name, birthday, or the name of a favorite pet in lieu of a forgotten password.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
When users forget passwords, they lack the knowledge to access their accounts in the normal way. Providing alternative methods of entering protected sites, or means to retrieve forgotten passwords, helps to accommodate such errors.
4.10 Providing Good HelpA user needs help. The user may find, however, that a system’s help procedures do not adapt adequately to the context. For example, a user’s computer may crash. After rebooting, the help system automatically opens to a general table of contents rather than to a section on restoring lost data or searching for conflicts. Help content may also lack the depth of information required to address the user’s problem. For example, an operating system’s help area may contain an entry on customizing the desktop with an image, but may fail to provide a list of the types of image files that can be used. Help procedures should be context dependent and sufficiently complete to assist users in solving problems.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Improves non-routine performance
Supports problem solving
Feedback is essential to human problem-solving. Thus, users may solve problems more effectively by seeking additional feedback from context dependent help systems. If the help is correct, understandable, and delivered in the right context, it can simply tell the user what to do to solve the problem.
Increases individual effectiveness
Improves non-routine performance
Facilitates learning
As with problem solving, feedback is an essential component of human learning processes. Users may learn more effectively by seeking additional feedback from context–dependent help systems. If the help is correct, understandable, and delivered in the right context, the user can learn the correct concept or procedure from the help material.
4.11
Reusing Information
A user may wish to move data from one part of a system to another. For example, a telemarketer may wish to move a large list of phone numbers from a word processor to a database. Re-entering this data by hand could be tedious and/or excessively time-consuming. Users should be provided with automatic (e.g., data propagation) or manual (e.g., cut and paste) data transports between different parts of a system. When such transports are available and easy to use, the user’s ability to gain insight through multiple perspectives and/or analysis techniques will be enhanced.
Allocation to Benefit Hierarchy
Increases individual effectiveness
In most cases, it is more efficient for systems to transport information from place to place than it is for users to re-enter this information by hand. Thus, systems that support information reuse accelerate routine performance.
Increases individual effectiveness
Automatic data transportation and/or re-entry require fewer human actions (e.g., typing, mouse movements) than re-entering data by hand. Since performing more actions introduces more opportunities for error, systems that support information reuse can prevent slips.
Increases individual effectiveness
When users can import and export data from one place to another easily, they may try different applications to gain additional insight while solving problems. For example, a user may export data from a traditional text–based statistics application to a data visualization application. Thus, systems that support information reuse facilitate problem-solving.
4.12
Supporting International Use
A user may want to configure an application to communicate in his or her language or according to the norms of his or her culture. For example, a Japanese user may wish to configure the operating system to support a different keyboard layout. However, an application developed in one culture may contain elements that are confusing, offensive, or otherwise inappropriate in another. Systems should be easily configurable for deployment in multiple cultures.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Systems that support internationalization accelerate users’ performance by allowing them to communicate with the system in the language that they know best.
Increases individual effectiveness
Systems that support internationalization help accommodate users’ slips by presenting error messages in the language that they know best.
Increases individual effectiveness
Systems that support internationalization facilitate problem-solving by allowing users to receive feedback from the system in the language that they know best.
Increases individual effectiveness
Systems that support internationalization facilitate learning by allowing users to receive feedback from the system in the language that they know best.
Increases individual effectiveness
Systems that support internationalization help users avoid linguistic mistakes by allowing them to communicate with the system in the language that they know best.
Increases individual effectiveness
Systems that support internationalization help accommodate user mistakes by presenting error messages in the language that they know best. Incomprehensible error messages can compound existing misunderstanding.
Increases confidence and comfort
Being able to communicate with a system in the language that a user knows best reduces frustration and increases user satisfaction by affirming the importance of the user’s national or cultural identify.
People use what they already know when approaching new situations. Such
situations may include using new applications on a familiar platform, a new
version of a familiar application, or a new product in an established product
line.
New approaches usually bring new functionality or power. When, however,
users are unable to apply what they already know, a corresponding cost in
productivity and training time is incurred. For example, new versions of
applications often assign items to different menus or change their names. As a
result, users skilled in the older version are reduced to the level of novices
again, searching menus for the function they know exists.
System designers should strive to develop upgrades that leverage users’
knowledge of prior systems and allow them to move quickly and efficiently to
the new system.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Leveraging human knowledge can directly benefit both software developers and users. For example, reusing the code for a search engine’s interface leverages the end-user’s knowledge of how to use the search engine. At the same time, it reduces the amount of new code that has to be written.
Increases individual effectiveness
When problem solving, users first apply the methods that they have used successfully in other parts of a system. By leveraging human knowledge, designers increase the likelihood that a user’s early explorations will be effective.
Increases individual effectiveness
By leveraging human knowledge, designers reduce the amount of information that users must acquire to operate their systems. Thus, users can devote their time to learning more advanced techniques, techniques that match their interests. The quality of their learning is therefore increased.
Increases individual effectiveness
If the system is designed so that old methods are recognized as legitimate (rather than as "errors"), leveraging human knowledge can prevent errors. It is not necessary for the new system to react the same way as the old system did. Rather, the system could be designed to do something sensible with old methods (for example., bring up context sensitive help that directs the user to the new way of accomplishing the goal). Thus, using old methods becomes a learning opportunity rather than an "error" from which the user must recover.
4.14
Modifying Interfaces
Iterative design is the lifeblood of current software development practice, yet a system developer may find it prohibitively difficult to change the user interface of an application to reflect new functions and/or new presentation desires. System designers should ensure that their user interfaces can be easily modified.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Developers must routinely modify the appearance and functionality of visual interfaces. Systems that reduce the overhead involved in making such changes accelerate the routine performance of programmers.
Increases individual effectiveness
The need to modify a user interface can arise from a lack of knowledge on the part of the development team regarding user needs and expectations. In such cases, systems that reduce the overhead involved in making interface changes help to reduce the impact of mistakes.
4.15
Supporting Multiple Activities
Users often need to work on multiple tasks more or less simultaneously (e.g., check mail and write a paper). A system or its applications should allow the user to switch quickly back and forth between these tasks.
Allocation to Benefit Hierarchy
Increases individual effectiveness
During the course of routine work, users may want to tackle several tasks at once, or to open several applications concurrently to complete a single task. Users may also wish to work on a different task while waiting for the computer to complete an operation. For example, a user may want to read email while a Web page loads. Systems that support multiple activities facilitate and increase routine performance.
4.16
Navigating Within a Single View
A user may want to navigate from data visible on-screen to data not currently displayed. For example, he or she may wish to jump from the letter "A" to the letter "Q" in an online encyclopedia without consulting the table of contents. If the system takes too long to display the new data or if the user must execute a cumbersome command sequence to arrive at her or his destination, the user’s time will be wasted. System designers should strive to ensure that users can navigate within a view easily and attempt to keep wait times reasonably short.
(See: Working at the User’s Pace)
Allocation to Benefit Hierarchy
Increases individual effectiveness
This is a ubiquitous routine activity in complex computer systems with data sets of any size (e.g., a paper more than a page long, a spreadsheet larger than the screen). Making such navigation possible, easy, and fast, speeds routine performance of almost any task.
4.17
Observing System State
A user may not be presented with the system state data necessary to operate the system (e.g., uninformative error messages, no file size given for folders). Alternatively, the system state may be presented in a way that violates human tolerances (e.g., is presented too quickly for people to read. See: Working at the User’s Pace). The system state may also be presented in an unclear fashion, thereby confusing the user. System designers should account for human needs and capabilities when deciding what aspects of system state to display and how to present them.
A special case of Observing System State occurs when a user is unable to determine the level of security for data entered into a system. Such experiences may make the user hesitate to use the system or avoid it altogether.
Allocation to Benefit Hierarchy
Increases individual effectiveness
When the inevitable slip happens, if the system state is readily and easily observed, the user will know how to correct the slip before continuing further down an incorrect path.
Increases individual effectiveness
Human problem-solving depends on knowledge of current state (where you are), the goal state (where you want to be), and awareness of the range of available actions. Thus, being able to observe the current system state is central to the process of problem solving.
Increases individual effectiveness
Learning correct actions depends on knowing the system state when the action produced a desired response. Thus, if the system state is obscured or unobservable, the user’s ability to learn will be inhibited.
Increases individual effectiveness
A common type of mistake occurs when a user applies knowledge and procedures appropriate to one system state to a different, inappropriate, system state. Making the system state easily available to users reduces the likelihood of this type of mistake.
Increases individual effectiveness
If the system state is readily and easily observed, the user will know how to correct the mistake before continuing further down an incorrect path.
Increases confidence and comfort
This applies to the special case of the user being unable to determine the level of security for data entered into a system. Such experiences may make the user hesitate to use the system or avoid it altogether. Thus, systems that prominently display security policies and security levels (both of which are features of system state) increase user confidence and comfort.
4.18
Working at the User’s Pace
A system might not accommodate a user’s pace in performing an operation. This may make the user feel hurried or frustrated. For example, ATMs often beep incessantly when a user "fails" to insert an envelope in time. Also, Microsoft Word’s scrolling algorithm does not take system speed into account and becomes unusable on fast systems (the data flies by too quickly for human comfort). Systems should account for human needs and capabilities when pacing the stages in an interaction. Systems should also allow users to adjust this pace as needed.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Systems that move either too slowly or too swiftly (as in the scrolling example above) interfere with routine performance. The user may actually change to a less-efficient method to work around the pace mismatch.
Increases individual effectiveness
Systems that move too quickly may push users to, or past, their perceptual limits and increase the likelihood of slips. For example, scrollbars that do not take system speed into account may move too quickly on fast systems and cause users to make errors when navigating documents.
Increases confidence and comfort
Even in cases where errors are not introduced, systems that do not support pace tolerance may make users feel frustrated or hurried.
4.19
Predicting Task Duration
A user may want to work on another task while a system completes a long running operation. For example, an animator may want to leave the office to make copies or to eat while a computer renders frames. If systems do not provide expected task durations, users will be unable to make informed decisions about what to do while the computer "works." Thus, systems should present expected task durations.
Allocation to Benefit Hierarchy
Increases individual effectiveness
If performing long tasks is part of routine performance, allowing the user to do other things instead of waiting accelerates overall performance.
Increases individual effectiveness
If the system accurately predicts the time it will take to accomplish an operation, the user will not assume that inactivity indicates that the system is "hung." Thus, the user will not make the mistake of canceling the operation or rebooting the machine.
4.20
Supporting Comprehensive Searching
A user wants to search some files or some aspects of those files for various types of content. For example, a user may wish to search text for a specific string or all movies for a particular frame. Search capabilities may be inconsistent across different systems and media, thereby limiting the user’s opportunity to work. Systems should allow users to search data in a comprehensive and consistent manner by relevant criteria.
Allocation to Benefit Hierarchy
Increases individual effectiveness
During routine work, using a search feature is often more efficient than perusing a large amount of material. Thus, systems that support search accelerate routine performance.
Increases individual effectiveness
People solve problems more easily if the path to success is straightforward. Systems that support search can facilitate problem-solving by helping users stay on track. For example, users often employ searches in online help systems to find relevant information.
Increases individual effectiveness
People learn more easily if the path to success is straightforward. Systems that support search can facilitate learning by helping users stay on track. (See example above.)
Increases individual effectiveness
Automated searching is much more accurate than visually searching a lot of material. Therefore, supporting search prevents mistakes attributed to overlooking a target item.
4.21
Supporting Undo
A user performs an operation, then no longer wants the effect of that operation. For example, a user may accidentally delete a paragraph in a document and wish to restore it. The system should allow the user to return to the state before that operation was performed. Furthermore, it is desirable that the user then be able to undo the prior operation (multi-level undo).
Allocation to Benefit Hierarchy
Increases individual effectiveness
Undo reduces the impact of user slips by allowing users to return to the state prior to any accidental actions.
Increases individual effectiveness
Undo facilitates problem-solving by allowing users to apply commands and explore without fear, because they can always return to the previous state.
Increases individual effectiveness
Undo accommodates user mistakes by allowing users to return to the state prior to any accidental actions.
4.22
Working in an Unfamiliar Context
A user needs to work on a problem in a different context. Discrepancies between this new context and the accustomed one may interfere with the user’s ability to work. For example, a clerk in business office A wants to post a payment for a customer of business unit B. Each business unit has a unique user interface, and the clerk has only used unit A’s previously. The clerk may have trouble adapting to business unit B’s interface (same system, unfamiliar context). Systems should provide a novice (verbose) interface to offer guidance to users operating in unfamiliar contexts.
Allocation to Benefit Hierarchy
Increases individual effectiveness
A novice or verbose interface can support problem-solving by giving the user the additional or enhanced feedback needed to consider various options.
Increases individual effectiveness
A novice or verbose interface can give the user additional or enhanced feedback. This information will increase the user’s knowledge and reduce the likelihood of mistakes.
4.23
Verifying Resources
An application may fail to verify that necessary resources exist before beginning an operation. This failure may cause errors to occur unexpectedly during execution. For example, some versions of Adobe® PhotoShop® may begin to save a file only to run out of disk space before completing the operation. Applications should verify that all necessary resources are available before beginning an operation.
Allocation to Benefit Hierarchy
Increases individual effectiveness
Routine performance can be compromised if a system wastes the user’s time by invoking a sequence of actions that cannot be completed. Systems that verify resources sidestep this problem.
Reduces impact of system errors
Some system errors result when one or more components or applications vie for a given resource. Systems that verify resources avoid this problem.
4.24
Operating Consistently Across Views
A user may become confused by functional deviations between different views of the same data. Commands that had been available in one view may become unavailable in another or may require different access methods. For example, users cannot run a spell check in the Outline View utility found in a mid-90’s version of Microsoft Word. Systems should make commands available based on the type and content of a user’s data, rather than the current view of that data, as long as those operations make sense in the current view.
For example, allowing users to perform operations on individual points in a scatter plot while viewing the plot at such a magnification that individual points cannot be visually distinguished does not make sense. A naïve user is likely to destroy the underlying data. The system should prevent selection of single points when their density exceeds the resolution of the screen, and inform the user how to zoom in, access the data in a more detailed view, or otherwise act on single data points.
(See: Providing Good Help and
Supporting Visualization)
Allocation to Benefit Hierarchy
Increases individual effectiveness
If all views in an application afford the same operations, routine performance will be enhanced; users will no longer need to navigate to a specific view to perform some action.
Increases individual effectiveness
When problem solving, users first apply the methods that they have used successfully in other parts of a system. By making all views operate consistently, designers increase the likelihood that a user’s early explorations in a given view will be effective, thereby enhancing the user’s ability to solve problems.
Increases individual effectiveness
By making all views operate consistently, designers reduce the amount of information that a user must learn to operate a given system.
Increases individual effectiveness
When faced with a new or infrequently used view, users will attempt to apply the methods that have been successful with other parts of the system. When discrepancies between the operations afforded by different views are reduced, the likelihood that users will make such mis-application mistakes is also reduced.
4.25
Making Views Accessible
A user may want to see data from another point of view. For example, a user may wish to see the outline of a long document and the details of the prose. If certain views become unavailable in certain modes of operation, or if switching between views is cumbersome, the user’s ability to gain insight through multiple perspectives will be constrained.
Allocation to Benefit Hierarchy
Increases individual effectiveness
If users cannot easily and consistently switch from one view to another in an application and switching is frequently needed to do the task, routine performance will be compromised.
Increases individual effectiveness
If switching between views is easy and fast, users are more likely to look at their work from different viewpoints and may gain additional insight while solving problems. Thus, systems that make views accessible enhance problem-solving.
A user wishes to see data from a different viewpoint. Systems should provide a reasonable set of task-related views to enhance users’ ability to gain additional insight while solving problems. For example, Microsoft Word provides several views to help users compose documents, including Outline and Page Layout modes.
Increases individual effectiveness
Users can employ multiple views to gain additional insight while solving problems. These multiple perspectives can effectively increase both the quality and quantity of the feedback the user receives. Thus, systems that support visualization enhance problem solving.
Expedites routine performance
Accelerates error-free portion of routine performance
Expedites routine performance
Reduces impact of slips
Improves non-routine performance
Supports problem-solving
Expedites routine performance
Accelerates error-free portion of routine performance
Expedites routine performance
Reduces impact of slips
Improves non-routine performance
Supports problem-solving
Improves non-routine performance
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Improves non-routine performance
Supports problem solving
Improves non-routine performance
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Reduces the impact of routine user errors (slips)
Accommodates mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Expedites routine performance
Accelerates error-free portion of routine performance
Expedites routine performance
Reduces impact of slips
Improves non-routine performance
Supports problem solving
Improves non-routine performance
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Expedites routine performance
Reduces impact of slips
Expedites routine performance
Accelerates error-free portion of routine performance
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Improves non-routine performance
Supports problem solving
Improves non-routine performance
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Expedites routine performance
Reduces impact of slips
Improves non-routine performance
Supports problem solving
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Accommodates mistakes
Improves non-routine performance
Supports problem solving
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Prevents system errors
Expedites routine performance
Accelerates error-free portion of routine performance
Improves non-routine performance
Supports problem solving
Improves non-routine performance
Facilitates learning
Reduces the impact of user errors caused by lack of knowledge (mistakes)
Prevents mistakes
Expedites routine performance
Accelerates error-free portion of routine performance
Improves non-routine performance
Supports problem solving
Improves non-routine performance
Supports problem solving
[Title Page]
[Abstract]
[Figures]