Design Tactics - Usability (SEI)
Based on Len Bass, Bonnie E. John, Jesse Kates, Achieving Usability Through Software Architecture.
= 98 items
(filtered by ) / - General Usability Scenarios
- Aggregating DataAllow users to select and act upon arbitrary combinations of data.
- Aggregating CommandsProvide a batch or macro capability to allow users to aggregate commands.
- Canceling CommandsAllow users to stop the operation rather than wait for it to complete.
- Using Applications ConcurrentlyAllow users to work with arbitrary combinations of applications concurrently.
- Checking for CorrectnessCheck for user errors that he or she does not notice.
- Maintaining Device IndependenceReduce the severity and frequency of device conflicts.
- Evaluating the SystemInclude test points and data gathering capabilities to facilitate evaluation.
- Recovering from FailureProvide users with the means to reduce the amount of work lost from system failures.
- Retrieving Forgotten PasswordsProvide alternative, secure mechanisms to grant users access.
- Providing Good HelpHelp procedures should be context dependent and sufficiently complete to assist users in solving problems.
- Reusing InformationProvide users with automatic (e.g., data propagation) or manual (e.g., cut and paste) data transports between different parts of a system.
- Supporting International UseSystems should be easily configurable for deployment in multiple cultures.
- Leveraging Human KnowledgeStrive to develop upgrades that leverage users’ knowledge of prior systems and allow them to move quickly and efficiently to the new system.
- Modifying InterfacesEnsure that user interfaces can be easily modified.
- Supporting Multiple ActivitiesAllow the user to switch quickly back and forth between tasks.
- Navigating Within a Single ViewStrive to ensure that users can navigate within a view easily and attempt to keep wait times reasonably short.
- Observing System StateAccount for human needs and capabilities when deciding what aspects of system state to display and how to present them.
- Working at the User’s PaceAccount for human needs and capabilities when pacing the stages in an interaction. Allow users to adjust this pace as needed.
- Predicting Task DurationPresent expected task durations.
- Supporting Comprehensive SearchingAllow users to search data in a comprehensive and consistent manner by relevant criteria.
- Supporting UndoAllow the user to return to the state before that operation was performed.
- Working in an Unfamiliar ContextProvide a novice (verbose) interface to offer guidance to users operating in unfamiliar contexts.
- Verifying ResourcesVerify that all necessary resources are available before beginning an operation.
- Operating Consistently Across ViewsMake commands available based on the type and content of a user’s data, rather than the current view of that data. Inform the user how to zoom in, access the data in a more detailed view, or otherwise act on single data points.
- Making Views AccessibleMake diverse views accessible to support user’s ability to gain insight through multiple perspectives.
- Supporting VisualizationProvide a reasonable set of task-related views to enhance users’ ability to gain additional insight while solving problems.
- By Usability Benefits
- Increase individual user effectivenessSmall increases in productivity of individuals can aggregate to produce substantial benefits for an organization as a whole.
- Expedites routine performanceAlthough users know what to do to accomplish routine tasks, they will still make errors.
- Accelerates error-free portion of routine performanceThe error-free portion of routine performance is the minimum required time to accomplish a task, assuming no slips.
- Aggregating DataMake the system rather than the user responsible for iterations.
- Evaluating the SystemSystems that are easy to evaluate are easier to test (routine performance of programmers).
- Reusing InformationIt is more efficient to transport information than forcing users to re-enter it by hand.
- Supporting International UseAllows users to communicate in the language that they know best.
- Leveraging Human KnowledgeLeverages the end-user’s knowledge of how to use some feature.
- Modifying InterfacesReduce the overhead involved in making interface changes (routine performance of programmers).
- Supporting Multiple ActivitiesAllows users to tackle several tasks at once, or to open several applications concurrently to complete a single task.
- Navigating Within a Single ViewA routine activity in any complex computer systems with data sets of any size.
- Working at the User’s PaceSystems that move either too slowly or too swiftly interfere with routine performance.
- Predicting Task DurationAllows the user to do other things instead of waiting.
- Supporting Comprehensive SearchingUsing a search feature is often more efficient than perusing a large amount of material.
- Verifying ResourcesAvoids wasting the user’s time by invoking actions that cannot be completed.
- Operating Consistently Across ViewsAvoids forcing users to navigate to a specific view to perform some action.
- Making Views AccessibleAllows users to easily and consistently switch from one view to another.
- Reduces the impact of routine user errors (slips)Reducing the number of opportunities for error and better accommodate user slips by providing adequate recovery methods.
- Modifying InterfacesReducing the overhead involved in making interface changes help to reduce the impact of mistakes.
- Improves non-routine performanceIn a non-routine task, a user does not know exactly what to do and may experiment.
- Supports problem-solvingUsers employ problem-solving behavior when they do not know exactly what to do.
- Canceling CommandsAllows users to apply commands and explore without fear.
- Using Applications ConcurrentlyMake applications can work concurrently without unintended and undesirable result.
- Checking for CorrectnessCan help keep users on a more context-appropriate and direct path when problem-solving.
- Maintaining Device IndependenceAllow users to easily switch to a more familiar or desirable device.
- Reusing InformationUsers may try different applications to gain additional insight while solving problems.
- Supporting International UseAllows users to receive feedback in the language that they know best.
- Facilitates learningHumans continuously learn as they perform tasks.
- Using Applications ConcurrentlyWhen applications interfere with each other, users may learn superstitious behavior.
- Checking for CorrectnessPrevents undetected human errors to lead users down paths in the problem space that have nothing to do with solutions.
- Providing Good HelpFacilitates users to learn the correct concept or procedure.
- Supporting International UseAllows users to receive feedback in the language that they know best.
- Leveraging Human KnowledgeReduces the amount of information that users must acquire to operate their systems.
- Observing System StateLearning depends on knowing when the action produced a desired response.
- Supporting Comprehensive SearchingMake the path to success is straightforward.
- Operating Consistently Across ViewsReduces the amount of information that a user must learn to operate a given system.
- Reduces the impact of user errors caused by lack of knowledge (mistakes)Errors due to lack of knowledge are called mistakes.
- Prevents mistakesHow well a system helps to prevent mistakes.
- Aggregating DataRequires fewer human actions (e.g., typing, mouse movements) than working on each member of the aggregate.
- Aggregating CommandsRequires little thought and presents fewer opportunities for user mistakes than applying commands one by one in sequence.
- Using Applications ConcurrentlyApplication interference is an instance of a system error.
- Checking for CorrectnessHelps preventing user mistakes.
- Supporting International UseHelp users avoid linguistic mistakes.
- Leveraging Human KnowledgeUse "old" methods as a learning opportunity rather than an “error” from which the user must recover.
- Observing System StateHelps users avoid applying knowledge and procedures to an inappropriate system state.
- Predicting Task DurationThe user will not assume that inactivity indicates that the system is "hung."
- Supporting Comprehensive SearchingAutomated searching is much more accurate than visually searching a lot of material.
- Working in an Unfamiliar ContextPrivides a novice or verbose interface to give the user additional or enhanced feedback.
- Operating Consistently Across ViewsStimulates users to attempt to apply the methods that have been successful with other parts of the system when faced with a new or infrequently used view.
- Accommodates mistakesMistakes will occur if the user has the freedom to stray from a correct path.
- Aggregating Data (Dependant on Search)A robust search system can help accommodate user mistakes (forgeting the members of an aggregate).
- Aggregating CommandsA robust search system can help accommodate user mistakes (forgetting a step or the name of the macro or script).
- Canceling CommandsAllows users to abort commands they invoke through lack of knowledge.
- Checking for CorrectnessWhen systems are designed to correct errors, the effects of user mistakes can be reduced.
- Retrieving Forgotten PasswordsSupports users who lack the knowledge to access their accounts in the normal way.
- Supporting International UseHelp accommodate user mistakes by presenting error messages in the language that they know best.
- Modifying InterfacesReduces the overhead involved in making interface changes.
- Observing System StateUsers will know how to correct the mistake before continuing further down an incorrect path.
- Supporting UndoAllows users to return to the state prior to any accidental actions.
- Reduce the impact of system errorsSystems will always operate with some degree of error.
- Prevents system errorsThe number and type of error that occur as a user performs a task.
- Maintaining Device IndependenceDevice errors are system errors.
- Verifying ResourcesSome system errors result applications vie for a given resource.
- Tolerates system errorsSystem errors WILL occur.
- Canceling CommandsAllows users to abort commands that aren’t working properly.
- Recovering from FailureHelps users tolerate system mishaps by facilitating data restoration.
- Increase user confidence and comfortSystem errors will occur.
- Observing System StateAvoids making the user hesitate to use the system or avoid it altogether.
- Working at the User’s PaceAvoids making users feel frustrated or hurried.