Previous Table of Contents Next


4.2. GRAEFE (CHAPTER 3)

Graefe proposes that the design gap lies between various representations used in the design process (i.e., between a represented world and a representing world). As with many other cognitive tasks, bridging the gap is a process of transforming various representations from one to another, in this case, beginning with user work descriptions and ending with an interface design. He discusses a theoretical framework in which he specifies a series of representations and the transformations that lead from one to the next. This process is shaped by mediating abstractions such as metaphors and by the rules governing the chosen user interface paradigm.

The context of Graefe’s discussion is a system management application to be used for monitoring hardware and software processing resources, typically functioning as servers within a computing environment. Scenarios provide content and structure for the subsequent steps, beginning with the development of use-cases, which define the high-level system interactions, the setting of usability goals, and the development of low- and high-fidelity prototypes. Specific user scenarios are gathered from interviews with users and from direct observations of their work. Interviews are also conducted with others involved in the context of use (e.g., managers).

From scenarios, Graefe generates use-cases, which are defined as “a sequence of transactions in a system whose task is to yield a result of measurable value to an individual actor of the system”. Initially, a use-case is defined at a high level of task interaction, then extensions are developed, which account for more detailed subtasks. The use-cases capture the users’ work, and Graefe describes how the designer’s task of creating a user interface is facilitated by the use of effective meditating representations.

Both the user scenarios and use-cases contain descriptions of user objects and are the source of metaphors defining the contents of the interface. This interface is captured first in a paper prototype storyboard, which is reviewed with users. These data are used to create a computer simulation prototype that can be tested for more detailed feedback. Graefe concludes that iterative, user-centered design can be thought of as a corrective measure for biases that occur in more traditional software development processes. He suggests some rules-of-thumb for successful design practice.

4.3. LUDOLPH (CHAPTER 4)

Ludolph contends that people use models to explain complex systems. He therefore bases his approach to interface design on the construction of models and their transformation from one into another until there is finally a finished design. He begins with background information, transforms that into an essential model, transforms the essential model into a user’s model, and finally, transforms the user’s model into the user interface presentation and interaction elements. It is this series of transformations that allows the designer to bridge the gap between user requirements and the finished design.

The context for Ludoph’s discussion is the development of an application builder, where a developer constructs an application, using reusable chunks of software as building blocks. The user locates and selects the software chunks to be used. The first stage in design is the gathering of background information, consisting of goals, a description of the work environment, the people involved (including their roles and their characteristics), real-life scenarios (including task frequencies, artifacts produced, and obstacles), and environmental constraints.

From the background information, essential task models (use-cases) are constructed by taking real-life work scenarios, focusing on goals, and then abstracting away details of specific technologies and descriptions of how the tasks are currently performed. The essential model includes necessary tasks with objects and their relationships and essential actions.

Essential models are then transformed into user models, primarily by putting the tasks, objects, and relationships of the essential model into the context of a familiar metaphor. In the case of the application builder project, candidate metaphors were a catalog, a components data handbook, and a parts bin/cabinet. The characteristics of the candidate metaphors are compared to those of the essential model to choose the best candidate for the application. Once a metaphor is chosen, the use-cases are restated in terms of the metaphor to construct the user model. Another important part of the user model is a hierarchical task tree which describes functionally what the user does to accomplish each task, but not how the user actually does it.

The interface design results by transformations on the essential model. First, rough layouts are constructed by transforming task flows into simples sketches of window layouts with indicators of flow between them. Interaction design is produced by transforming the task tree and objects into plausible object views and controls. Finally, rough layouts are transformed into visual prototypes (high-fidelity prototypes), which mimic the intended appearance, interaction, and feedback in a way that allows the designer to validate the design with potential users. The process of developing the high-fidelity prototypes also brings many interaction issues to light and also forces the designer to consider details easily overlooked in rough layouts (i.e., it is part of the design development process itself).


Previous Table of Contents Next