05-899D: Human Aspects of Software Development (HASD)
Note: Be sure to sign up for the “D” section—different courses are using the same
course number.
(HCII
page for this course.)
New course!
12 units, Spring, 2011.
Times: Tuesdays and Thursdays
from 12noon to 1:20 p.m. in NSH 3002.
(Note: if you want to take this course, but have a conflict with the time, let
me know.)
Overview
This course
will investigate the research on the human aspects of software development. The
focus will primarily be on individual software development, such as what is
known about people programming, debugging, testing, and understanding code. We will cover studies of programmers, and tools that have been shown to be
effective for programmers. This will include what is sometimes called "Empirical
Studies of Programmers" and the "Psychology of Programmers". Topics
that are associated with Human Aspects of
Software Engineering, such as the study of processes for management, studies of
large groups of programmers, and software specifications, will only be covered
lightly.
This will be
a seminar course, primarily intended for PhD students and other students
interested in research on this topic. The course readings will mostly be
important research articles on the various topics. We will also draw from the
book: Making Software: What Really Works, and Why We Believe It, edited
by Andy Oram and Greg Wilson (2011). Most of the
classes will be led by the students. Each student will choose two
topics, and will read the relevant literature and present the material to the
rest of the class. Grading will be based on students' presentations, participation
in class, and three projects. The projects will be performed in small
groups, and will entail a field study of some aspect of
software development, the creation of a new tool for developers (such as a
new plugin for Eclipse), and a lab comparison study of the tool. (See the
complete homework description below.) The projects may result in publishable papers.
Readings and Detailed Topics
Maintained on a
shared GoogleDoc.
Class and Lecture Schedule (evolving)
Homeworks and Grading
Each student in the course will be responsible for presenting lectures on two (2) topics.
The topics will be divided up and a schedule made up near the beginning of the
course. Presenting each topic will involve: reading the material the instructors
have selected, augmenting it with any additional material you think is relevant,
selecting one or two articles that best represent the topic that the rest of the
class should read (this must be one 1 week before your topic is presented),
preparing an 80-minute presentation including slides that synthesizes the
material, compare and contrast the studies/systems, if the topic includes
studies and systems then discuss the relationships, and in general, summarizes the entire
area, including summarizing all of the important papers, and leading the
in-class discussion on that topic. See the
in-class evaluation form.
For the other homeworks, the students will form groups of two or three people.
Each group will be responsible for three (3) projects, plus a planning document. All members of the group
should work on all projects:
- Select groups and propose three projects: Due: Tuesday,
February 1, 2011
This will be a short document listing the
group members, and discussing the initial idea about the three projects that your group will
do,
as described below. This report should also include a survey of related work
about what is already known about this area. This document should include
your initial plans for the field study, the tool and the lab study. We
expect that about 5 pages single spaced should be sufficient for this
document. The instructors will use this to make sure that all groups are
doing different topics, and that the topics seem reasonable.
- Study of Existing Practice: Due: Thursday, February 24, 2011,
extended: Friday, March 4, 2011
This will be a study of how programmers perform some existing practice, or
some existing problem that programmers have. There are at least four kinds
of exploratory studies to choose from: (1) Field study, like a Contextual
Inquiry, (2) Survey of a group of people, (3) Artifact study of existing
corpuses, or (4) exploratory lab study, where you instruct participants on
what to do. Our preference is for you to do a Contextual Inquiry or some
other kind of field study, possibly augmented by a survey, but will consider
the other options. The target audience can be novice, end-user or professional programmers. Deliverables will be a written report and an
in-class presentation (including slides) about the results.
- Prototype of a New Tool: Due: Tuesday,
April 5, 2011
This will be a new tool or language for
example an Eclipse plug-in or a stand-alone tool, that aims to help with
some aspect of programming. It might address the problem investigated in
your study. Deliverables will be the working prototype, a video of your
demonstration of it working, a short written report describing the system
and any interesting features, and an in-class presentation of the results.
- Lab study comparing two versions: Due: Thursday, April 28,
2011
This will be a lab study comparing (at least) two
versions, or two different systems. For example, you might compare your tool
or language against the way that programmers work today. Deliverables will
be a final report discussing the study (if all projects are about the same
system, you can write the final report like a submitted paper, including all
previous material in one comprehensive report), and an in-class presentation
of the results.
Grading
The grading will be allocated approximately as follows:
In-class Lecture 1 (eval
form) |
15% |
In-class Lecture 2 |
15% |
Planning document |
10% |
Study of Existing Practice |
20% |
Prototype |
20% |
Lab study |
15% |
In-class participation |
5% |
Total |
100% |
Topic Summary
The specific
topics covered will be developed in collaboration with the students in the
class, based on mutual interest. See the final list. A preliminary list of topics includes:
- HCI techniques relevant to studying software development (contextual
inquiries, field studies, surveys, lab studies, etc.)
- Studies of novice programmers
(barriers, performance, etc.)
- Studies of professional programmers
(programmer variability, cultural differences, actual practices, questions asked)
- Studies of the usability of APIs
- Studies of processes for programming (Agile, Peer, collaboration,
test-driven development, etc.)
- Tools for novice programmers
- Tools for making it easier to understand code (Visualization, analyses,
etc.)
- Tools for making it easier to write programs
(IDEs, etc.)
- Programming Languages and Environments that have good usability properties
- Tools for making it easier to debug programs
- Tools focused on "end-user" development of code (for people who are not
professional programmers)
- End-User Software Engineering (EUSE)
- Tools for making it easier to capture and use Design Rationale
- Documentation tools for making it easier to understand APIs