User Interface Design - How Can It Be Improved?

By

Hugh Jackson

Contents
Introduction

       When user interfaces were originally designed there was little effort put into what the user saw in front of them. Character-based interfaces on a traditional alphanumeric full-screen terminal with a keyboard and function keys were the norm, and people accepted that this was the best they were going to get. However, as computing popularity increased, questions started to be asked about how things could be improved - how could you stop people making mistakes when they use a computer? With advances in technology being made in leaps and bounds, it soon became possible to start implementing some sort of interface that would improve the situation. Great efforts have been made to try to find ways of maximizing throughput and efficiency, of enhancing its 'usability'.

Usability Inspection

       Usability inspection is the generic name for a set of methods that are all based on having evaluators inspect a user interface trying to find usability problems in the design. Many inspection methods can used in the inspection of user interface specifications that have not necessarily been implemented yet, meaning that inspection can be performed early in the user interface's lifecycle.

  • Heuristic evaluation is the most informal method and involves having usability specialists judge whether each dialogue element follows established usability principles (the "heuristics").
  • Heuristic estimation is a variant in which the inspectors are asked to estimate the relative usability of two (or more) designs in quantitative terms (typically expected user performance).
  • Cognitive walkthrough uses a more explicitly detailed procedure to simulate a user's problem-solving process at each step through the dialogue, checking if the simulated user's goals and memory content can be assumed to lead to the next correct action.
  • Pluralistic walkthrough uses group meetings where users, developers, and human factors people step through a scenario, discussing each dialogue element.
  • Feature inspection lists sequences of features used to accomplish typical tasks, checks for long sequences, cumbersome steps, steps that would not be natural for users to try, and steps that require extensive knowledge/experience in order to assess a proposed feature set.
  • Consistency inspection has designers who represent multiple other projects inspect an interface to see whether it does things in the same way as their own designs.
  • Standards inspection has an expert on an interface standard inspect the interface for compliance.
  • Formal usability inspection combines individual and group inspections in a six-step procedure with strictly defined roles to with elements of both heuristic evaluation and a simplified form of cognitive walkthroughs.

           Heuristic evaluation, heuristic estimation, cognitive walkthrough, feature inspection, and standards inspection normally have the interface inspected by a single evaluator at a time (though heuristic evaluation, which I will look at in more detail, is based on combining inspection reports from a set of independent evaluators to form the list of usability problems and heuristic estimation involves computing the mean of the individual estimates). In contrast, pluralistic walkthrough and consistency inspection are group inspection methods. I shall look at heuristic evaluation further because it seems to provide large scope for study.

    Heuristic Evaluation

           Heuristic evaluation is one of three steps that together define 'discount usability engineering' [Nielsen 1989b, 1990a, 1993]. One important reason usability engineering, the process of creating systems through usability inspection, is not used in general is the cost of using the techniques. British studies [Bellotti 1988] indicate that many developers don't use usability engineering because HCI (human-computer interaction) methods are seen as too time consuming and expensive and because the techniques are often intimidating in their complexity. The "discount usability engineering" approach is intended to address these two issues. It is a simpler methods than most, and thus stands a much better chance of actually being used in practical design situations.

           The "discount usability engineering" method is based on the use of the following three techniques:

  • Scenarios        Scenarios are a special kind of prototyping as shown in Figure 1. The entire idea behind prototyping is to cut down on the complexity of implementation by eliminating parts of the full system. Horizontal prototypes reduce the level of functionality and result in a user interface surface layer, while vertical prototypes reduce the number of features and implement the full functionality of those chosen (i.e. we get a part of the system to play with).
    Scenarios are prototypes that have been limited both horizontally and vertically
    Figure 1
    The concept of a scenario compared to vertical and horizontal prototypes as ways to make rapid prototyping simpler.

  • Simplified thinking aloud        Thinking aloud studies are conducted with psychologists or user interface experts as experimenters who videotape the subjects and perform detailed protocol analysis. It is simply a form of user testing where you bring in some real users, give them some typical test tasks, and ask them to think out loud while they perform the tasks.

  • Heuristic evaluation        Most user interface standards and collections of usability guidelines typically have in the order of one thousand rules to follow and are therefore seen as intimidating by developers. For the discount method Nielson, in his paper "Enhancing the Explanatory Power of Usability Heuristics", developed a set of 10 heuristics from examining a database of 249 usability problems. He considered them to be capable of explaining nearly all usability problems encountered in HCI. They are as follows:

  • Visibility of system status - The system should always keep users informed about what is going on, through appropriate feedback within reasonable time.
  • Match between system and the real world - The system should speak the users' language, with words, phrases and concepts familiar to the user, rather than system-oriented terms. Follow real-world conventions, making information appear in a natural and logical order.
  • User control and freedom - Users often choose system functions by mistake and will need a clearly marked "emergency exit" to leave the unwanted state without having to go through an extended dialogue. Support undo and redo.
  • Consistency and standards - Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions.
  • Error prevention - Even better than good error messages is a careful design which prevents a problem from occurring in the first place.
  • Recognition rather than recall - Make objects, actions, and options visible. The user should not have to remember information from one part of the dialogue to another. Instructions for use of the system should be visible or easily retrievable whenever appropriate.
  • Flexibility and efficiency of use - Accelerators -- unseen by the novice user -- may often speed up the interaction for the expert user such that the system can cater to both inexperienced and experienced users. Allow users to tailor frequent actions.
  • Aesthetic and minimalist design - Dialogues should not contain information which is irrelevant or rarely needed. Every extra unit of information in a dialogue competes with the relevant units of information and diminishes their relative visibility.
  • Help users recognize, diagnose, and recover from errors - Error messages should be expressed in plain language (no codes), precisely indicate the problem, and constructively suggest a solution.
  • Help and documentation - Even though it is better if the system can be used without documentation, it may be necessary to provide help and documentation. Any such information should be easy to search, focused on the user's task, list concrete steps to be carried out, and not be too large.

    Conclusion

           It is obvious that a lot of companies do not yet implement any kind of advanced usability engineering approach when designing their systems. Even the biggest software developers have only embraced the approached within the past few years. Microsoft, for example, have made four major changes recently in their approach to usability: Use of heuristic evaluation, use of "discount" user testing with small sample sizes, contextual inquiry, and use of paper mock-ups as low-fidelity prototypes.

           One of the fundamental things about usability engineering is to remember that "anything is better than nothing" when it comes to usability. Therefore, companies should focus on getting started by using a minimum of usability methods. Simple usability methods can be a way for a company to gradually build up, starting with the bare minimum and gradually progressing to a more refined lifecycle approach, where usability engineering is used in every stage of development.

    Bibliography

  • Nielsen, J. (1994a). Enhancing the explanatory power of usability heuristics. Proc. ACM CHI'94 Conf. (Boston, MA, April 24-28), 152-158.
  • Nielsen, J. (1994b). Heuristic evaluation. In Nielsen, J., and Mack, R.L. (Eds.), Usability Inspection Methods. John Wiley & Sons, New York, NY.
  • Nielsen, J. (1992c). Finding usability problems through heuristic evaluation. Proc. ACM CHI'92 (Monterey, CA, 3-7 May), 373-380.
  • Gould, J. D., and Lewis, C. H. (1985). Designing for usability: Key principles and what designers think. Communications of the ACM 28, 3 (March), 300-311.