HUMAN COMPUTER INTERACTION

Course Code: PECS801D

MODULE 3
Design Guidelines and Dialog Design in HCI

Complete Question & Answer Guide

2-Mark | 5-Mark | 10-Mark Questions
SECTION A: 2-Marks Questions
Each answer is approximately 50 words.

Q1. Indicate the meaning of a usability heuristic.

A usability heuristic is a general rule of thumb or broad principle used to evaluate the usability of
a user interface. These are not strict guidelines but rather experiential rules that help identify
usability problems. They serve as quick, practical benchmarks during interface design and
evaluation processes.

Q2. Identify the aim of heuristic evaluation.

The aim of heuristic evaluation is to identify usability problems in a user interface design by
having evaluators examine the interface and judge its compliance with recognized usability
principles (heuristics). It helps uncover design flaws early and cost-effectively, before user
testing, improving the overall interface quality.

Q3. Indicate the idea behind cognitive walkthrough.

Cognitive walkthrough is a usability inspection method where evaluators simulate a user's
problem-solving process while interacting with an interface. The focus is on evaluating how
easily a new or casual user can learn to use the system by stepping through tasks and
assessing each action's clarity and learnability.

Q4. State the purpose of contextual inquiry.

Contextual inquiry is a user research method where designers observe and interview users in
their natural work environment. Its purpose is to understand how users actually perform tasks,
what tools they use, and what problems they face, helping designers build systems that align
with real-world user needs and workflows.

Q5. Indicate the role of Norman's interaction model.

Norman's interaction model describes the cycle of interaction between a user and a system. It
highlights two key gulfs — the Gulf of Execution (difficulty in knowing what to do) and the Gulf of
Evaluation (difficulty in interpreting system response). The model helps designers minimize
these gaps to improve usability.

Q6. State the meaning of feedback in interfaces.

Feedback in interfaces refers to the system's response to a user's action, informing them of the
result or current state. For example, a progress bar after clicking 'Submit' is feedback. It keeps
users informed, reduces uncertainty, and confirms that the system has received and processed
their input correctly.
Q7. Indicate the idea of affordance.
Affordance refers to the perceived or actual properties of an object that suggest how it should
be used. In HCI, a button that looks raised affords clicking; a slider affords dragging. Good
affordances make interfaces intuitive by making possible interactions visually or physically
obvious to users without requiring instructions.

Q8. State the meaning of visibility.

Visibility in HCI means that the relevant functions and current state of a system should be
clearly visible to the user. When controls and options are visible, users can discover them
easily. Poor visibility forces users to memorize hidden options, increasing cognitive load and
leading to errors and frustration.

Q9. Indicate the meaning of a finite state machine.

A Finite State Machine is a computational model used to represent systems with a limited
number of states. In HCI, it models dialog behavior — the system is always in one defined state,
and user inputs cause transitions to other states. FSMs are useful for designing and analyzing
interactive dialog flows.

Q10. Indicate the meaning of a transition.

A transition in the context of FSMs and dialog design is a change from one state to another,
triggered by a specific user action or system event. Transitions define the valid paths a user can
take through a system. They help map out the flow of interaction and guide dialog design
systematically.

Q11. State the meaning of a token.

In the context of Petri nets (used in dialog modeling), a token represents the current state or
activity within a system. Tokens move between places in a Petri net when transitions fire (are
activated). The distribution of tokens at any point in time represents the current state of the
entire system.

Q12. Identify the idea of dialog design.

Dialog design refers to the structured planning of the interaction or 'conversation' between a
user and a computer system. It focuses on organizing inputs, outputs, and system responses in
a logical, user-friendly manner. Good dialog design ensures smooth, predictable, and error-
tolerant interactions between humans and computer interfaces.

Q13. State the meaning of consistency in respect to HCI.

Consistency in HCI means maintaining uniformity in design elements, terminology, behavior,
and layout across an interface. It allows users to apply previously learned knowledge to new
parts of the system. For example, using the same icon for 'save' throughout an application
ensures predictability and reduces the user's cognitive effort significantly.

Q14. Indicate the idea of error prevention.

Error prevention is a design strategy aimed at eliminating or reducing the chances of a user
making a mistake. This involves designing interfaces that guide users toward correct actions,
using confirmation dialogs, constraints, and clear labeling. Preventing errors is more effective
and user-friendly than simply providing error messages after mistakes occur.

Q15. Indicate the meaning of recall.

Recall in HCI refers to the mental effort required by users to retrieve information from memory to
use an interface. Interfaces that require high recall are harder to use. Good design minimizes
recall by using recognition (showing options) instead, reducing cognitive load and making the
system easier and faster to use.

Q16. State the idea of learnability.

Learnability refers to how easily a new user can learn to use an interface effectively. A highly
learnable system enables users to reach a reasonable level of proficiency quickly. It is achieved
through intuitive design, clear labeling, consistent behavior, helpful feedback, and adherence to
users' prior knowledge and mental models.

Q17. Identify the meaning of flexibility.

Flexibility in HCI refers to the ability of a system to accommodate different users' needs,
preferences, and skill levels. A flexible interface supports multiple ways of accomplishing the
same task — for example, offering both keyboard shortcuts and mouse-based menus —
ensuring that both novice and expert users can interact efficiently and comfortably.

Q18. State the meaning of user control.

User control means giving users the power to initiate, pause, undo, and control their interactions
with a system. Users should feel in command rather than feeling 'trapped.' Features like
undo/redo, cancel buttons, and back navigation are examples. User control reduces frustration
and increases confidence while using interactive systems.

Q19. Indicate the meaning of system feedback.

System feedback is the information a system provides to users in response to their actions,
indicating what has happened or is happening. For example, a 'Loading...' spinner or a 'File
saved successfully' message are forms of system feedback. It keeps users informed and
prevents confusion about whether their input was received.

Q20. Identify the idea of a state chart.

A state chart is an extension of a finite state machine that allows the modeling of complex,
hierarchical, and concurrent system behaviors. It organizes states in a tree-like structure with
nested sub-states, making it suitable for modeling complex real-world dialog systems like ATM
transactions or flight booking interfaces more manageably.

Q21. State the meaning of formalism in HCI.

Formalism in HCI refers to the use of mathematical or structured notations to precisely describe
user interfaces and interactions. Formal methods like Finite State Machines, Petri nets, and
state charts provide unambiguous representations of dialog behavior. They are used to analyze,
verify, and detect design flaws early in the development process.

Q22. Identify the idea of a usability problem.

A usability problem is any aspect of an interface that makes it difficult, confusing, inefficient, or
frustrating for users to achieve their goals. Usability problems can range from unclear labels and
poor navigation to system crashes. They are identified through methods like heuristic
evaluation, cognitive walkthroughs, and user testing sessions.

Q23. State the meaning of user evaluation.

User evaluation is the process of testing a system with real users to assess its usability,
effectiveness, and user satisfaction. It involves observing users performing tasks, collecting data
on errors, time taken, and satisfaction. User evaluation provides direct, real-world evidence of
how well an interface meets the needs of its target audience.

Q24. Indicate the idea of system status.

System status refers to the current state of the system that is communicated to the user. Users
should always be aware of what the system is doing — whether it is processing, waiting, or
ready for input. Communicating system status clearly (e.g., through progress bars or status
messages) is a key usability principle.

Q25. State the meaning of interaction style.

Interaction style refers to the method through which a user communicates with a computer
system. Common styles include command-line interfaces, menu-based navigation, form fill-in,
direct manipulation (e.g., drag-and-drop), and natural language interaction. The choice of
interaction style affects learnability, efficiency, and user satisfaction based on the target user
group.
SECTION B: 5-Marks Questions
Each answer is approximately 100+ words.

Q1. Outline Shneiderman's eight golden rules.

Ben Shneiderman proposed eight golden rules of interface design that serve as fundamental
guidelines for creating usable systems:
• 1. Strive for Consistency — Use consistent sequences of actions, identical terminology
in menus, and consistent color schemes throughout the interface.
• 2. Enable Frequent Users to Use Shortcuts — Allow experienced users to use
abbreviations, keyboard shortcuts, and macros to speed up interactions.
• 3. Offer Informative Feedback — Every user action should be met with appropriate
system feedback to keep the user informed.
• 4. Design Dialogs to Yield Closure — Sequences of actions should have a beginning,
middle, and end, with clear completion signals to give users satisfaction.
• 5. Offer Error Prevention and Simple Error Handling — Design to minimize errors,
and when they occur, allow simple recovery without penalty.
• 6. Permit Easy Reversal of Actions — Actions should be reversible (undo/redo),
encouraging exploration and reducing fear of mistakes.
• 7. Support Internal Locus of Control — Users should feel in control of the system and
that the system responds to their actions.
• 8. Reduce Short-Term Memory Load — Interfaces should not require users to hold
excessive information in memory; instead, display relevant information when needed.
These rules collectively improve usability by making interfaces predictable, forgiving, and user-
centered.

Q2. Illustrate Norman's seven principles of design.

Donald Norman proposed seven principles aimed at improving the usability of everyday objects
and interfaces:
• 1. Use Knowledge in the World and in the Head — Design systems that leverage both
external information (labels, icons) and users' prior knowledge to reduce cognitive load.
• 2. Simplify the Structure of Tasks — Break complex tasks into simpler steps to reduce
the cognitive demands on the user.
• 3. Make Things Visible — The controls, system status, and available actions should be
clearly visible so users can see what is possible and what is happening.
• 4. Get the Mappings Right — There should be a natural relationship between controls
and their effects (e.g., steering wheel direction matches car movement).
• 5. Exploit the Power of Constraints — Use physical, cultural, and logical constraints to
guide users toward correct actions and prevent errors.
• 6. Design for Error — Assume users will make errors and design the system to detect,
tolerate, and recover from mistakes gracefully.
• 7. When All Else Fails, Standardize — When natural mappings and constraints cannot
solve a design problem, use standardized conventions that users are familiar with.
These principles help bridge the Gulf of Execution and Gulf of Evaluation in Norman's
interaction model, resulting in more intuitive and usable interfaces.

Q3. Summarize Nielsen's heuristics.

Jakob Nielsen's 10 usability heuristics are widely used principles for interface design and
evaluation:
• 1. Visibility of System Status — Always inform users about what is going on through
appropriate feedback (e.g., loading indicators).
• 2. Match Between System and the Real World — Use language, concepts, and
metaphors familiar to users rather than system-oriented jargon.
• 3. User Control and Freedom — Allow users to undo and redo actions, and provide
clear exit points from unwanted states.
• 4. Consistency and Standards — Follow platform conventions so users don't have to
guess whether different words/actions mean the same thing.
• 5. Error Prevention — Design to prevent problems from occurring in the first place
(e.g., confirmation dialogs for irreversible actions).
• 6. Recognition Rather Than Recall — Minimize memory load by making options
visible, reducing the need for users to remember information.
• 7. Flexibility and Efficiency of Use — Support accelerators for expert users while
keeping the interface accessible to novices.
• 8. Aesthetic and Minimalist Design — Avoid irrelevant information that competes with
relevant content and reduces efficiency.
• 9. Help Users Recognize, Diagnose, and Recover from Errors — Error messages
should be plain-language, precise, and suggest solutions.
• 10. Help and Documentation — Even though a well-designed system should not need
extensive documentation, searchable and task-focused help should be available.

Q4. Outline the steps involved in heuristic evaluation.

Heuristic evaluation is a structured usability inspection method. The following steps are
involved:
• 1. Select Evaluators — Typically 3-5 usability experts are chosen. Having multiple
evaluators helps identify a broader range of problems.
• 2. Brief the Evaluators — Evaluators are given the scope, target users, and specific
heuristics they should apply.
• 3. Individual Evaluation — Each evaluator independently interacts with the interface,
inspecting it against the list of heuristics.
• 4. Record Usability Problems — Evaluators document each problem they find, noting
which heuristic it violates.
• 5. Severity Rating — Each identified problem is rated for severity based on frequency,
impact, and persistence.
• 6. Aggregate Results — After all evaluators have completed their individual
assessments, results are compiled and duplicates are merged.
• 7. Debrief and Feedback Session — Evaluators may discuss findings together to
finalize the list and generate improvement recommendations.
This method is cost-effective, fast, and can be performed early in the design process.

Q5. Describe the process of cognitive walkthrough.

Cognitive walkthrough is a user-centered usability inspection method that focuses on evaluating
the learnability of an interface for new users. The process involves:
• 1. Define the User Population and Task — Identify who the target users are and select
specific tasks to evaluate.
• 2. Describe the Interface and Actions — Document the sequence of actions required
to complete each task using the interface.
• 3. Walk Through Each Action — For each step, evaluators ask: Will the user know
they need to take this action? Will they notice the correct control? Will they understand
the feedback?
• 4. Identify Failure Points — If the answer to any of these questions is 'no', a usability
problem is identified and recorded.
• 5. Compile and Report Findings — All problems are documented with their
descriptions and suggested fixes.
Cognitive walkthrough is particularly useful for identifying issues that affect first-time or
infrequent users, making it a complement to heuristic evaluation.

Q6. Illustrate the use of contextual inquiry.

Contextual inquiry is a qualitative field research method based on four key principles:
• 1. Context — Researchers observe users in their actual work environment rather than a
lab, ensuring observations reflect real-world use.
• 2. Partnership — Researchers and users collaborate; the user acts as the expert on
their own work, and the researcher learns from them.
• 3. Interpretation — Researchers interpret what they observe in real-time, sharing their
understanding with users for validation or correction.
• 4. Focus — The inquiry has a defined focus to keep observations relevant and
structured.
The researcher observes the user performing tasks, asks questions as they arise, and takes
notes. Data is later analyzed to uncover patterns, pain points, and unmet needs. Contextual
inquiry is particularly valuable in early design stages, helping teams build systems grounded in
actual user needs rather than assumptions.

Q7. Describe dialog modeling using finite state machines.

A Finite State Machine (FSM) consists of:
• States — Represent specific points in the dialog (e.g., 'Waiting for username,' 'Password
entered,' 'Login successful').
• Transitions — Arrows between states triggered by user actions or system events.
• Inputs/Events — The user actions or system events that cause transitions.
• Initial State — The starting state of the dialog.
• Final/Accepting States — States that represent successful completion of the dialog.
Example: A simple login dialog FSM begins at 'Start,' transitions to 'Enter Username' after
system load, moves to 'Enter Password' after username input, then transitions to 'Home Screen'
on successful authentication or 'Error' on failure. FSMs are easy to visualize and implement but
are limited in modeling complex or concurrent dialogs.

Q8. Outline the structure of state charts.

State charts, introduced by David Harel, extend FSMs with the following structural components:
• Hierarchical States — States can contain nested sub-states. A superstate (e.g.,
'Logged In') contains substates (e.g., 'Browsing,' 'Editing Profile'), reducing the number
of transitions needed.
• Concurrent States — State charts support parallel states using AND decomposition,
allowing a system to be in multiple states simultaneously.
• Transitions with Guards and Actions — Transitions can include guard conditions
(e.g., [password correct]) and associated actions (e.g., /display home screen).
• Events — Events trigger transitions between states.
• History Mechanism — Allows a system to return to its last active substate after
interruption.
State charts are particularly useful for modeling complex systems like ATM transactions or
online booking systems where multiple concurrent and nested behaviors need to be
represented.

Q9. Illustrate dialog modeling using Petri nets.

Petri nets are a formal, graphical modeling tool for concurrent and parallel dialog behaviors. A
Petri net consists of:
• Places (Circles) — Represent conditions or states (e.g., 'Waiting for input').
• Transitions (Bars) — Represent events or actions that change the system state.
• Arcs (Arrows) — Connect places to transitions and transitions to places, defining
control flow.
• Tokens (Dots) — Represent the current active condition. A token in a place means that
condition is currently true.
Firing Rule: A transition fires when all input places have at least one token. When fired, tokens
are consumed from inputs and produced at outputs.
Example: In a simple dialog, a Petri net might model form submission: Place A (Form Open) →
Transition (Submit Clicked) → Place B (Processing) → Transition (Success) → Place C
(Confirmation Screen). Petri nets are more powerful than FSMs for modeling concurrent
interactions, making them suitable for complex, multi-threaded dialog systems.

Q10. Describe dialog design in interactive systems.

Dialog design refers to the structured planning of all interactions between a user and a
computer system. Key aspects include:
 • Dialog Types — Systems may employ menus, form fill-in, command-line input, direct
manipulation, or question-and-answer dialogs, chosen based on user needs and
expertise.
• Dialog Structure — A well-designed dialog has a clear beginning (initiating the task),
middle (executing steps), and end (confirmation/closure), giving users a sense of
progress.
• Error Handling — The dialog should anticipate errors, provide clear error messages,
and allow recovery without losing progress.
• Feedback — At every step, the system should provide appropriate feedback so users
know their actions have been registered.
• Formal Modeling — Tools like FSMs, state charts, and Petri nets help designers
formally model and verify dialog behavior before implementation.
• Consistency — All dialogs within a system should follow the same conventions,
reducing learning time for users.

Q11. Differentiate heuristic evaluation from cognitive walkthrough.

The following table compares the two key usability inspection methods:

Aspect Heuristic Evaluation Cognitive Walkthrough

Focus Broad usability issues Learnability for new users
Method Inspect against heuristics Step-by-step task simulation
Who Usability experts Designers simulate users
Output List of violated heuristics List of task-step failures
Best For General usability problems First-time user issues

Heuristic evaluation is broader and faster, identifying a wide range of usability issues. Cognitive
walkthrough is more focused on task-specific learnability. Both methods are complementary and
together provide a comprehensive picture of interface usability.

Q12. Outline methods for handling errors in interfaces.

Error handling is a critical component of usable interface design. Key methods include:
• 1. Error Prevention — The most effective method — design interfaces that make errors
unlikely, such as disabling irrelevant buttons and using input masks.
• 2. Confirmation Dialogs — For irreversible actions (like deleting a file), prompt users to
confirm before proceeding.
• 3. Inline Validation — Provide real-time feedback as users fill in forms (e.g., highlighting
a field red if an email format is incorrect before submission).
• 4. Clear Error Messages — When an error occurs, the message should state what
went wrong, why, and how to fix it in plain language.
• 5. Undo/Redo Functionality — Allow users to reverse their actions, reducing the
consequence of mistakes.
 • 6. Graceful Degradation — Design the system to handle unexpected inputs without
crashing or producing confusing behavior.
• 7. Help and Documentation — Provide contextual help that users can access when
they encounter problems.

Q13. Illustrate the importance of consistency in UI design.

Consistency in UI design means maintaining uniformity in visual design, terminology, behavior,
and interaction patterns. Its importance includes:
• Reduces Learning Time — When all parts of a system behave the same way, users
can apply knowledge learned in one area to another.
• Prevents Errors — Consistent labels and actions reduce confusion and the likelihood of
user mistakes.
• Builds Mental Models — Consistent design helps users develop accurate mental
models of how the system works.
• Improves Efficiency — Experienced users can interact faster when behavior is
consistent.
• Enhances Aesthetics — Consistent visual design creates a professional, coherent look
that improves user confidence.
• Supports Accessibility — Consistency aids users with cognitive disabilities who rely on
predictable patterns.
Consistency can be internal (within the same product) or external (matching platform
conventions). Both types are essential for creating a high-quality user experience.

Q14. Describe visibility of system status with examples.

Visibility of system status (Nielsen's Heuristic 1) states that users should always be informed
about what the system is doing through timely and appropriate feedback.
Without status visibility, users become confused about whether their action was registered,
whether the system is working, or whether they need to act further — leading to repeated
inputs, frustration, and loss of trust.
Examples:
• Progress Bar — When uploading a file, a progress bar shows percentage complete,
managing user expectations during a long wait.
• Loading Spinner — A spinning icon during page loads signals that the system is
processing.
• Confirmation Messages — 'Your order has been placed successfully!' informs the user
that their transaction was completed.
• Active Navigation Highlighting — In a website menu, the current page link is
highlighted, showing users exactly where they are.
• Battery Indicator — On a smartphone, the battery level indicator continuously shows
system status without user prompting.
Good system status visibility builds trust, reduces uncertainty, and helps users make better
decisions during interaction.
Q15. Outline user control and freedom in interfaces.
User control and freedom is a usability principle stating users should have the power to
navigate, undo, and exit actions freely without feeling trapped or penalized. Key aspects
include:
• Undo and Redo — Allows users to reverse actions, reducing the fear of exploring the
interface and enabling recovery from errors.
• Cancel Buttons — Every dialog or process should offer a clear way to cancel or exit
without causing damage to the user's work.
• Back Navigation — Browsers and apps should support backward navigation, allowing
users to return to previous states.
• Emergency Exits — Clearly marked ways to leave unwanted states (e.g., a prominent
'X' on popups) are essential.
• Avoiding Forced Paths — Users should not be forced to complete a process in one
sitting; they should be able to save progress and return.
• Customization — Allowing users to personalize layouts, preferences, and shortcuts
gives them a greater sense of control.

Q16. Summarize key usability principles.

Usability principles are foundational guidelines ensuring interfaces are easy to learn, efficient to
use, and satisfying. The key principles include:
• Learnability — New users should achieve basic tasks quickly on first encounter.
• Efficiency — Once familiar, users should perform tasks rapidly and with minimal effort.
• Memorability — Casual users who return after absence should re-establish proficiency
without relearning.
• Error Tolerance — The system should tolerate errors and provide mechanisms to
recover easily.
• Satisfaction — The experience should be pleasant, building user confidence and trust.
• Consistency — Interface elements should behave predictably.
• Visibility — System status and available actions should always be visible.
• Feedback — Every user action should elicit an appropriate system response.
• Accessibility — Systems should be usable by people with varying abilities.

Q17. Describe different interaction styles.

Interaction style refers to the mode of communication between a user and a computer system.
The major styles are:
• 1. Command-Line Interface (CLI) — Users type text commands to interact. Efficient for
experts but steep learning curve (e.g., Unix terminal).
• 2. Menu-Based Interaction — Users select options from a list. Reduces recall demands
and suits novice users (e.g., smartphone menus).
• 3. Form Fill-In — Users enter data into structured forms with labeled fields. Common in
data-entry applications (e.g., online registration forms).
• 4. Direct Manipulation — Users interact with visible objects using pointing devices
(drag, drop, resize). Intuitive and learnable (e.g., desktop file management).
 • 5. Natural Language Interaction — Users communicate in spoken or written natural
language (e.g., voice assistants like Siri, chatbots).
• 6. Question and Answer — The system asks structured questions and the user
responds (e.g., installation wizards, survey tools).
Each style has advantages and disadvantages in terms of learnability, efficiency, and user
satisfaction.

Q18. Outline formal methods used in dialog design.

Formal methods in HCI use mathematical notations to precisely describe the behavior of user
interfaces. Key formal methods include:
• Finite State Machines (FSMs) — Model dialogs as a set of states and transitions.
Simple and easy to diagram but limited to non-concurrent systems.
• State Charts — Extend FSMs with hierarchy and concurrency. Suitable for complex
systems with nested and parallel behaviors.
• Petri Nets — Support concurrent modeling using places, transitions, and tokens. Ideal
for representing parallel user interactions.
• BNF (Backus-Naur Form) — A grammar-based notation used to formally specify the
syntax of valid user inputs in command-based interfaces.
• CSP (Communicating Sequential Processes) — A process algebra used to model
concurrent interactions between users and systems.
Formal methods help detect design errors early, enable precise communication among team
members, and provide a basis for automated verification of interface properties.

Q19. Illustrate the role of feedback in dialogs.

Feedback plays a critical role in dialog design by keeping users informed about the result of
their actions and the current state of the system. Its role includes:
• Acknowledgment of Input — Feedback confirms that the system has received and
processed the user's action (e.g., a button changing color when clicked).
• Error Indication — When a user makes an incorrect input, feedback (e.g., red
highlighting with an error message) alerts them to the problem and guides correction.
• Progress Indication — During lengthy operations, progress bars or percentage
indicators inform users that the system is working.
• Completion Signals — Dialog closure is signaled through confirmation messages (e.g.,
'Your message has been sent'), giving users a sense of task completion.
• Guiding Next Actions — Feedback can suggest what the user should do next, reducing
uncertainty during complex multi-step dialogs.
• Building Trust — Consistent, accurate feedback builds user confidence in the system.

Q20. Outline the factors influencing learnability.

Learnability is the ease with which new users can learn to use a system. Key factors that
influence it include:
• Familiarity — If the system resembles other tools users already know, the learning
curve is reduced.
• Consistency — Consistent behavior allows users to generalize their learning from one
part of the system to another.
• Feedback — Clear feedback after each action helps users understand cause-and-effect
relationships.
• Simplicity of Structure — Simple, logical task structures that match users' mental
models are easier to learn.
• Visibility — Making available options visible (recognition over recall) reduces the need
for users to memorize commands.
• Affordances — Intuitive visual cues help users understand functionality without
instruction.
• Help and Onboarding — Well-designed tutorials, tooltips, and contextual help
significantly accelerate the learning process.
• Error Recovery — Systems that allow easy recovery from mistakes encourage
exploration, which accelerates learning.
SECTION C: 10-Marks Questions
Each answer is approximately 150+ words, elaborately explained.

Q1. Illustrate Shneiderman's golden rules with suitable examples.

Ben Shneiderman's eight golden rules of interface design are foundational principles that guide
the creation of usable, efficient, and user-friendly interfaces. Each rule addresses a key aspect
of the human-computer interaction experience:

1. Strive for Consistency

Consistency requires that similar operations and similar elements look and behave the same
way across the interface. This includes consistent use of menus, icons, colors, fonts, and
terminology. For example, if clicking an 'X' icon closes a window in one part of an application,
the same icon should close windows everywhere in the system. Inconsistency forces users to
re-learn behaviors, increases cognitive load, and leads to errors. Microsoft Office is a good
example — the ribbon interface behaves uniformly across Word, Excel, and PowerPoint.

2. Enable Frequent Users to Use Shortcuts

As users gain experience, they seek efficiency. Shortcuts like keyboard commands (Ctrl+C for
copy, Ctrl+V for paste), macros, and abbreviations allow expert users to bypass slower menu-
based interactions. While novice users rely on menus, experts prefer shortcuts that match their
increased proficiency. Adobe Photoshop exemplifies this by offering extensive keyboard
shortcuts alongside its GUI.

3. Offer Informative Feedback

Every user action should generate some form of system feedback. The feedback should be
appropriate in intensity: minor actions (like clicking a list item) may produce subtle visual
feedback, while major actions (like completing a file transfer) should produce more prominent
feedback. For example, email clients show a 'Message Sent' confirmation after sending an
email.

4. Design Dialogs to Yield Closure

Sequences of actions should be organized into groups with clear beginnings, middles, and
endings. The sense of closure after completing a task is psychologically satisfying and confirms
task success. For example, an online shopping checkout process ends with an 'Order
Confirmed' page with an order number — this provides clear closure after the multi-step
transaction.

5. Offer Error Prevention and Simple Error Handling

The best design prevents errors before they happen. When errors do occur, the system should
detect them quickly and offer simple, clear recovery mechanisms. For example, Gmail's 'Are
you sure you want to delete this email?' confirmation dialog prevents accidental deletion.

6. Permit Easy Reversal of Actions

Users should be able to undo their actions easily, which encourages exploration and reduces
anxiety about making mistakes. This is implemented through Ctrl+Z (undo) in most applications.
Photo editing software like Lightroom allows users to step back through multiple edits.
7. Support Internal Locus of Control
Users should feel that they are in command of the interface, not the other way around. Systems
should respond to user actions, not dictate the user's path. Avoiding unexpected pop-ups,
forced updates mid-task, or disabling user-initiated navigation supports this principle.

8. Reduce Short-Term Memory Load

Human short-term memory is limited (typically 7±2 items). Interfaces should not require users to
memorize information across multiple screens. For example, e-commerce sites display a 'cart
summary' on the checkout page so users don't need to remember what they added earlier.
Using icons with labels, persistent navigation bars, and breadcrumb trails all help reduce
memory demands. Together, these eight rules provide a comprehensive framework for
designing interfaces that are consistent, forgiving, efficient, and satisfying to use across both
novice and expert user populations.

Q2. Interpret Norman's principles and justify their relevance to usability.

Donald Norman's seven principles of design, articulated in The Design of Everyday Things,
have profoundly influenced HCI. Each principle addresses a specific challenge in designing
intuitive, usable systems.

1. Use Knowledge in the World and in the Head

Norman argues that good design leverages both external cues (knowledge 'in the world') and
the user's existing knowledge ('in the head'). An interface with clear labels, visible options, and
familiar metaphors allows users to rely on environmental cues rather than memory. For
example, a word processor's toolbar uses familiar icons (scissors for cut, clipboard for paste)
that draw on real-world metaphors. Relevance: This principle directly addresses cognitive load,
one of the primary usability challenges.

2. Simplify the Structure of Tasks

Complex tasks should be broken into simpler, more manageable steps. Multi-step wizards in
software installation (e.g., 'Step 1 of 5') simplify what could be an overwhelming process.
Relevance: Simplified task structures reduce errors and improve efficiency, key usability
metrics.

3. Make Things Visible

The controls needed to complete a task should always be visible. When controls are hidden or
unlabeled, users must guess or search, leading to frustration. In interfaces, navigation menus,
search bars, and action buttons should always be prominent. Relevance: Visibility is directly
linked to learnability and user efficiency.

4. Get the Mappings Right

Mappings are relationships between controls and their effects. A natural mapping means the
control layout mirrors the outcome layout. For example, scroll direction (scrolling down shows
content further down the page) is a natural mapping. Poor mappings cause confusion and
errors. Relevance: Good mappings reduce the Gulf of Execution, making interfaces more
intuitive.

5. Exploit the Power of Constraints

Constraints limit the range of possible actions, preventing users from making errors. Logical
constraints (a 'Submit' button grayed out until all required fields are filled) and cultural
constraints (red means stop) guide users toward correct behavior. Relevance: Constraints are a
primary tool for error prevention.

6. Design for Error

Norman advocates assuming that users will make errors and designing systems to handle them
gracefully. This means making errors detectable, reversible, and easy to recover from. For
example, a text editor's 'autosave' feature means a crash doesn't result in total data loss.
Relevance: Error-tolerant design is fundamental to user satisfaction and trust.

7. When All Else Fails, Standardize

When natural mappings and constraints cannot make a design intuitive, standardization
provides a fallback. Standardized conventions (QWERTY keyboard, traffic light colors) leverage
cultural learning. Following platform conventions (e.g., placing the hamburger menu in the top-
left on mobile) reduces the learning burden. Relevance: Standardization supports consistency, a
key usability heuristic. In summary, Norman's principles are directly relevant to usability
because they address core challenges: cognitive load, error prevention, learnability, and user
efficiency.

Q3. Demonstrate Nielsen's heuristics using real-world interfaces.

Jakob Nielsen's 10 usability heuristics provide a practical framework for evaluating and
improving interface design. Below, each heuristic is illustrated with real-world examples:
• 1. Visibility of System Status — YouTube shows a buffering spinner when video is
loading and a red progress bar showing how much of the video has loaded.
• 2. Match Between System and the Real World — The desktop metaphor (files,
folders, trash can) mirrors physical office concepts. Google Maps uses 'Turn left' rather
than 'Navigate to waypoint 3.'
• 3. User Control and Freedom — Gmail's 'Undo Send' feature gives users a few
seconds to retract an email. Ctrl+Z in MS Word is a classic example of supporting user
freedom.
• 4. Consistency and Standards — Apple's iOS maintains consistent navigation patterns
across all native apps. The back button is always in the top-left corner.
• 5. Error Prevention — Google Calendar grays out past dates when scheduling future
events. Flight booking sites show only available dates.
• 6. Recognition Rather Than Recall — Spotify shows recently played songs on the
home screen so users don't need to remember song names. Autocomplete in search
bars reduces recall demands.
• 7. Flexibility and Efficiency of Use — Excel supports both menu-based formatting and
keyboard shortcuts (Ctrl+B for bold). Gmail offers shortcuts for power users while
remaining menu-driven for novices.
• 8. Aesthetic and Minimalist Design — Google's homepage is famously minimalist —
just a search bar and logo. Apple's product pages use white space to keep focus on the
product.
• 9. Help Users Recognize, Diagnose, and Recover from Errors — Instead of 'Error
404,' well-designed sites say 'Page not found — try searching for what you need' with a
search box.
 • 10. Help and Documentation — Microsoft Office's 'Tell me what you want to do' search
helps users find features without knowing menu locations.
These heuristics, applied systematically, help designers identify and address usability problems
in any type of interface.

Q4. Compare different usability inspection methods.

Usability inspection methods are techniques used by evaluators (rather than end users) to
assess the usability of an interface. The major methods are compared below:

Heuristic Evaluation
In heuristic evaluation, 3-5 usability experts independently examine the interface against a set of
recognized usability principles (heuristics), such as Nielsen's 10 heuristics. Each evaluator
produces a list of usability problems with severity ratings. Results are then aggregated. This
method is quick, inexpensive, and can be performed early in the design process without
requiring real users. However, it is limited by the expertise of evaluators.

Cognitive Walkthrough
Cognitive walkthrough focuses specifically on evaluating the learnability of an interface for new
users. Evaluators simulate the thought process of a first-time user as they attempt to complete
specific tasks step by step. This method is particularly useful for identifying problems that affect
new or casual users. It requires a clear task definition and a prototype or working system.

Pluralistic Walkthrough
In this method, users, developers, and usability experts walk through tasks together, discussing
design decisions and issues as a group. This collaborative approach collects diverse
perspectives but can be time-consuming and may be influenced by group dynamics.

Feature Inspection
Evaluators examine the list of features in an interface to determine whether a feature is
necessary, usable, and consistent with the interface's overall design. Particularly useful for
identifying redundant or overly complex features.

Standards Inspection
An expert inspects the interface for compliance with established standards (e.g., ISO usability
standards, WCAG accessibility guidelines). Especially important in domains with regulatory
requirements.
Comparison Summary:

Method Focus Speed User Best For

Involvement
Heuristic Evaluation General Fast None Early-stage design
usability
Cognitive Walkthrough Learnability Moderate None New user tasks
Pluralistic Walkthrough Diverse Slow Yes Collaborative design
perspectives
 Method Focus Speed User Best For
Involvement
Standards Inspection Compliance Fast None Regulatory domains
Feature Inspection Feature Moderate None Feature-heavy systems
usability

Q5. Assess an interface using heuristic evaluation.

Heuristic evaluation is a structured method to identify usability problems in an interface by
comparing it against established principles. Below is a demonstration using a hypothetical
online banking interface evaluated against Nielsen's 10 heuristics:
• Heuristic 1 — Visibility of System Status (Severity: High): After clicking 'Transfer
Funds,' there is no loading indicator. Users do not know if their transaction is being
processed, potentially leading to duplicate transactions.
• Heuristic 2 — Match Between System and the Real World (Severity: High): Error
messages use banking system codes like 'ERR_TXN_502' rather than plain language
like 'Transfer failed. Your account balance is insufficient.'
• Heuristic 3 — User Control and Freedom (Severity: Critical): Once a transfer is
initiated, there is no 'Cancel' button. Users who initiated a transfer by mistake cannot
stop it.
• Heuristic 4 — Consistency and Standards (Severity: Critical): The 'Back' button on
some pages navigates to the previous screen, but on others it logs the user out entirely.
• Heuristic 5 — Error Prevention (Severity: High): The account number field accepts
letters and symbols, leading to errors only caught after submission.
• Heuristic 6 — Recognition Rather Than Recall (Severity: Medium): The beneficiary
list for fund transfers is buried three levels deep in menus.
• Heuristic 7 — Flexibility and Efficiency (Severity: Low): There are no keyboard
shortcuts or quick-access options for frequent tasks.
• Heuristic 8 — Aesthetic and Minimalist Design (Severity: Medium): The dashboard
is cluttered with promotional banners competing with critical account information.
• Heuristic 9 — Help Users Recover from Errors (Severity: High): The 'Forgot
Password' recovery process provides no guidance on password requirements.
• Heuristic 10 — Help and Documentation (Severity: Medium): There is no searchable
help section; the FAQ page is a static, unorganized list.
Priority: Critical issues (inconsistent Back button, no Cancel option) should be addressed
immediately. This evaluation reveals that while the interface functions correctly technically, it
has numerous usability flaws that could lead to user errors, frustration, and loss of trust —
particularly serious in a financial context.

Q6. Develop a state chart for an ATM transaction.

A state chart for an ATM transaction models all possible system states and transitions during a
user's interaction with the machine. Below is a detailed description:
Superstate: ATM System Active
• 1. Idle State — ATM displays welcome screen and waits for card insertion. Transition:
Card Inserted → Authentication State.
• 2. Authentication State — Contains two substates: PIN Entry (user enters 4-digit PIN;
correct PIN → Main Menu; 3 incorrect attempts → Card Captured State) and Card
Captured State (card retained by ATM).
• 3. Main Menu State — User sees options: Withdraw, Check Balance, Deposit, Transfer,
Change PIN. Transition: User selects option → corresponding functional state.
• 4. Withdrawal State (Superstate) — Contains: Amount Entry Substate (user enters
amount), Processing Substate (system contacts bank server), Cash Dispensing
Substate (cash dispensed and receipt offered), and Error Substate.
• 5. Balance Inquiry State — System retrieves and displays balance. Transition: →
Another Transaction? State.
• 6. Deposit State — User inserts cash/cheque, system verifies. Transition on success:
→ Confirmation State.
• 7. Fund Transfer State — User enters recipient account and amount. Transition on
success: → Confirmation State.
• 8. PIN Change State — User enters old PIN, new PIN, and confirmation. Transition on
success: → Confirmation State.
• 9. Another Transaction? State — System asks if user wants another transaction. Yes
→ Main Menu State. No → Card Return State.
• 10. Card Return State — Card is returned to user. Transition: → Idle State.
• 11. Timeout State — If no input received for 30 seconds in any state, session ends and
card is returned. Transition: → Idle State.

Concurrent States
The ATM simultaneously manages the user interaction states AND a session timer (concurrent
AND-state), which monitors for timeout independently of the user's navigation path.

History State
If a user is interrupted mid-session (e.g., by an error), the ATM can use the history mechanism
to return the user to the last stable state (e.g., Main Menu) rather than restarting the entire
transaction. This state chart captures the full complexity of ATM interaction, including error
handling, concurrency, and hierarchical state organization — demonstrating why state charts
are superior to simple FSMs for real-world systems.

Q7. Illustrate Petri nets with a dialog-based example.

Petri nets are a formal graphical and mathematical tool well-suited for modeling concurrent and
parallel processes in interactive dialog systems. They overcome a key limitation of FSMs — the
inability to model parallel activities occurring simultaneously.

Components of a Petri Net

• Places (circles) — Represent conditions or states (e.g., 'Waiting for username input').
• Transitions (bars) — Represent events or actions (e.g., 'Username submitted').
• Arcs (directed arrows) — Connect places to transitions and transitions to places,
defining the flow of control.
 • Tokens (filled dots inside places) — Represent the current active condition. A token's
presence in a place means that condition is currently true.
• Firing Rules — A transition is enabled when all of its input places contain at least one
token. When a transition fires, it consumes tokens from input places and produces
tokens in output places.

Dialog-Based Example: Online User Registration System

Consider a user registration dialog with two parallel validation processes: email validation and
password strength checking. These occur simultaneously after the user submits the form.
• Place P1 (Form Displayed) — Initial state; contains one token.
• Transition T1 (User Submits Form) — Fires when user clicks 'Register.'
• After T1 fires — Token moves to P2 (Validating Email) AND P3 (Checking Password
Strength) simultaneously — this parallelism cannot be easily represented in a simple
FSM.
• Transition T2 (Email Valid) — Fires when email check passes; token moves to P4
(Email OK). T3 (Email Invalid) fires otherwise, token moves to P5 (Email Error).
• Transition T4 (Password Strong) — Fires when password meets strength criteria;
token moves to P6 (Password OK). T5 fires otherwise.
• Transition T6 (Registration Complete) — Requires tokens in BOTH P4 (Email OK)
AND P6 (Password OK) to fire, representing synchronization. When T6 fires, token
moves to P8 (Account Created).

Key Advantages
Concurrency: The Petri net naturally models the simultaneous execution of email and password
validation (places P2 and P3 both active at the same time), which an FSM would struggle to
represent. Synchronization: T6 elegantly represents that registration only completes when
BOTH validations pass. Petri nets are particularly valuable for systems involving concurrent
user inputs, parallel server-side processes, and synchronization requirements.

Q8. Analyze usability issues in a poorly designed interface.

For this analysis, consider a poorly designed hospital appointment booking interface. Identifying
usability issues demonstrates how design flaws can have serious real-world consequences in
critical domains.
• Issue 1 — Poor Visibility of System Status: After clicking 'Book Appointment,' the
page shows no loading indicator or confirmation. This leads to duplicate bookings as
anxious users click repeatedly. Fix: Add a progress spinner and a clear 'Booking
Confirmed' screen with a reference number.
• Issue 2 — Language Mismatch: The interface uses medical jargon like 'Schedule a
consultation with a specialist in your preferred nosology category.' Most patients don't
know what 'nosology' means. Fix: Use plain language: 'Choose the type of doctor you
need (e.g., Heart Doctor, Eye Doctor).'
• Issue 3 — No Undo or Error Recovery: Once an appointment is booked, there is no
'Cancel' or 'Reschedule' option visible. Users must call the hospital helpline. Fix: Provide
a 'Cancel Appointment' button on the booking confirmation page.
• Issue 4 — Inconsistency: The date picker uses DD/MM/YYYY format on the
appointment page but MM/DD/YYYY on the insurance page. In a medical context, this
can cause serious booking errors. Fix: Standardize date formats throughout.
 • Issue 5 — Inadequate Error Prevention: The phone number field accepts any input
including letters. Errors are only flagged after form submission. Fix: Implement real-time
inline validation.
• Issue 6 — High Recall Demand: The system does not show which doctors are
available on selected dates. Users must note names from a separate page before
returning to book. Fix: Integrate doctor selection and availability check into a single step.
• Issue 7 — Cluttered Design: The appointment booking page is overcrowded with
promotional health packages and insurance advertisements. Fix: Apply progressive
disclosure — show only booking-relevant information during the booking flow.
• Issue 8 — Poor Error Messages: When a user enters an expired insurance ID, the
system displays: 'Error Code INS_412: Transaction declined by external validator.' Fix:
Replace with: 'Your insurance ID appears to be expired. Please check your insurance
card or contact your provider.'
• Issue 9 — No Help or Documentation: There is no FAQ, tooltip, or help link on any
page. Fix: Add contextual '?' icons next to complex fields with brief explanations.
• Issue 10 — No Session Timeout Warning: The system has a 10-minute timeout but
provides no warning. Users silently lose all entered data. Fix: Display a warning dialog 2
minutes before timeout, offering users the option to extend their session.
These usability issues collectively result in frustrated users, booking errors, unnecessary burden
on hospital helplines, and in the worst case, missed medical appointments. This underscores
the critical importance of rigorous usability evaluation, especially in high-stakes domains.

Q9. Apply usability heuristics to critique a website.

For this critique, consider a popular e-commerce website evaluated against Nielsen's 10
usability heuristics:
• Heuristic 1 — Visibility of System Status: The website displays a spinning loader
when adding items to the cart, but the cart icon in the header does not update until the
page is refreshed. Recommendation: The cart icon count should update immediately
and a brief 'Item added to cart' notification should appear.
• Heuristic 2 — Match Between System and the Real World: The checkout uses terms
like 'Billing Address' and 'Shipping Address' clearly. Product categories use familiar
language. The shopping cart icon reinforces the real-world metaphor effectively. This
heuristic is largely satisfied.
• Heuristic 3 — User Control and Freedom: Users can edit their cart freely. However,
once the 'Place Order' button is clicked, there is no confirmation step — the order is
immediately placed. Recommendation: Add a confirmation dialog or an 'Order Review'
step before final submission.
• Heuristic 4 — Consistency and Standards: The 'Add to Wishlist' button uses a heart
icon on product pages but a bookmark icon on the search results page.
Recommendation: Standardize the wishlist icon across all pages.
• Heuristic 5 — Error Prevention: The coupon code field does not indicate whether
codes are case-sensitive. Recommendation: Make coupon codes case-insensitive or
clearly state the format requirement.
• Heuristic 6 — Recognition Rather Than Recall: The website shows 'Recently Viewed
Items' and 'Your Previous Orders' prominently. Search suggestions appear while typing.
This heuristic is well implemented.
 • Heuristic 7 — Flexibility and Efficiency of Use: 'Buy Now' and 'Add to Cart' are both
available on product pages. Filters help experienced users narrow results efficiently.
However, there are no keyboard shortcuts.
• Heuristic 8 — Aesthetic and Minimalist Design: The homepage is heavily cluttered
with rotating banners, flash sale timers, and sponsored placements. Recommendation:
Reduce promotional elements on the homepage and prioritize search functionality.
• Heuristic 9 — Help Users Recover from Errors: When a payment fails, the error
message says 'Payment unsuccessful. Please try again' without explaining why.
Recommendation: Provide specific messages like 'Your card was declined. Please
check your card details.'
• Heuristic 10 — Help and Documentation: The help center is accessible from the
footer but not from within the checkout flow. Recommendation: Add a 'Need Help? Chat
with Us' link directly on the checkout pages.
Priority: Critical — Heuristics 1, 5, 9. High Priority — Heuristics 3, 8, 10. Addressing these
issues would significantly improve conversion rates and user satisfaction.

Q10. Interpret Norman's interaction model using a suitable diagram.

Norman's interaction model describes the full cycle of interaction between a user and a system.
It identifies two fundamental gaps — the Gulf of Execution and the Gulf of Evaluation — that
designers must minimize to create usable systems.

The Seven Stages of Action

Norman's model breaks user interaction into seven stages, grouped around the two gulfs:
• Gulf of Execution (Thinking → Acting):
• 1. Forming a Goal — The user identifies what they want to achieve (e.g., 'I want to save
this document').
• 2. Forming an Intention — The user decides on a specific plan of action (e.g., 'I will use
Ctrl+S').
• 3. Specifying an Action — The user determines the exact physical actions required
(e.g., pressing Ctrl and S simultaneously).
• 4. Executing the Action — The user physically performs the action (pressing the keys).
• Gulf of Evaluation (Observing → Interpreting):
• 5. Perceiving the State of the World — The user observes the system's response
(e.g., sees 'Saved' appear in the title bar).
• 6. Interpreting the State of the World — The user interprets what the system's
response means (e.g., 'The document has been saved').
• 7. Evaluating the Outcome — The user compares the outcome to their original goal
(e.g., 'Yes, my document is now saved — goal achieved').

The Two Gulfs

• Gulf of Execution — The difficulty a user faces in figuring out how to make the system
do what they want. A wide Gulf of Execution means the available controls are unclear or
don't match the user's mental model. Design solution: Improve affordances, visibility,
and mappings.
• Gulf of Evaluation — The difficulty a user faces in determining whether their action
achieved the desired result. A wide Gulf of Evaluation means system feedback is
 inadequate, delayed, or ambiguous. Design solution: Improve feedback quality,
immediacy, and clarity.

Example Application — ATM Machine

• Goal: Withdraw money.
• Intention: Use the 'Withdraw Cash' option.
• Action Specification: Press the 'Withdraw' button on the touchscreen.
• Execution: Tap 'Withdraw' → select account → enter amount → confirm.
• Perception: Machine makes a sound, cash drawer opens.
• Interpretation: Cash is being dispensed.
• Evaluation: Cash received — goal achieved.
Gulf of Execution problem: If the ATM's menu uses confusing labels like 'Debit from Primary
Linked Instrument' instead of 'Withdraw Cash,' users struggle to map their intention to the
available controls. Gulf of Evaluation problem: If the machine dispenses cash but shows no on-
screen confirmation, users may be unsure whether the full amount was dispensed correctly.
Norman's model is invaluable because it provides a cognitive framework for diagnosing usability
problems. When users struggle, the problem can be traced to a specific stage in the cycle,
allowing designers to target improvements precisely.

Q11. Evaluate the usability of a mobile application.

For this evaluation, consider a food delivery mobile application assessed across key usability
dimensions:
• 1. Learnability: The app uses familiar metaphors — a shopping cart for orders, a
magnifying glass for search, and a home icon for the main page. New users can
navigate basic functions without a tutorial. However, the 'Group Order' feature is difficult
to discover — buried inside the restaurant page behind an unlabeled icon.
Recommendation: Highlight the Group Order feature with a brief onboarding tooltip on
first use.
• 2. Efficiency: Returning users can reorder previous meals in two taps from the home
screen. Search with filters is fast and responsive. However, applying multiple filters
requires multiple screen navigations rather than a single filter panel. Recommendation:
Implement a comprehensive filter panel accessible from a single tap.
• 3. Memorability: The app saves delivery addresses, payment methods, and favorite
restaurants, significantly reducing effort for returning users. The navigation structure is
consistent, supporting rapid re-establishment of proficiency. This dimension is well
handled.
• 4. Error Tolerance: The app handles network errors gracefully, showing 'Connection
lost — your cart is saved.' However, if a user accidentally removes an item from the cart,
there is no 'Undo' option. Recommendation: Add an 'Undo Remove' option that appears
briefly after item removal.
• 5. User Satisfaction: The app uses appealing food photography, smooth animations,
and real-time delivery tracking with a map showing the driver's location. However, the
rating and review system requires multiple mandatory steps before submission.
Recommendation: Make all review elements except the star rating optional.
 • 6. Visibility of System Status: The real-time order status tracker (Order Placed →
Being Prepared → On the Way → Delivered) with time estimates is excellent. Push
notifications at each stage further reinforce status visibility.
• 7. Error Prevention: When a user attempts to checkout without specifying a delivery
address, the app highlights the missing field. However, it does not warn users if an item
in their cart has become unavailable until they attempt to pay. Recommendation: Check
item availability in real time.
• 8. Accessibility: The app uses color alone to distinguish between available (green) and
unavailable (grey) items, which is problematic for color-blind users. Recommendation:
Add a text label alongside color coding.
Overall Rating: The application performs well in efficiency for returning users, system status
visibility, and network error handling. Primary areas for improvement are error recovery,
discoverability of advanced features, and accessibility. These targeted improvements would
elevate the application from good to excellent usability.

Q12. Formulate a dialog for an online ticket booking system.

An online ticket booking system requires a carefully designed dialog that guides users through a
complex multi-step process while remaining clear, efficient, and error-tolerant:

Step 1: Home / Search State

System displays 'Search for Events' with fields for event type, location, date range, and
keywords. User fills in search criteria and submits. Transition: Search Executed → Results
State. Error handling: If no results found → 'No events match your search. Try different dates or
keywords.' with a 'Modify Search' button.

Step 2: Event Selection State

System displays a list of matching events with thumbnail images, dates, venues, prices, and
availability indicators. User selects an event. Transition: Event Selected → Seat/Category
Selection State.

Step 3: Seat/Category Selection State

System displays an interactive seating map or ticket categories. Available seats are shown in
green with a text label for accessibility. User selects seats and quantity. Feedback: Selected
seats highlight immediately; running total shown at bottom. Error handling: If selected quantity
exceeds availability → 'Only 3 seats available in this category.'

Step 4: Booking Details State

System prompts for attendee information: Full Name (required), Email Address (required, with
inline format validation), Phone Number (optional), Special Requirements (optional). Feedback:
Inline validation as fields are completed. Transition: Details Confirmed → Payment State.

Step 5: Payment State

System displays order summary with event name, date, seats selected, subtotal, booking fee,
and total. User selects payment method. Security indicator shown. Error handling: 'Your card
was declined. Please check your card details or try a different payment method.' Transition on
success: → Confirmation State.
Step 6: Confirmation State
System displays 'Booking Confirmed!' with booking reference number, event details, seat
numbers, and QR code for entry. Options: 'Download Ticket (PDF),' 'Add to Calendar,' 'Share
with Friends.' Email confirmation sent automatically.

Step 7: Cancellation Dialog

Accessible from 'My Bookings.' System displays cancellation policy with a confirmation prompt:
'Are you sure you want to cancel? This action cannot be undone.' with 'Yes, Cancel' and 'No,
Keep Booking' buttons.

Design Principles Applied

• Progress Indicator — Clear closure at each step (progress indicator showing Step X of
6).
• Error Prevention — Through inline validation at each step.
• Undo Supported — Through the cancellation flow.
• Consistent Navigation — Back button always visible and always functional.

Q13. Assess the role of feedback in dialog systems.

Feedback is one of the most fundamental principles in dialog system design. It forms the bridge
between user actions and system responses, enabling users to understand the results of their
interactions and maintain an accurate mental model of the system's state.

Types of Feedback in Dialog Systems

• 1. Acknowledgment Feedback — Confirms that the system has received the user's
input. Examples include a button visually depressing when clicked, a text field
highlighting when selected, or a brief animation when an item is added to a shopping
cart. Without acknowledgment feedback, users are unsure whether their input was
registered, leading to repeated actions and potential errors (e.g., double-clicking a
'Submit' button and creating duplicate orders).
• 2. Progress Feedback — For tasks that take time, progress feedback keeps users
informed and patient. Progress bars, percentage indicators, and 'Loading...' messages
fall into this category. Research shows that users are more tolerant of delays when
progress feedback is provided.
• 3. Error Feedback — Alerts users to mistakes and guides correction. Effective error
feedback is immediate, specific, and constructive. For example, when a user enters an
invalid date, the field should immediately highlight in red with the message 'Please enter
a valid date (DD/MM/YYYY)' rather than waiting for form submission.
• 4. Completion Feedback — When a task is completed, clear completion feedback
provides psychological closure. 'Your order has been placed — Order #12345' or 'File
saved successfully' are examples. Completion feedback assures users that their goal
has been achieved.
• 5. Status Feedback — Continuous status feedback informs users of the system's
current state. Examples include the battery indicator on a phone, the word count in a
document editor, or the 'Online/Offline' status in a messaging app.
• 6. Confirmatory Feedback — Before irreversible actions, confirmatory feedback (e.g.,
'Are you sure you want to delete this file? This cannot be undone.') gives users a final
opportunity to verify their intention.
Importance in Multi-Step Dialogs
In complex dialogs, feedback serves as the connective tissue that links each step. A progress
indicator ('Step 3 of 5') provides constant orientation, while step-completion acknowledgments
keep users moving confidently through the dialog.

Consequences of Poor Feedback

Systems with inadequate feedback cause users to: repeatedly perform actions (because they're
unsure if the first worked), lose trust in the system, abandon tasks prematurely, or make
irreversible errors. In critical systems like medical or financial applications, poor feedback can
have serious real-world consequences. In summary, feedback transforms a dialog from a one-
sided command interface into a genuine two-way conversation between user and system.

Q14. Examine how design guidelines influence usability.

Design guidelines are structured sets of recommendations, principles, and rules that guide the
development of user interfaces. Their influence on usability is profound, operating at multiple
levels of the design process.
• 1. Providing a Shared Framework — Design guidelines (such as Nielsen's heuristics,
Shneiderman's golden rules, or platform-specific guidelines like Google's Material
Design) give design teams a common vocabulary and framework. This consistency
ensures all team members are working toward the same usability goals, reducing
conflicting decisions.
• 2. Preventing Common Usability Problems — Many guidelines directly target
recurring usability issues. The guideline 'offer informative feedback' directly prevents
users from being unaware of system status. The guideline 'error prevention' leads
designers to implement input validation and confirmation dialogs.
• 3. Improving Learnability — Guidelines around consistency, natural mappings, and
real-world metaphors directly improve learnability. When a system follows platform
conventions, new users can transfer their existing knowledge to the new system,
reducing the learning curve.
• 4. Reducing Cognitive Load — Guidelines like 'reduce short-term memory load' and
'recognition rather than recall' specifically address cognitive load — one of the primary
causes of usability problems. The result is a less mentally demanding interface that
users can operate more efficiently.
• 5. Enhancing Error Tolerance — Guidelines around error prevention, error recovery,
and undo functionality produce systems with safety nets at every level — preventing,
catching, and recovering from errors — increasing user confidence.
• 6. Supporting Accessibility — Many guidelines explicitly address accessibility —
ensuring that interfaces are usable by people with varying physical, cognitive, and
sensory abilities.
• 7. Providing Evaluation Criteria — Design guidelines also serve as evaluation criteria.
Heuristic evaluation is based entirely on applying design guidelines (heuristics) to an
interface to identify violations. This dual role amplifies the influence of guidelines across
the entire design lifecycle.
• 8. Limitations of Design Guidelines — Guidelines are general principles that may
sometimes conflict with each other or with specific domain requirements. They should be
applied with contextual judgment, not mechanically. User testing remains essential to
validate that guidelines have been applied effectively.
In conclusion, design guidelines influence usability by providing a proactive, structured
approach to building interfaces that are consistent, learnable, efficient, error-tolerant, and
accessible. They transform implicit knowledge about good design into explicit, actionable rules
that can be applied systematically.

Q15. Apply Nielsen's heuristics to an e-commerce interface.

Applying Nielsen's 10 usability heuristics to an e-commerce interface provides a structured
critique that identifies specific usability problems and guides targeted improvements:
• Heuristic 1 — Visibility of System Status (Impact: High): After adding an item to the
cart, the cart icon does not update immediately — it shows the old count until the user
navigates elsewhere. May lead to duplicate additions. Recommendation: Update the cart
count instantly and show a brief 'Added to Cart' notification.
• Heuristic 2 — Match Between System and the Real World: Product descriptions use
consumer-friendly language. Size charts use familiar measurements. However, the
returns process uses jargon like 'Initiate RMA (Return Merchandise Authorization).'
Recommendation: Replace with 'Start a Return.'
• Heuristic 3 — User Control and Freedom (Impact: Medium): The 'Continue
Shopping' button after adding an item to the cart navigates back to the homepage rather
than the previous product category page, disrupting browsing flow. Recommendation:
Navigate back to the specific product category.
• Heuristic 4 — Consistency and Standards: The 'Wishlist' feature uses a heart icon on
mobile but a star icon on the desktop version. The checkout button is labeled 'Proceed to
Buy' on the cart page but 'Complete Purchase' on the review page. Recommendation:
Standardize all interface elements across platforms.
• Heuristic 5 — Error Prevention (Impact: High): The coupon code field is case-
sensitive but provides no indication. The site allows users to enter a quantity of 0 for an
item, which only throws an error at checkout. Recommendation: Make coupon codes
case-insensitive; implement real-time quantity validation (minimum quantity of 1).
• Heuristic 6 — Recognition Rather Than Recall: The site shows 'Recently Viewed' and
'Previously Ordered' sections, reducing recall demands. However, advanced search filter
options disappear when the user scrolls down on mobile. Recommendation: Implement
sticky filter controls or a fixed 'Filters' button.
• Heuristic 7 — Flexibility and Efficiency of Use: There are no quick-buy options for
repeat purchases. Returning users must go through the full product page → cart →
checkout flow even for items they buy regularly. Recommendation: Add a 'Buy Again'
one-click option on the order history page.
• Heuristic 8 — Aesthetic and Minimalist Design (Impact: High): The homepage
contains 5 rotating banners, 3 flash sale timers, multiple carousels, sponsored products,
and a newsletter popup — all simultaneously competing for attention. Recommendation:
Limit the homepage to 2-3 key promotional areas; remove auto-playing carousels.
• Heuristic 9 — Help Users Recover from Errors (Impact: High): When payment fails,
the error message simply states 'Payment could not be processed.' It doesn't specify
whether the issue is with the card number, insufficient funds, or network.
Recommendation: Implement specific messages like 'Your card was declined by your
bank. Please try a different payment method.'
• Heuristic 10 — Help and Documentation: The customer support chat option is only
available from the 'Contact Us' page, requiring 3 navigation steps to reach. During
 checkout — where users most need support — there is no visible help option.
Recommendation: Embed a 'Need Help? Chat with Us' button directly on the checkout
pages.
Priority Summary: Critical (fix immediately) — Heuristics 1, 5, 9. High Priority — Heuristics 3, 8,
10. Medium Priority — Heuristics 4, 6, 7. Implementing these recommendations systematically
would result in a measurably more usable e-commerce interface, directly improving conversion
rates, reducing cart abandonment, and increasing customer satisfaction.