UPA Home Link
 UPA Conference 2005

Full Day Tutorial:
T-16 - Agile User Centered Design: Practicing UCD on Agile Projects

Title: T-16 - Agile User Centered Design: Practicing UCD on Agile Projects
Curricula: Methods & Skills
Audience: Everyone
Presenter(s): Jeff Patton, Thyra Rauch
  • Tuesday, June 28, 2005 -- 8:30AM - 5:00PM
As Agile Development approaches continue to increase in popularity, more usability professionals find themselves struggling to adapt to its fast pace, short development cycles, and small incremental releases. In this tutorial you’ll learn through participation how to perform user-centered design quickly, collaboratively, in harmony with, and complimentary to an agile development lifecycle.

PARTICIPANT KNOWLEDGE AND EXPERIENCE EXPECTED

Participants should have practical knowledge of the complete software development process. Participants should have some general knowledge of interaction design. Some knowledge of agile methods is a plus, but not necessary. This tutorial would be appropriate for both usability professionals and developers alike.

Interaction design concepts will have value to software managers and to user interface designers. Project managers, product managers, and team leaders will find value in understanding the forces which interaction design places on projects priorities. Testers can learn how to use user roles and their goals to write effective test cases. Anyone involved in software development will find value in the techniques described and practiced.

GOALS FOR THE SESSION:

Participants in this tutorial will learn:

  • An overview of Usage-Centered Design
  • 3x5 card sorting techniques
  • Agile modeling techniques for role and task modeling
  • How to define features for use in agile software development projects
  • How to create an iterative development plan using features
  • Agile software development basics
  • How to fit User Centered Design approaches into an agile process

Throughout the tutorial, participants will be encouraged to ask questions, discuss their own methods, and exchange experiences with other participants and the instructors.

PREVIOUS PUBLICATION OR USE OF THIS MATERIAL

The instructors, independently, have presented pieces of this information previously in different formats at UPA, ForUse, OOPSLA, Agile Software Development Conference, and XP/Agile Universe. This will be the first time all presenters have combined their knowledge and experience into one tutorial. Experience and case studies from all will be incorporated into the tutorial.

YOUR BACKGROUND IN THIS MATERIAL

One of the instructors has worked as a software designer and developer for the past 8 years, the past 4 years of which has been spent focusing on agile software development. Concurrently, this instructor has placed special attention on driving agile projects using interaction design sensibilities, resulting in an approach that is a pragmatic blend of agile techniques with proven interaction design techniques.

The other instructor has worked as a usability professional and interaction designer for the past 18 years, always with a strong focus on the users and their tasks in the environment they will be performing them. This instructor has been working for the past year in an agile environment, refining how to make UCD methods more agile to better fit into the changing development process.

HOW WILL THIS TUTORIAL BE CONDUCTED

Alistair Cockburn describes the use of a “process miniature” as an approach to allow people to quickly learn a large and somewhat complex process. Participants of this tutorial will be engaged in a process miniature. They will play the role of a design team tasked with creating a general design for a piece of software, justification for that design, and a development plan that reasonably allows them to complete construction of the software in the constrained time frame allowed. Then, the design team becomes the development team to build the first incremental release of the software as a paper prototype that will be tested for usability each iteration.

Nearly 50% of participant's time will be spent engaged in hands-on activities, 20% in discussion of models and other work-products with the instructor and other workshop participants, and 30% listening to presentation to help them participate effectively in activities and apply the techniques learned to real-world design and development projects.

Activities will primarily use card-sorting and arranging techniques for brainstorming, prioritization, and model construction and paper prototyping techniques for software prototype construction.

TUTORIAL SCHEDULE WITH TIME ALLOCATION

Number of Minutes Topic or Event
15 minutes
8:30 – 8:45
Introduction
Introduce instructors, participants, and schedule
30 minutes
8:45 – 9:15
1. Hit the Ground Running: the Design Problem
Introduce design problem and discuss as a group. Set up room for collaborative design session. Participants break into design teams.
45 minutes
9:15 – 10: 00
2. Who Cares?: User Roles and Role Modelingv Introduce the concept of the user role and understand what it means relative to job titles or actors. Introduce card-sorting techniques for brainstorming and prioritization. Introduce card based modeling techniques for user role modeling. An exercise for practicing the techniques is included.
30 minutes
10:00 – 10:30
Break
30 minutes
10:30 – 11:00
3. What Will The Software Do?: Tasks and Interaction Contexts
Introduce the U-CD task and the development feature, understand them relative to XP's story or other definitions for feature such as FDD's feature. Introduce the U-CD interaction context then cluster user tasks into interaction contexts and build a context navigation model.
40 minutes
11:00 – 11:40
4. Agile Software Development and Interaction Design Overview
Define terms and establish a motivation for using User Centered Design and collaborative modeling techniques on your agile project.
20 minutes
11:40 – 12:00
5. Software Simulation Using Paper Prototyping
Discuss paper prototyping basics. Discuss using paper prototypes and Wizard-of-Oz style testing to simulate live software.
90 minutes
12:00 – 1:30
Lunch
45 minutes
1:30 – 2:15
6. Incremental Release Planning
Understand the concept of units of work in agile development such as stories or features. Introduce the concept of incremental delivery and the “system span.” Incorporate these concepts to build a feature-centric release plan using 3 x 5 card sorting. An exercise for practicing this technique is included.
25 minutes
2:15 – 2:40
7. Building the First Release, Iteration #1
Build the first release of our software in two short iterations. This is iteration #1. Includes an exercise to build the iteration.
20 minutes
2:40 – 3:00
8. Building the First Release, Testing iteration #1.
Understand testing in agile development. Test the product release for functional completeness and usability. An exercise to test the iteration is included.
30 minutes
3:00 – 3:30
Break
25 minutes
3:30 – 3:55
9. Building the First Release, Iteration #2
Build the first release of our software in two short iterations. This is iteration #2. An exercise to build the iteration is included.
20 minutes
3:55 – 4:15
10. Building the First Release, Testing iteration #2.
Test the product release for functional completeness and usability. An exercise to test the iteration is included.
45 minutes
4:15 – 5:00
11. Agile UCD Wrap-up
Discuss common challenges and strategies for incorporating UCD approaches into agile software development environments.

DETAILED DESCRIPTION OF TUTORIAL

Abstract:

As Agile Development approaches continue to increase in popularity, more usability professionals find themselves struggling to adapt to its fast pace, short development cycles, and small incremental releases. In this tutorial you’ll learn through participation how to perform user-centered design quickly, collaboratively, in harmony with, and complimentary to an agile development lifecycle.

Full Description:

Focal to most agile development approaches is the notion that development work done is described in terms of its understandable value to the users of the software. Yet, there’s little written in documented agile methods on exactly how to discover and understand these users and the features they need to achieve value. Even when actual users are placed in the role of an agile customer it generally takes them quite a while to diagnose their own problems and invent techniques for articulating their needs to the development team.

On the other hand standard UCD methodologies, while emphasizing the user and designing for them throughout the process, fail to handle the rapid schedules and incremental release cycles that an agile approach imposes. In general, the key to usability professionals successfully working with development has been first, don’t make them break the schedule, and second, try to help the product succeed.

In general terms, the usability philosophy and agile development are compatible. Both emphasize frequent interactions with users and validation of what has been produced. Both place a premium on testing the solution early and frequently. The trick is how to get just enough of the up-front information, quickly, to be able to move forth in an agile environment.

Agile programming methods challenge usability professionals to adapt from an extensive front-end-loaded approach to an integrated, iterative approach.

This tutorial acquaints participants with Constantine and Lockwood’s Usage-Centered Design as a User Centered Design approach and demonstrates its place in an agile development approach. As a participant, you will be working hands-on in a collaborative design team, working on a real design problem to produce models for user roles, tasks, and interaction contexts using 3 x 5 cards, poster paper, discussion, and creativity. You will use the problem-understanding these models give you, and more 3 x 5 cards, to develop an incremental release plan. Using paper prototyping to build and simulate usage of your software, you’ll then construct the first release of your software in an agile iterative development cycle.

1. Hit the Ground Running: the Design Problem: 30 minutes
Goal: Set up for a collaborative scoping session. Introduce a real world design problem to discuss during this tutorial.

Topics Include:

  • Collaborative Design Meeting Participants
  • Meeting Setup
  • Feed-Forward Bins
  • Preconception Purge
  • Domain Discussion

2. Who Cares?: User Roles and Role Modeling: 1 hour
Goal: Introduce the concept of the user role and understand what it means relative to job titles or actors. Introduce card-sorting techniques for brainstorming and prioritization. Introduce card based modeling techniques for user role modeling. Compare/contrast this model to user profiles, personas, etc. Emphasize that this is just one more model for the “toolbox.” Participants will take part in an exercise on user roles and role modeling.

Topics Include:

  • Role Definition
  • Card-Based Role Brain-Storming
  • Card Based Role Modeling and Model Markup

3. What Will The Software Do?: Tasks and Interaction Contexts: 30 minutes
Goal: Introduce the U-CD task and the development feature, and understand them relative to XP's story or other definitions for feature such as FDD's feature. Introduce the U-CD interaction context, then cluster user tasks into interaction contexts and build a context navigation model. Emphasize that this is one of several possible methods of gathering and representing the state of the user’s world. Contrast this to the “standard” UCD concept of “task.”

Topics Include:

  • U-CD Tasks & Task Modeling
  • U-CD Interaction Contexts & Context Modeling

4. Agile Software Development and User Centered Design Overview: 40 minutes
Goal: Give short overview of Agile software development. Discuss how agile development and UCD can mesh. Discuss the role of the user and how to involve the user in this process. Give short overview of U-CD. Define terms and establish a motivation for using User Centered Design and collaborative modeling techniques on your agile project. Discuss team member roles on an agile development team.

Topics Include:

  • Agile Principles & Agile Development Methodologies
  • User Centered Design & Usage-Centered Design
  • Collaborative Agile Modeling Techniques
  • Team roles on an Agile team

5. Software Simulation Using Paper Prototyping: 20 minutes
Goal: Discuss paper prototyping basics. Discuss using paper prototypes and Wizard-of-Oz style testing to simulate live software.

Topics Include:

  • Paper prototyping
  • Usability testing using a paper prototype

6. Incremental Release Planning: 45 minutes
Goal: Understand the concept of units of work in agile development such as stories or features. Introduce the concept of incremental delivery and the “system span.” Incorporate these concepts to build a feature-centric release plan using 3 x 5 card sorting. Participants will take part in an exercise on incremental release planning.

Topics Include:

  • Feature definition
  • Incremental release planning and the system span
  • Scenario writing from the span plan

7. Building the First Release, Iteration #1: 25 minutes
Goal: Build the first release of our software in two short iterations. Participants will take part in an exercise to build iteration #1.

Topics Include:

  • Iterative development

8. Building the First Release, Testing #1: 20 minutes
Goal: Test the product release for functional completeness and usability. Participants will take part in an exercise to test iteration #1.

Topics Include:

  • Acceptance Testing

9. Building the First Release, Iteration #2: 25 minutes
Goal: Build the first release of our software in two short iterations. This will be iteration 2.

Topics Include:

  • Iterative development

10. Building the First Release, Testing #2: 20 minutes
Goal: Test the product release for functional completeness and usability. This will be the second iteration testing.

Topics Include:

  • Acceptance Testing

11. Agile UCD Wrap-up: 45 minutes
Goal: Discuss common challenges and strategies for incorporating UCD approaches into agile software development environments.

  • Using UCD throughout the development cycle
  • Combining UCD techniques with existing software development techniques
  • Alter UCD techniques to increase collaboration and shorten duration
  • Exchange and compare ideas with other participants.
"" ""