HCI in the
Software Process
M O D U L E 5
Outline
• Software Development Lifecycle
• Verification and Validation
• Usability engineering
• ISO usability standard 9241
• Techniques for prototyping
• Design space analysis
Software development lifecycle (SDLC)
The software development lifecycle (SDLC) is a structured approach used in
software engineering to design, develop, test, and deploy software.
It ensures high-quality software while minimizing risks and maximizing efficiency.
Here’s how HCI fits into the various phases of the software lifecycle:
1. Requirements Analysis
HCI Focus: At this stage, user needs and tasks are analyzed. The goal is to
understand the users, their environments, and their goals. Techniques like user
interviews, observations, and personas help in identifying the functional and usability
requirements.
HCI Contribution: Ensures the requirements are human-centered, focusing on
usability, accessibility, and user satisfaction.
2. Design
HCI Focus: This phase involves creating prototypes and mockups to visualize the user
interface and interactions. It includes:
• Low-fidelity prototypes (e.g., sketches or wireframes). Ex: E-commerce- show
how the home page, product listing, and checkout processes will look.
• High-fidelity prototypes (interactive models) - includes drag-and-drop
functionality for users to customize their shopping experience.
• Focus on interaction design principles, such as affordances, feedback, and
consistency.
HCI Contribution: Ensures that the design is intuitive, easy to use, and meets the
needs of users. Techniques such as user journey mapping and storyboarding are
applied. Ex: users prefer a horizontal navigation bar and a search bar with auto-
suggestions, helping them to quickly locate products.
3. Implementation/Development
HCI Focus: During implementation, HCI designers collaborate with developers to
ensure that the interface and interactions are built as intended. Any design changes
must be tested for usability. Example: Smartwatch Interface Development -
ensure that features like heart rate monitoring and fitness tracking are easy to
access with minimal swiping and tapping.
HCI Contribution: Developers rely on HCI guidelines and user feedback to ensure
the system remains user-friendly. Example: ensure that the interface works
smoothly even with a small screen. Front-end design is particularly important here.
4. Testing
HCI Focus: This stage involves testing the usability of the system. Common
techniques include:
• Usability testing with 10 real users who use the streaming app to search for
movies, add them to their watchlist, and play them. During the test, you
observe that users struggle with locating the watchlist feature.
• Heuristic evaluation (expert-based evaluation).
• Cognitive walkthroughs (evaluating ease of learning).
HCI Contribution: Identifying pain points in user interaction, navigation, and
overall experience. HCI experts can suggest design modifications based on the
feedback from tests.
Example: Expert may recommend moving the watchlist feature to a more prominent
position on the home screen and adding clearer labels.
5. Deployment
HCI Focus: During deployment, it’s essential to provide user training and support.
Good documentation and onboarding processes can improve user adoption and
satisfaction. An onboarding experience that includes video tutorials and in-app
walkthroughs to guide new users. You also ensure there is a help section with clear
FAQs and a chatbot for user support.
HCI Contribution: Ensures that users understand how to use the system and that
the system performs as expected in real-world environments.
With well-designed onboarding, you minimize the learning curve and improve user
satisfaction. Users feel more confident in using the system from the beginning,
reducing the need for constant support.
6. Maintenance and Evaluation
HCI Focus: Post-deployment, the system should be continuously monitored for
performance, user feedback, and issues related to usability. Iterative improvements
are part of maintaining a user-friendly system. Ex: Fitness App update - After the
app has been deployed, you collect user feedback through surveys and in-app
analytics. Users report frustration with the navigation of workout categories.
HCI Contribution: User feedback is analyzed to find areas where interaction can
be improved. Updates to the interface and functionality are often made based on
evolving user needs or issues encountered.
Common SDLC Models:
• Waterfall Model: Linear and sequential; each phase must be completed before
moving to the next and there is typically no overlap between phases.
• Agile Model: Iterative and incremental; focuses on collaboration and flexibility.
Agile breaks the project into small, manageable units called sprints (usually 1–4
weeks long), allowing teams to adapt to changes quickly.
• V-Model (Verification and Validation): Extension of the Waterfall with
simultaneous testing at each phase.
• Iterative Model: Develops software incrementally, refining it through repeated
cycles.
• DevOps: Combines development and operations, emphasizing automation,
continuous integration, and delivery.
Agile Example: Building a Library
Management System Sprint 3: Borrowing & Returning
Sprint 1: User Registration & Login • Goal: Enable users to borrow and return books.
Goal: Implement basic user authentication.
• Tasks: Track borrowed books, due dates, and return
Tasks: Design login UI, set up user database, status.
implement login/logout functionality.
• Duration: 2 weeks
Duration: 2 weeks
• Deliverable: Borrow/return system.
Deliverable: Working login system.
Sprint 4: Admin Features
Sprint 2: Book Catalog
• Goal: Allow librarians to manage inventory.
Goal: Allow users to browse and search books.
Tasks: Create book database, search/filter features, • Tasks: Add/edit/delete books, view user activity.
display book details. • Duration: 2 weeks
Duration: 2 weeks
• Deliverable: Admin dashboard.
•
Verification and Validation (V&V)
In the context of Human-Computer Interaction (HCI), Verification and Validation
(V&V) are key steps in ensuring the system or product being developed meets both
the design specifications and the user's needs.
1. Verification:
Verification answers the question, "Are we building the product right?" It ensures
that the product being developed meets the specified requirements and design
guidelines before it is released or tested with users.
Verification is about checking that the system or interface works as intended and
adheres to the technical and design standards.
In HCI, verification includes the following:
• Checking consistency with user requirements: Ensuring that the interface
design follows the specified user goals and tasks.
• Prototype evaluations: Testing interactive prototypes at various stages of
development to ensure that they are progressing in line with the initial
specifications.
• Usability testing for functionality: Conducting controlled usability tests to see
if the user can complete tasks without errors.
Example of Verification in HCI: Imagine designing a medical app interface for
doctors to input patient information. Verification would involve making sure the
input fields align correctly with medical data standards, the functionality (like data
entry and storage) works without bugs, and the interface follows health compliance
rules.
2. Validation:
• Validation answers the question, "Are we building the right product?" This step
ensures that the final product meets the user's needs and expectations. It focuses
on whether the system actually supports the users in completing their tasks
efficiently, effectively, and satisfactorily.
• Validation is about user-centered evaluation and testing, ensuring the product fits
the context of use and user goals.
• User-centered testing: Involves gathering feedback from actual users through
usability tests, interviews, or observations to determine if the system satisfies their
needs.
• Real-world scenarios: Testing the interface in environments or situations where
users will actually be working (e.g., simulating real-world interactions in the
workplace).
• Iterative Design: Using feedback from validation tests to improve the design
iteratively, making sure that the system evolves based on user insights.
Example of Validation in HCI: In the same medical app, validation would
involve having real doctors use the system in a clinical setting. You would test
whether they find it easy to input data during a busy day and whether the design
helps them achieve their goal without frustration. If doctors struggle to input data
quickly, validation testing would identify this as a key issue for further
improvement.
V-Model Example: Library Management System
Left Side – Development Phases (Verification)
Right Side – Testing Phases (Validation)
• Requirements Analysis
• Each testing phase validates the
Define system requirements (e.g., user login, book catalog, borrowing system).
corresponding development phase:
Corresponding Test: Acceptance Testing
• Unit Testing: Tests individual
• System Design
functions/components.
Plan system architecture, database schema, and interfaces.
• Integration Testing: Tests interactions
Corresponding Test: System Testing
between modules.
• High-Level Design
• System Testing: Tests the complete system as
Break down system into modules (e.g., user module, book module). a whole.
Corresponding Test: Integration Testing
• Acceptance Testing: Validates the system
• Low-Level Design against user requirements.
Design individual components and functions.
Corresponding Test: Unit Testing
• Implementation
Write the actual code for each module.
Key Differences:
• Verification ensures the system is built according to design specs
(internal focus), while Validation ensures the system meets the users'
needs (external focus).
• Verification typically occurs during the development phase, while
validation happens after the system is built and ready to be tested with
real users.
Iterative Model Example: Library Management System
Iteration 1: Basic Book Catalog
Iteration 3: Borrowing System
• Goal: Create a simple system to list and search books.
• Goal: Enable borrowing and returning of books.
• Activities:
• Activities:
Design basic UI and database.
Add borrowing logic and due date tracking.
Implement book listing and search.
Test with sample users.
Test and gather feedback.
• Outcome: Functional borrowing system.
• Outcome: A working catalog feature.
Iteration 4: Admin Features
Iteration 2: User Registration
• Goal: Allow librarians to manage books and users.
• Goal: Add user login and registration.
• Activities:
• Activities:
Implement admin dashboard.
Design user module.
Add book editing and user management.
Implement login/logout.
Test and refine based on feedback. • Outcome: Full-featured admin control.
• Outcome: Users can now log in and access the catalog.
DevOps Example: Library Management System
1. Planning
4. Testing
• Teams define features like book search, user login,
• Automated unit, integration, and UI tests run in pipelines.
borrowing system.
• Tools: Selenium, JUnit, Postman for API testing.
• Use tools like Jira or Azure Boards for tracking tasks.
5. Deployment (CD)
2. Development
• Code is automatically deployed to staging or production
• Developers write code using version control (e.g., Git).
environments.
• Code is pushed to repositories like GitHub or GitLab.
• Tools: Docker, Kubernetes, Terraform, Ansible.
3. Continuous Integration (CI)
6. Monitoring & Feedback
• Every code change triggers automated builds and tests.
• Monitor system performance and errors using tools
• Tools: Jenkins, GitHub Actions, Azure DevOps Pipelines.
like Prometheus, Grafana, or New Relic.
• Feedback loops help improve future iterations.
Usability Engineering
• Usability engineering is a discipline within Human-Computer Interaction
(HCI) that focuses on improving the design of user interfaces and
interactions, with the primary goal of making systems easier and more
efficient for users.
• It systematically applies principles, methods, and tools to assess and
enhance the usability of a system or product.
Key aspects of usability engineering
include:
1. Usability Goals:
• Usability engineering focuses on defining measurable usability goals for a
system, such as:
• Effectiveness: Can users achieve their objectives using the system?
• Efficiency: How much effort (time and resources) does it take to complete
tasks?
• Satisfaction: How do users feel when interacting with the system?
2. Iterative Design Process:
• The usability engineering process is typically iterative. Designers create
prototypes, test them with users, gather feedback, and then refine the
designs in cycles.
• Prototyping: Early versions of the interface are built to explore design
solutions.
• User Testing: Real users interact with the prototypes, and their
behavior is observed. Common usability issues, like unclear navigation
or confusing icons, can be detected.
• Evaluation: Feedback and testing results are analyzed to measure
performance against usability goals.
3. Usability Testing:
• A core part of usability engineering is conducting usability tests where
real users perform tasks on the system while experts observe and
record issues.
• Usability testing identifies problems in how users interact with the
system.
• This helps designers understand where the system is falling short.
Example: Usability Engineering in a
Web Application
Imagine a new e-commerce website where users can browse products, add
items to their cart, and check out.
1. Defining Usability Goals: The team defines goals such as:
• Users should be able to find and purchase a product within 5 minutes
(Efficiency).
• At least 90% of users should successfully complete the checkout
process (Effectiveness).
• Users should rate their experience at least 4 out of 5 in post-task
surveys (Satisfaction).
2. Design and Prototyping: The team creates a clickable prototype of
the website, including a product catalog, a shopping cart, and a checkout
system.
3. Usability Testing: During usability testing, users are asked to search
for a product, add it to the cart, and check out. Observations are made:
• Some users struggle to find the checkout button because it is small and
hidden at the bottom of the page.
• Other users express confusion over the lack of progress indicators during
the multi-step checkout process.
4. Refinement: Based on feedback, the team makes the checkout button more
prominent and adds a progress bar to the checkout process.
5. Re-testing: The revised design is tested again to see if users find the new
version easier and more intuitive to use.
Tools and Methods in Usability Engineering:
• Heuristic Evaluation: Experts evaluate the system based on usability
principles (heuristics) such as visibility of system status, error prevention, and
consistency.
• Surveys and Questionnaires: These collect user feedback about
satisfaction and perceived ease of use.
• Cognitive Walkthrough: Designers simulate the thought processes of users
trying to accomplish tasks, looking for areas where they might struggle.
ISO usability standard 9241
ISO 9241 is an international standard that provides guidelines and
specifications for the design of user interfaces, particularly focusing on
usability and ergonomics in Human-Computer Interaction (HCI).
It is a multi-part standard developed by the International Organization
for Standardization (ISO) and covers a wide range of topics, all aimed at
ensuring that systems are designed with user-centered principles in
mind.
Key Aspects of ISO 9241 in HC
1. Usability Definition:
• ISO 9241 defines usability as the extent to which a product can be used by
specified users to achieve specific goals with effectiveness,
efficiency, and satisfaction in a particular context of use. This definition
emphasizes three major aspects:
• Effectiveness: How accurately and completely users can achieve their
goals.
• Efficiency: The resources (time, effort) expended to achieve the goals.
• Satisfaction: The comfort and positive attitude users have when
interacting with the system.
2. Structure of ISO 9241:
• The standard is divided into multiple parts, each focusing on different aspects
of usability and human-centered design. A few key parts are:
• ISO 9241-11: Usability Framework: It focuses on the basic definition of
usability and explains how it can be measured by evaluating the
effectiveness, efficiency, and satisfaction of users.
• ISO 9241-110: Interaction Principles: This section describes general
ergonomic principles for the design of user-system interfaces, such as
consistency, user control, and feedback.
• ISO 9241-210: Human-Centered Design: It provides guidelines for
designing interactive systems that meet user needs. It focuses on involving
users throughout the design and development process.
3. Human-Centered Design Process (ISO 9241-210):
• This part emphasizes the need for a human-centered approach in design, which
means involving users in every phase of the design and development process.
The key stages of the human-centered design process include:
• Understanding and specifying the context of use: Identifying who the users
are, what they are trying to achieve, and in what environment they will use the
system.
• Specifying the user and organizational requirements: Defining the needs and
goals of the users and how the system can meet them.
• Producing design solutions: Creating prototypes and designs that address the
identified needs.
• Evaluating designs: Continuously testing and refining the design through user
feedback and usability testing.
4. Benefits of Using ISO 9241 in HCI:
• Consistency: Following ISO 9241 helps ensure that designs are consistent and
align with recognized usability and ergonomic principles.
• User Satisfaction: By following a user-centered design process, products are
more likely to meet user expectations, leading to higher satisfaction.
• Accessibility: It promotes designs that are more accessible to a wider range of
users, including people with disabilities.
• Efficiency in Design: The human-centered approach saves time and resources
by reducing the need for major redesigns after deployment.
By adhering to ISO 9241, the software company ensures that the application
meets usability standards, making it more likely to succeed in the market due to
positive user experiences.
Techniques for prototyping
In Human-Computer Interaction (HCI), prototyping is a key technique
used to explore and validate design ideas early in the development
process. It allows designers to create representations of a system to test
concepts, gather feedback, and make iterative improvements.
There are several common techniques for prototyping in HCI, each with
its own purpose and application:
1. Low-Fidelity Prototyping
• Description: This involves creating a rough and simple version of the product,
often using basic materials like paper, post-its, or sketching software. The focus is
on the overall structure and interaction flow rather than detailed aesthetics.
• Example: Paper prototypes where screens are drawn on paper to simulate the
interface of a mobile app. Users can “interact” by point ing to different parts of the
paper, while a facilitator changes the drawings to simulate screen transitions.
• Benefits:
• Quick to create and modify.
• Helps to explore multiple design ideas at an early stage.
• Cost-effective.
• Drawbacks:
• Limited functionality, cannot represent detailed interactions or animations.
2. High-Fidelity Prototyping
• Description: These prototypes are more detailed and closer to the final product, both
in appearance and interaction. They can be made using prototyping tools like Adobe
XD, Figma, or Axure, which allow for interactive elements like clickable buttons and
simulated user flows.
• Example: A fully clickable mobile app prototype built in Figma where users can tap
buttons to navigate between screens, view transitions, and see real content.
• Benefits:
• Realistic experience for users and stakeholders.
• Can simulate actual interactions and behaviors.
• Drawbacks:
• More time-consuming to develop.
• Can be harder to modify quickly after feedback.
3. Wizard of Oz Prototyping
• Description: In this method, the user interacts with a system that appears to be
autonomous, but behind the scenes, a hum an is controlling the system's behavior. This is
often used for simulating complex systems like AI or voice interfaces.
• Example: Simulating a voice assistant by having a human respond to spoken commands
instead of a real AI. The user thinks they are interacting with an AI, but the responses are
controlled by the facilitator.
• Benefits:
• Allows for testing complex systems that aren’t fully developed.
• Great for testing interactions with AI or automation.
• Drawbacks:
• Difficult to scale beyond a few users.
• Can create misleading expectations if users think the system is further along than it
actually is.
4. Horizontal vs. Vertical Prototyping
• Horizontal Prototyping: Focuses on a broad range of functions, but with
minimal depth or detail in any particular area. This is useful for testing the
overall structure and navigation.
• Vertical Prototyping: Focuses on a narrow set of functions but goes deep into
the details. This is useful for testing specific interactions or features in detail.
• Example: A horizontal prototype might include every screen in a mobile app
but with only placeholder content, while a vertical prototype might include just
the login screen but with full functionality, error checking, and UI animations.
5. Rapid Prototyping
• Description: This technique involves quickly creating prototypes to test concepts
early and often. Rapid iterations help teams adjust designs based on user
feedback in short cycles. It can combine both low and high-fidelity techniques.
• Example: Building multiple versions of a login screen and testing them with
users in a day. Each iteration incorporates feedback from the previous version.
• Benefits:
• Helps in quickly validating ideas.
• Encourages constant feedback and improvement.
• Drawbacks:
• May result in superficial exploration if not managed carefully.
Design space analysis
• Design Space Analysis (DSA) in Human-Computer Interaction (HCI)
is a structured approach to explore and evaluate various design options
by identifying and comparing the choices available during the design
process.
• It helps designers systematically consider the impact of different design
decisions on the user experience, technology constraints, and
interaction paradigms.
Components of Design Space Analysis:
1. Dimensions: These are key factors or aspects of the design space that need consideration. They
represent the variables along which design choices can be made (e.g., input methods, feedback
mechanisms, user tasks, etc.).
• Example: Designing a Mobile Health Application
Step 1: Identify the Key Dimensions
• Input Method: How will users interact with the app? Choices: Touchscreen, Voice Input, Wearable
Integration (e.g., fitness tracker).
• Data Presentation: How will the app present health data? Choices: Graphs, Lists, Notifications.
• Feedback Mechanism: How will the app provide feedback to users? Choices: Text notifications,
Audio alerts, Haptic feedback (vibrations).
• User Motivation: How will the app keep users motivated to stay healthy? Choices: Goal setting,
Social sharing, Gamification (badges, rewards).
Components of Design Space Analysis:
2. Choices: For each dimension, there are multiple possible design options. Each choice represents
a potential solution for that dimension.
Step 2: Explore the Choices for Each Dimension
• Input Method:
• Touchscreen: Easy to use for most users but can be challenging while exercising.
• Voice Input: Hands-free, but might not work well in noisy environments.
• Wearable Integration: Automatic data collection, but may require users to purchase
additional hardware.
• Data Presentation:
• Graphs: Visual and easy to understand trends over time, but may be overwhelming for some
users.
• Lists: Simple and clear, but may not highlight trends as effectively.
• Notifications: Immediate feedback but may distract users if too frequent.
Components of Design Space Analysis:
• Feedback Mechanism:
• Text notifications: Can be read at the user’s convenience but may not be urgent
enough.
• Audio alerts: Can quickly grab attention, but can be intrusive in public places.
• Haptic feedback: Subtle and effective during workouts, but might be ignored
during rest.
• User Motivation:
• Goal setting: Personalized and effective for users who like to track progress.
• Social sharing: Encourages users through community support but can create
pressure for some users.
• Gamification: Engages users by making health management fun, but not everyone
is motivated by rewards.
Components of Design Space Analysis:
3. Rationale: This refers to the reasoning behind selecting or rejecting certain choices. It
reflects the constraints, user needs, and trade-offs that influence decisions.
Step 3: Analyze the Rationale for Choices
• If the target users are primarily busy individuals, wearable integration might be
prioritized for automatic data collection, minimizing manual input.
• Graphs could be chosen for users who want a clear visual representation of their progress
over time, but simple lists might be offered as an alternative for users who prefer less
cluttered data.
• Haptic feedback could be favored for real-time exercise feedback, especially when users
are engaged in physical activity.
• For motivation, gamification could be implemented to engage users and keep the
experience enjoyable, while also offering goal-setting for users who prefer a structured
approach to health tracking.
• Design Space Analysis helps ensure that various design possibilities are
explored systematically. By clearly defining the dimensions, choices,
and rationale, designers can make informed decisions and create more
effective, user-friendly designs.