Human Factors in Computer and Information Systems
Spring2002 - Professor Ben Shneiderman
1. Prepare your web pages and zip files. You should prepare:
One html page that contains everything you may have in your project report. The Web page should be named exactly report.html (all in lower case). Please refer to http://www.cs.umd.edu/class/spring2002/cmsc434-0101/project.html, section "Format for Interface Design Reports" for the writing style and formatting. You can use MS Word to edit your report, and save it as a html file.
One zip file that contains the PowerPoint slides that you use in the presentation. The zip file should be named exactly presentation.zip (all in lower case).
One zip file that contains everything you may have for the implementation, such as the source code and data. In a word, everything that you need to submit but does not go to report.html or presentation.zip should be included in this archive. The zip file should be named exactly implementation.zip (all in lower case).
2. Transfer your files to the directory
Login to the CS junkfood system, transfer all your files to the directory /fs/www/class/spring2002/cmsc434-0101/report/[your directory]. [your directory] is the sub-directory name we assign to your group. Please see http://www.cs.umd.edu/class/spring2002/cmsc434-0101/report/termPrjGroups.html for the sub-directory name that is assigned to your group.
3. Test if your files are ready to be accessed.
Go to http://www.cs.umd.edu/class/spring2002/cmsc434-0101/report/termPrjGroups.html, click the three links to the right of your group. If it reports any error, check if the files are in the correct directory, if your file names are correct, and if you have assigned the correct access permission to your files. Use “chmod 744 [filename]” to enable the access to your files.
Title page: Title, Authors, Electronic Mail Addresses, and Date
Abstract: 100-150 word overview of project
Credits: Indicate who did what
1. Introduction (3-6 single spaced pages)
Overview of the problem,
Discussion of previous work including (with references at the end):
- commercial systems
- previous academic papers
- relevant web sites
2. Presentation of design (10-25 pages)
Give overview of your approach and solution
Show transition diagram for screens in your design
Present all screens you have designed with commentaries to explain
(do screen grabs or scans of your prototype images)
Present your tutorial/help
3. Report on development process (10-20 pages)
Show a few of your low-fidelity prototype screens
Describe your process for arriving at the high fidelity prototype
Describe your usability testing process (subjects, tasks, results)
4. Conclusions (1-4 pages)
Describe the final status (what was implemented)
Future work possibilities (what needs to be done to complete & refine)
Recommendations to future developers of your idea
Acknowledgements (a few sentences)
Thanks to teachers, bosses, organizations, or friends who helped you
References (5-20 references): in a neat standard format, alphabetical by last
name of first author.
(Editing Guidelines: Use Times Roman New font 12 point for text throughout, bold
for section titles. On title page use 14 point bold for the title (capitalize
first letter of each word), the rest in 12 point not bold, all left justified.
In body of paper, use single spacing, skip two lines before and one after each
section title. Number each figure and give it a caption. Cite references by
authors and date, for example, (Jones and Berge, 1997) or (Microsoft, 2001) )
Duration : 8 minutes
Questions: 2 minutes
Slide 1) Title with names of group members
Slide 2) Describe requirements and intended users
Show the prototype if possible, or show slides of screen prints
Slide 3) Describe usability test (subjects, tasks, results)
Slide 4) Conclusions & future work
Note: You can use more slides if you wish.
Additional Suggestion: Please rehearse your talk.
Monday May 6:
Museum of User Interfaces (MUIseum)
Wednesday May 8: Campus systems
ICARUS - Interactive Computer Science Academic and Recreational Utility Screen
Games for CSIC foyer
Artistically Representing Terps (ART)
Information and Map System
Monday May 13: Consumer systems
The Restaurant Interface (for restaurant workers)
Sit Down to Eat! (for restaurant patrons)
IdentiCam (identifying camera)
CUPID- WILD Word - Word's Interactive Leveled Design
This project is a hands-on experience in iterative user-centered system design. You begin your design by getting to know the intended users, their tasks, and the working context of their actions. Only then do you consider what the actual system design should look like, basing your design on real people, tasks, and needs. User centered system design is not an academic process where some cookbook formula can be applied. Nor is it an intuitive process where programmers can sit in their offices and think they know what the user and their tasks are. Rather, it is a hands-on process that requires you to go out and identify actual users, talk to them about what tasks they are trying to do, and understand their work context. Because your initial designs will be crude and problem-prone, you will have to identify potential usability problems by evaluating your design and by crafting new ones. This is called iterative design.
In this project, you begin using task-centered system design methods and low fidelity prototyping methods:
The outcome of this project is a design portfolio containing:
Section 1: User needs: Tasks and requirements (~4-10 pages)
Section 2: References (~2-4 pages)
Section 3: First design (low fidelity prototypes + description or tutorial ~6-12 pages)
Section 4: Task list and questionnaires (~2-3 pages)
Section 5: Usability test report (high fidelity prototype + test ~6-12 pages)
Section 6: Final project (revised protoype + history ~15-25 pages)
Your company is looking to design, build, and market new software systems, such as:
Your group will deliver a system design and discussion portfolio written to the vice-president of your company. The portfolio is intended to document the progression of your design. Your portfolio must be neat, well-organized, and visually appealing. Portfolios should be constructed out of a 1" or smaller 3-ring binder (I will not appreciate having to carry around larger binders) with titled section separators to separate the 6 sections. The cover of the portfolio should include the names of the group members and the project title. Grading will be based upon the sophistication and maturity of the work, the elegance of the designs, the logic of the presentations, and completeness.
Section 1: User needs: Tasks and requirements (~4-10 pages) (Due February 27)
Introduction. Describe in general terms the background to the system. You should describe the expected users, their work contexts, and what they will use the envisaged system for.
Concrete task examples. List at least 5-7 concrete task examples that have the properties listed in Appendix 2. Try to keep task descriptions short and to the point. Each task should be accompanied by the class of the expected user (a typical customer) and the relative importance of the task (frequently done and important, infrequently done but still important).
System requirements. From the task examples, extract the major system requirements (hardware, software, networking, content) and prioritize them into a) absolutely must include; b) should include; and c) could include.
Section 2: References (~2-4 pages) (Due March 6)
Provide annotated (1-3 sentences) references to academic papers, industrial reports, and web pages on your topic. Compare your work to existing products.
Section 3: First design (low fidelity prototypes + description or tutorial ~6-12 pages) (Due March 13)
Develop at least two very different low-fidelity prototypes that you believe will satisfy the major requirements. Discuss the prototypes with your team and (ideally) potential users. The more different you are from the target users, the more important it is for representative users to give you feedback on your design. For the prototype design that seems promising, use the tasks from Section 1 to perform a task-centered walkthrough with potential users. List the problems and successes for each task. Summarize the major design problems that must be corrected, as well as what seems to work well.
Section 4: Task list and questionnaires (~2-3 pages) (Due March 20)
Prepare the tasks for your the usability test. Prepare the pre-test and post-test.
Section 5: Usability test report (high-fidelity prototype + test ~6-12 pages) (Due April 10)
Create your high-fidelity prototype. Describe the usability test, subjects, and how it went. Itemize the problems you identified and give them 1-5 points in terms of importance (5 is most important) and effort (5 is most time consuming).
Section 6: Final project (revised prototype + history ~15-25 pages) (Due May 1)
Revise your final design. Present the revised prototype, commentaries, and as complete a working system as you have implemented. All to be posted on the web page for your project.
Step 1. Generating a list of expected users, and an initial list of tasks. Interview knowledgeable people about their real-world tasks and observe them doing their tasks. Your goal is to generate an initial list of concrete task descriptions. You may or may not be able to access your real clients in the short time available for this exercise. Consequently, each team should select the approach below that best fits their constraints and team membership.
For whatever approach you chose, do the following steps. If you have a client and/or representative, you would do it with them. If you are "making it up", try to imagine as realistic a situation as possible.
At this point, you will have a set of concrete, detailed examples of tasks that people now perform, or would want to perform on your system. Each task description should have the attributes described in the appendix and the second reading (see attached).
Step 2. Validating the tasks. The next step is to get a reality check of your task list. Have end-users and/or client representatives review your tasks. They should check to see if the set of people are representative of potential end-users of your product, if tasks capture the variations of those done by real people, and if details are realistic (they will be, if they are based on real customers!). You should ask for details that were left out of the original task description, get corrections, clarifications, and suggestions, and then re-write the task descriptions.
Note: This step is critical if you used a client representative or just yourselves instead of a real client. While it may not be possible for you to interview and observe many real clients, you can probably get one to comment on a compiled list of prototypical tasks.
Step 3. Deciding upon key users and a tentative list of requirements. The task examples will provide clues on specific system requirements that you could use to design your system as well as who your target users will be. Because it is unrealistic to meet all requirements and address all users, it is your job to prioritize them. From the task examples (and possibly by further discussion with end users), decide upon the major system requirements and prioritize them into a) absolutely must include; b) should include; and c) could include. Similarly, decide upon what kind of users you must address, up to those you will exclude.
Step 4. Develop low fidelity prototypes. From the task examples and requirements, your team should sketch out several competing interfaces. Discuss and choose the most promising of these, and develop a low-fidelity prototype (using storyboards) that demonstrates how the interface fulfills the requirements.
Specifically, use the key users, their tasks, and the prioritized requirements as a type of requirements document to help you brainstorm prototypes that illustrate how your system would appear to the customer. You should be creating low fidelity prototypes e.g., paper sketches, storyboards, cut-and-paste mockups. You should not be concentrating on prettiness or completeness; rather, you are trying to show the overall interaction style of your system. Each prototype should contain the core screens that illustrate how the system will work as a whole, including (perhaps) a sample interaction based upon some of the key tasks.
Hint: To get diversity, each group member may want to try to create a few rough sketches before gathering as a group. You should also realize that some people may be better at this than others; this is not supposed to be a competition!
Step 5. Task-centered walkthrough. Test the prototype for usability bugs (problems, faults, weaknesses) by performing a task-centered walkthrough, as described in Appendix 1 and the readings.
Read: Lewis, C. and Rieman, J. (1993) Task Centered
User Interface Design http://www.hcibib.org/tcuid/
Chapter 2: Getting to know users and their tasks is the source for the exercise and for the following notes.
Good task examples:
Example task description for a clerk in a video store, including discussion. The eventual system will assist the clerks to perform their tasks.
Mary Farness, an experienced full-time clerk at the video store, opens the store in the morning. She begins the day by checking in all the videos returned in the night video slot, which typically number between 90 to 150 videos. She pauses her task whenever customers ask for her services. She usually checks in ten videos, and then reshelves them before going onto the next ten.
Discussion. In this case, the "user" is the full time person who normally carries out this task. We expect them to be typical of an experienced clerk who will know the process well, and who will become well practiced at using the target system. The task is routine and frequently done.
George Marlay, a regular video store customer, approaches Mary and asks if they have the Frankenstein comedy video. She asks if he mean "Young Frankenstein" by Mel Brooks, and he say yes. She then directs him to the shelf where the video is expected to be. George retrieves the video card and brings it to the front desk. Mary asks for George's membership card, but George has forgotten it. Mary then looks up his membership number. Mary checks out the video, but reminds George that he has not yet returned the video "Brazil", which is now a day late. George says that he will bring it in later today, and leaves with the video.
Discussion. This task contains many typical clerk activities, which deals with vague requests about video titles, the location of the video in the store, forgotten membership cards, the video checkout activity, as well as reminders to customers about late videos. Most these tasks are frequently done, and important.
Anil, a part time clerk who works the telephone, comes in for an hour every third evening. His job is to search the rental records to find customers who are at least one day late on their video returns. For example, he phones Bob Jakobs, who is two days late. Bob answers, and Anil identifies himself, tells him that he still has the video "Volcano", and reminds him to return the video. Bob says he will bring it back in an hour or so, and Anil crosses his name off the list. He then phones Ania Sliven, and says (more or less) the same thing. However, Ania says that she has already returned the video the day before. Anil puts her on hold, runs to check the shelf and finds the video there. He apologizes and hangs up. He then phones Ang Lee, but there is no answer. He notes on another list that he should try this person again later. He continues in this manner. When he has finished the list, he starts again on those who have not answered.
Discussion. This task identifies a specific activity that is less frequently done but still quite important. It also indicates that a non-regular staff member may be doing this task.
Why these are good examples:
Read: Rettig, M. (1994) Prototyping for tiny fingers . Communications of the ACM, 37(4).
Logical User Centered Interaction Design (LUCID)
Use the key users, tasks, and system requirements generated previously as a type of requirements document to help you brainstorm prototypes that illustrate how your system would appear to the customer. You should be creating several low fidelity prototypes e.g., paper sketches, storyboards, or physical mockups. You should also be thinking about what conceptual model the system will portray to its customers. You should not be concentrating on prettiness or completeness; rather, you are trying to show the overall representation and interaction style of your system. Each prototype should contain the core screens that illustrate how the system will work as a whole, including (perhaps) a sample interaction based upon some of the key tasks.
You should use the ideas of "psychology of everyday things" and "beyond screen design" to help you, as well as your general knowledge of other systems (there is nothing wrong with copying ideas, providing its legal!).
Hints: To get diversity, each of you may want to try to create a few rough sketches before gathering as a group. You may also want to talk to the systems people in your group, because there may be opportunities that already exist with the current way the information is stored and presented (e.g., if customers are already using software), or constraints that limit what you can do (e.g., if the system must be delivered as a Windows 95 application). You should also realize that some people may be better at this than others; this is not supposed to be a competition!
Your next step is to evaluate the prototypes.
Based on the prototype and evaluation exercise, you may wish to reconsider what customers you will address as well as what tasks and requirements you will support. It could be that you were wildly optimistic about what you could do!
At this point, you should have a reasonable idea of which prototype styles are worth pursuing, or whether you should start again. Make your decision on what direction(s) to follow. If you have more than one direction, you may want to continue developing both a bit further. If you have no worthy candidates, return to step 2.
Hint. Don't feel committed to any prototype. This is the time where prototypes are quick to generate and cheap to discard. Use this time to explore the design space. While you may want to just get on with it, a bad design choice now can have disastrous and expensive repercussions later.
Refine your prototype by considering the nuances of each task, the functions that must be incorporated, and the expected reaction of each user. You may want to start considering the more subtle aspects of interface design at this point (e.g., psychology of everyday things, principles of graphical screen design, design principles). You should be continually evaluating these prototypes as appropriate. Real users should be commenting on them. You should be using walk-throughs, heuristic evaluation, and various observational methods.
If you follow this process, your prototypes will evolve from a competing series of design ideas, to a crude single design representation, to more realistic looking screen designs, to functioning systems. As your design is refined, you will move from very low fidelity prototypes done on paper to medium fidelity prototypes done on-line, likely through an interface builder. You will have detected and corrected the major interface design problems, and will be concentrating on fine-grained details. Eventually, you will create vertical prototypes with back-ends that fake some of the system functionality. To the user, however, it will look like the real system.