Chapter Six Design Rules and Implementation Support
Chapter Six Design Rules and Implementation Support
Chapter Six Design Rules and Implementation Support
1. Data Entry
Position Designation
Distinctive Cursor
For position designation on an electronic display, provide a movable cursor with
distinctive visual features (shape, blink, etc.).
Exception When position designation involves only selection among displayed
alternatives, highlighting selected items might be used instead of a separately
displayed cursor.
Cont..
Comment When choosing a cursor shape, consider the general content of the display.
For instance, an underscore cursor would be difficult to see on a display of underscored text,
Comment If the cursor is changed to denote different functions (e.g. to signal deletion
rather than entry), then each different cursor should be distinguishable from the others.
Comment If multiple cursors are used on the same display (e.g. one for alphanumeric entry
and one for line drawing), then each cursor should be distinguishable from the
others.
Golden Rules and Heuristics
4. Design dialogs to yield closure so that the user knows when they have completed
a task.
5. Offer error prevention and simple error handling so that, ideally, users are
prevented from making mistakes and, if they do, they are offered clear and
informative instructions to enable them to recover.
6. Permit easy reversal of actions in order to remove anxiety and encourage
exploration, since the user knows that he can always return to the previous state.
7. Support internal locus of control so that the user is in control of the system,
which responds to his actions.
8. Reduce short-term memory load by keeping displays simple, consolidating
multiple page displays and providing time for learning action sequences.
Norman’s Seven Principles for Transforming Difficult Tasks
into Simple Ones
1. Use both knowledge in the world and knowledge in the head. People work
better when the knowledge they need to do a task is available externally –
either explicitly or through the constraints imposed by the environment.
But experts also need to be able to internalize regular tasks to increase
their efficiency. So systems should provide the necessary knowledge within
the environment and their operation should be transparent to support the
user in building an appropriate mental model of what is going on.
Cont...
2. Simplify the structure of tasks. Tasks need to be simple in order to avoid
complex problem solving and excessive memory load. There are a
number of ways to simplify the structure of tasks.
One is to provide mental aids to help the user keep track of stages in
a more complex task.
Another is to use technology to provide the user with more
information about the task and better feedback.
A third approach is to automate the task or part of it, as long as this
does not detract from the user’s experience.
The final approach to simplification is to change the nature of the
task so that it becomes something more simple. In all of this, it is
important not to take control away from the user.
Cont...
3. Make things visible: bridge the gulfs of execution and evaluation. The
interface should make clear what the system can do and how this is
achieved, and should enable the user to see clearly the effect of their actions
on the system.
4. Get the mappings right. User intentions should map clearly onto system
controls. User actions should map clearly onto system events. So it should
be clear what does it and by how much. Controls, sliders and dials should
reflect the task –so a small movement has a small effect and a large
movement a large effect.
5. Exploit the power of constraints, both natural and artificial. Constraints are
things in the world that make it impossible to do anything but the correct
action in the correct way.
Cont..
• One way to approach design is to learn from examples that have proven to
be successful in the past: to reuse the knowledge of what made a system –
or paradigm – successful.
• Patterns are an approach to capturing and reusing this knowledge – of
abstracting the essential details of successful design so that these can be
applied again and again in new situations.
• Patterns can also address high-level issues such as organizational structures
or cooperative groups.
Cont..
Patterns originated in architecture, where they have been used
successfully, and they are also used widely in software development to
capture solutions to common programming problems. More recently
they have been used in interface and web design. A pattern is an
invariant solution to a recurrent problem within a specific context.
Patterns address the problems that designers face by providing a
‘solution statement’.
The pattern also has references to other patterns, indicating both the
context in which it can be applied (the top references) and the patterns
that may be needed to complete it (the bottom references).
Cont...
This connects the patterns together into a language. Patterns in isolation have limited
use, but by traversing the hierarchy, through these references, the user is assisted in
generating a complete design.
Patterns and pattern languages are characterized by a number of features, which,
taken as a whole, distinguish them from other design rules:
They capture design practice and embody knowledge about successful solutions: they
come from practice rather than psychological theory.
They capture the essential common properties of good design: they do not tell the
designer how to do something but what needs to be done and why.
Cont...
They represent design knowledge at varying levels, ranging from social
and organizational issues through conceptual design to detailed design.
They are not neutral but embody values within their rationale.
Alexander’s language clearly expresses his values about architecture.
HCI patterns can express values about what is humane in interface
design.
The concept of a pattern language is generative and can therefore assist
in the development of complete designs.
They are generally intuitive and readable and can therefore be used for
communication between all stakeholders.
Implementation Support
• Programming tools for interactive systems provide a means of
effectively translating abstract designs and usability principles into an
executable form.
• Windowing systems are a central environment for both the
programmer and user of an interactive system, allowing a single
workstation to support separate user–system threads of action
simultaneously.
• Interaction toolkits abstract away from the physical separation of input
and output devices, allowing the programmer to describe behaviors of
objects at a level similar to how the user perceives them.
Cont..
• User interface management systems are the final level of programming
support tools, allowing the designer and programmer to control the
relationship between the presentation objects of a toolkit with their
functional semantics in the actual application.
Cont..
• The first important feature of a windowing system is its ability to
provide programmer independence from the specifics of the hardware
devices. A typical workstation will involve some visual display screen, a
keyboard and some pointing device, such as a mouse. Any variety of
these hardware devices can be used in any interactive system and they
are all different in terms of the data they communicate and the
commands that are used to instruct them.
Cont..
• The second option is to implement the management role within the kernel of the
operating system, centralizing the management task by freeing it from the
individual applications. Applications must still be developed with the specifics of
the particular operating system in mind.
• The third option provides the most portability, as the management function is
written as a separate application in its own right and. so can provide an interface
to other application programs that is generic across all operating systems.
User Interface Management Systems
The main concerns of a UIMS, for our purposes, are:
• A conceptual architecture for the structure of an interactive system which
concentrates on a separation between application semantics and
presentation;
• Techniques for implementing a separated application and presentation
whilst preserving the intended connection between them;
• Support techniques for managing, implementing and evaluating a run-time
interactive environment.
UIMS as a Conceptual Architecture
• There are many good arguments to support this separation of
concerns:
• Portability To allow the same application to be used on different
systems it is best to consider its development separate from its device-
dependent interface.
• Reusability Separation increases the likelihood that components can be
reused in order to cut development costs.
• Multiple interfaces To enhance the interactive flexibility of an
application, several different interfaces can be developed to access the
same functionality.
Cont…