Cs8079 - Hci QB Unit 2
Cs8079 - Hci QB Unit 2
Cs8079 - Hci QB Unit 2
UNIT – II
DESIGN & SOFTWARE PROCESS
Interactive Design basics – process – scenarios – navigation – screen Design – iteration and
prototyping. HCI in software process – software life cycle – usability engineering – Prototyping in
practice – design rationale. Design rules – principles, standards, guidelines, rules. Evaluation
Techniques – Universal Design.
PART – A
1. What are the steps for Interaction design process? (N/D – 18)
1) Requirements
2) Analysis
3) Design
4) Iteration and prototyping
5) Implementation and deployment
17. What are the categories principles to support usability? (A/M – 18)
1) Learnability – the ease with which new users can begin effective interaction and achieve maximal
performance.
2) Flexibility – the multiplicity of ways in which the user and system exchange information.
3) Robustness – the level of support provided to the user in determining successful achievement and
assessment of goals.
Part – B
The architectural design will have provided a general specification of the information input to this
component and the information it should output. The detailed description will introduce more information
in refining the general specification. The detailed design may also have to change the representations for
the information and will almost certainly break up a single high-level operation into several low-level
operations that can eventually be implemented. In introducing these changes to information and
operations, the designer must show that the refined description is a legal one within its language (internal
consistency) and that it describes all of the specified behavior of the high-level description (completeness)
in a provably correct way (relative consistency). Validation of a design demonstrates that within the
various activities the customers requirements are satisfied.
Validation is a much more subjective exercise than verification, mainly because the disparity between the
language of the requirements and the language of the design forbids any objective form of proof. In
interactive system design, the validation against HCI requirements is often referred to as evaluation and
can be performed by the designer in isolation or in cooperation with the customer.
4. 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.
5. Permit easy reversal of actions in order to relieve anxiety and encourage exploration, since the
user knows that he can always return to the previous state.
6. Support internal locus of control so that the user is in control of the system, which responds to his
actions.
7. Reduce short-term memory load by keeping displays simple, consolidating multiple page displays
and providing time for learning action sequences.
This is merely asking whether it is visible to them at the time when they will need to use it.
Instances where the answer to this question might be no‘ are, for example, where a VCR remote
control has a covered panel of buttons or where a menu item is hidden away in a submenu.
3. Once users have found the correct action, will they know it is the one they need?
Complements the previous question. It is one thing for a button or menu item to be visible, but will
the user recognize that it is the one he is looking for to complete his task? Where the previous
question was about the visibility of the action, this one is about whether its meaning and effect is
clear.
4. After the action is taken, will users understand the feedback they get?
If you now assume that the user did manage to achieve the correct action, will he know that the has
done so? Will the feedback given be sufficient confirmation of what has actually happened? This is
the completion of the execution–evaluation interaction cycle In order to determine if they have
accomplished their goal, users need appropriate feedback. It is vital to document the cognitive
walkthrough to keep a record of what is good
7. Flexibility and efficiency of use Allow users to tailor frequent actions. Accelerators – unseen by the
novice user – may often speed up the interaction for the expert user to such an extent that the system
can cater to both in experienced and experienced users.
Part – C
Activities
The graphical representation is reminiscent of a waterfall, in which each activity naturally leads into the
next. The analogy of the waterfall is not completely faithful to the real relationship between these
activities, but it provides a good starting point for discussing the logical flow of activity. We describe the
activities of this waterfall model of the software life cycle
Figure The activities in the waterfall model of the software life cycle
Requirements specification
Requirements specification begins at the start of product development. Though the requirements are from
the customers perspective, if they are to be met by the software product they must be formulated in a
language suitable for implementation. Requirements are usually initially expressed in the native language
of the customer. The executable languages for software are less natural and are more closely related to a
mathematical language in which each term in the language has a precise interpretation, or semantics. The
transformation from the expressive but relatively ambiguous natural language of requirements to the
more precise but less expressive executable languages is one key to successful development. Task
analysis techniques, which are used to express work domain requirements in a form that is both
expressive and precise.
Architectural design
The requirements specification concentrates on what the system is supposed to do. The next activities
concentrate on how the system provides the services expected from it. The first activity is a high-level
decomposition of the system into components that can either be brought in from existing software
products or be developed from scratch independently. An architectural design performs this
decomposition. It is not only concerned with the functional decomposition of the system, determining
which components provide which services. It must also describe the interdependencies between separate
components and the sharing of resources that will arise between components.
Detailed design
The architectural design provides a decomposition of the system description that allows for isolated
development of separate components which will later be integrated. For those components that are not
already available for immediate integration, the designer must provide a sufficiently detailed description
so that they may be implemented in some programming language. The detailed design is a refinement of
the component description provided by the architectural design. The behavior implied by the higher-level
description must be preserved in the more detailed description.
There will be more than one possible refinement of the architectural component that will satisfy the
behavioral constraints. Choosing the best refinement is often a matter of trying to satisfy as many of the
non-functional requirements of the system as possible. Thus the language used for the detailed design
must allow some analysis of the design in order to assess its properties.
Coding and unit testing
The detailed design for a component of the system should be in such a form that it is possible to
implement it in some executable programming language. After coding, the component can be tested to
verify that it performs correctly, according to some test criteria that were determined in earlier activities.
Research on this activity within the life cycle has concentrated on two areas. There is plenty of research
that is geared towards the automation of this coding activity directly from a low-level detailed design.
Most of the work in formal methods operates under the hypothesis that, in theory, the transformation
from the detailed design to the implementation is from one mathematical representation to another and so
should be able to be entirely automated. Other, more practical work concentrates on the automatic
generation of tests from output of earlier activities which can be performed on a piece of code to verify
that it behaves correctly.
Integration and testing
Once enough components have been implemented and individually tested, they must be integrated as
described in the architectural design. Further testing is done to ensure correct behavior and acceptable use
of any shared resources. It is also possible at this time to perform some acceptance testing with the
customers to ensure that the system meets their requirements. It is only after acceptance of the integrated
system that the product is finally released to the customer.
Maintenance
After product release, all work on the system is considered under the category of maintenance, until such
time as a new version of the product demands a total redesign or the product is phased out entirely.
Consequently, the majority of the lifetime of a product is spent in the maintenance activity. Maintenance
involves the correction of errors in the systems which are discovered after release and the revision of the
system services to satisfy requirements that were not realized during previous development.
2. Explain 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.
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 users
experience. The final approach to simplification is to change the nature of the task so that it becomes
something simpler. In all of this, it is important not to take control away from the user.
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 what 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. A simple example is a
jigsaw puzzle, where the pieces only fit together in one way. Here the physical constraints of the
design guide the user to complete the task.
6) Design for error. To err is human, so anticipate the errors the user could make and design recovery
into the system.
7) When all else fails, standardize. If there are no natural mappings then arbitrary mappings should be
standardized so that users only have to learn them once. It is this standardization principle that
enables drivers to get into a new car and drive it with very little difficulty – key controls are
standardized. Occasionally one might switch on the indicator lights instead of the windscreen wipers,
but the critical controls (accelerator, brake, clutch, steering) are always the same.