CS 846 logo: Human Aspects of Software Engineering

Google doc is online

Software is a human product. Developers are intrinsic to software development; as systems scale in size and complexity, the challenges that developers must overcome rapidly increase. This course will examine why creating software is a hard problem and how these problems have been addressed and evaluated both in research and practice. We will focus on development-based activities (rather than planning or requirements-based activities). The course will be seminar-based and will involve weekly reading and discussion. The project component will be flexible but will likely involve some programming. This course is offered by the David R. Cheriton School of Computer Science at the University of Waterloo.

Lectures are held Thursday afternoons from 15:00 to 17:20 in DC 2568. My office hours are TBD but will be held in DC 3351. Official scheduling details can be found in the administrative entry.

Important dates and information will be posted to the course twitter feed.


The best way to get in touch with me is via email.

Nominal Outlinetop

The course will be adjusted according to your feedback, interests, and experience. This is an overview of the kinds of topics we could cover:
  • software evolution
  • program comprehension
  • software visualization
  • development team processes
  • software development tools and environments
  • quantitative & qualitative evaluation of software engineering research

Tentative Course Scheduletop

It is important to note that this schedule is very susceptible to change based on your interests and how the class is progressing.

Thursday September 11 - Introduction

Thursday September 20 - Historical Context

  1. Brooks. No Silver Bullet. Computer, vol.20, no.4, April 1987.
    Presented by Reid Holmes
  2. Gibbs. Software's Chronic Crisis. Scientific American, September 1994.
    Presented by Reid Holmes

Thursday September 27 - APIs and Bugs

  1. Cleidson R. Souza and David F. Redmiles. On The Roles of APIs in the Coordination of Collaborative Software Development.
    Presented by Daniel Kozimor
  2. Philip J. Guo, Thomas Zimmermann, Nachiappan Nagappan, Brendan Murphy. “Not My Bug!” and Other Reasons for Software Bug Report Reassignments
    Presented by Siddharth Subramanian

Thursday October 4 - Evaluation Strategies

  1. B. A. Kitchenham, S. L. Pfleeger, L. M. Pickard, et al. Preliminary guidelines for empirical research in software engineering..
    Presented by Dina Zayan
  2. Jorge Aranda, Gina Venolia. The secret life of bugs: Going past the errors and omissions in software repositories.
    Presented by Quinn Hanam

Thursday October 11 - Behaviour

  1. Röthlisberger et al. Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks..
    Presented by Laura Inozemtseva
  2. Henry Lieberman, Christopher Fry. Bridging the gulf between code and behavior in programming.
    Presented by Chun (Luke) Liu

Thursday October 18 - Coordination

  1. Robert E. Kraut and Lynn A. Streeter. Coordination in software development..
    Presented by Jeff Avery
  2. Christopher Poile, Andrew Begel, Nachiappan Nagappan, and Lucas Layman. Coordination in Large-Scale Software Development: Helpful and Unhelpful Behaviors..
    Presented by Qiming (Alex) Hu

Thursday October 25 - Information Needs

  1. Ko, DeLine and Venolia. Information needs in collocated software development teams..
    Presented by Leila Chinaei
  2. Sergey Dmitriev. Language Oriented Programming: The Next Programming Paradigm..
    Presented by Paul Meyer

Thursday November 1 - Visualization

  1. Baecker, R., DiGiano, C., and Marcus, A. Software Visualization for Debugging..
    Presented by Alexandr Murashkin
  2. B.A. Price, R.M. Baecker, and I.S. Small. A Principled Taxonomy of Software Visualization..
    Presented by Yi Ren

Thursday November 8 - Assorted

  1. Bjorn Hartmann, Daniel MacDougall, Joel Brandt, Scott R. Klemmer. What Would Other Programmers Do? Suggesting Solutions to Error Messages..
    Presented by Yijia (Allen) Zhao
  2. Suresh Thummalapenta and Tao Xie. Parseweb: a programmer assistant for reusing open source code on the web..
    Presented by Yufeng (James) Shao
  3. Reid Holmes and Andrew Begel. Deep Intellisense: A Tool for Rehydrating Evaporated Information..
    Presented by Mohammed Alliheedi

Thursday November 15 - Tools

  1. Andrew Bragdon, et. al. Code Bubbles: Rethinking the User Interface Paradigm of Integrated Development Environments..
    Presented by (Syed) Ashar Ghani
  2. Margaret-Anne D. Storey, Jody Ryall, Janice Singer, Del Myers, Li-Te Cheng, Michael J. Muller. How Software Developers Use Tagging to Support Reminding and Refinding..
    Presented by Ed Zulkoski
  3. Collin McMillan, Mark Grechanik, Denys Poshyvanyk, Qing Xie, and Chen Fu. Portfolio: finding relevant functions and their usage..
    Presented by Steven She

Thursday November 22 - Refactoring

  1. Emerson Murphy-Hill, Chris Parnin, Andrew P. Black. How we refactor, and how we know it..
    Presented by Hassan Khan
  2. Zhenchang Xing, Eleni Stroulia. Refactoring practice: How it is and how it should be supported, an Eclipse case study..
    Presented by Roop Rahal
  3. M.P. Robillard; W. Coelho; G.C. Murphy. How effective developers investigate source code: an exploratory study..
    Presented by Ravi Chandra

Thursday November 29 - PC Meeting

Details to follow.

Course Formattop

This will be a paper-based seminar course. Each week we will read and discuss two papers. Everyone in the class will have an opportunity to give a 15-20 minute paper presentation (this comprises 30% of your mark) and lead the ensuing discussion. While only one person will present each paper, it is expected that everyone will read the papers to contribute to the discussion.

While reading the papers you should be able to answer the following five questions:

  1. What were the primary contributions of the paper as the author sees it?
  2. What were the main contributions of the paper as you (the reader) see it?
  3. How does this work move the research forward (or how does the work apply to you)?
  4. How could this research be extended?
  5. How could this research be applied in practice?
While presenters should keep these questions in mind, the audience in particular should think about them specifically while they are reading the paper.

You will get to select the paper you want to present from the course. This selection can be made from this list (NOTE: this list is subject to change!). Once you have selected a paper, enter the details in the following paper choice list. This must be done by September 20 @ 0800.

The project is the primary artifact of the course; the outcome of all projects will be a research paper. In the last week of the class we will formally review all the papers from the course projects (using standard program committee review forms) and have a PC meeting describing the strengths and weaknesses of each paper. The reviews you produce will comprise 20% of your final mark.

The course will conclude with a formal Program Committee (PC) meeting. All projects will be submitted via a EasyChair (a conference management system). Each paper will receive at least 8 reviews from class members (I will review every paper). These peer-reviews will comprise 20% of the final mark. Michael Ernst has compiled a series of informative links for creating effective reviews. Here are links to two different reviews as well (one positive and one negative) if you want concrete examples.

Remember, the reviews must all be submitted to Easychair by 1300 on Nov 29.


The project forms an integral part of this course. The projects can be completed in groups of up to three. The intent of the project is to identify some

Three types of projects are possible:

  1. Build a Software Tool:

    The goal of this style of project is to identify some problem developers encounter in practice, find some solution, and validate that the solution helps with the initial problem. I would recommend drawing upon your experience as you write code to identify some problem that has inhibited you in the past and fix it.

    The outcome of this project will be a short (5-6 page) paper describing the problem, your solution, a comparison to related approaches, and some form of validation.

  2. Literature Survey:

    The goal of this kind of project is to gain a more complete understanding of a topic relevant to this course. The outcome of this project will be a critical summary of the state-of-the-art on your selected topic; this summary should be 8-10 pages. It is essential that this summary synthesizes the surveyed literature to identify important themes, findings, and open questions.

  3. Use an Advanced Software Development Tool

    The goal of this project is to provide a validation of some previously-existing development tool from the research community. The tool you validate must be related to the course material. The outcome of this project will be a 6-8 page paper describing your experience with the tool outlining its strengths, weaknesses, and avenues for future improvement.

There are two deliverables regardless of the kind of project you choose:

  1. Project proposal. Before you undertake your project you will need to submit a proposal for approval. The proposal should be short (max 1 page PDF in ACM format). The proposal should include a problem statement, the motivation for the project, and set of objectives you aim to accomplish. I will read these and provide comments. The proposal is not for marks but _must_ be completed in order to pass the course. If you wish to 'pitch' to the class to find additional team mates, please indicate this at the bottom of the proposal. For the pitch you will get 1-2 minutes to describe the project to try to entice others to join your group. NOTE: even if you pitch, you are still free to abandon your project and join a different one.
    This will be due on September 26 @ 0800 via email.
  2. Written report. The required length of the written report varies from project to project; all reports must be formatted according to the ACM format and submitted as a PDF. This artifact will constitute 100% of the project grade.
    This will be due on November 22 @ 0800 via Easychair.
  3. Project presentation. This is optional.
    Each group will have the opportunity to present their project in class on November 29, if they want to.
    This presentation should take the form of a 10 minute conference-style talk. There will be time for questions after the paper has been presented. The talk will not count for marks.

I have included a brief description of five of the projects from last year.

  • Answering developers’ questions using information fragments in a heterogeneous development environment In this project, the authors developed a novel approach to model online programming threads (e.g., Stack Overflow). This paper was extended subsequent to the course and was published in VLHCC 2012.
  • Semantic-Based Code Search Evaluation: An Exploratory Study By evaluating three different code search engines, the authors aimed to identify high-level strengths and weaknesses that could be used to suggest future improvements for hybrid code search approaches.
  • NavTracks: The Next Generation This paper evaluated the existing NavTracks tool to determine how the tool worked in practice and to suggest future avenues for research in this space.
  • File Recommendation Based on File Interactions: A Clustering Approach to File RecommendationsA new approach for leveraging code navigation paths (in a similar manner to NavTracks) was developed and the quality of the recommended artifacts evaluated.
  • Evaluation of Canada Health Infowayʼs Message Builder API and its documentation The authors evaluated the Infoway API and documentation to gain insight into the ease-of-use of this API by end-user developers.


Paper presentation: 30%

Project: 50%
Due Nov 22 @ 0800

Paper reviews: 20%
Due Nov 29 @ 1300


Academic Integrity

  • In order to maintain a culture of academic integrity, members of the University of Waterloo community are expected to promote honesty, trust, fairness, respect and responsibility. [See the academic integrity site for more information.]


  • A student who believes that a decision affecting some aspect of his/her university life has been unfair or unreasonable may have grounds for initiating a grievance. Read Policy 70, Student Petitions and Grievances, Section 4.
  • When in doubt please be certain to contact the department’s administrative assistant who will provide further assistance.


  • A student is expected to know what constitutes academic integrity to avoid committing an academic offence, and to take responsibility for his/her actions.
  • A student who is unsure whether an action constitutes an offence, or who needs help in learning how to avoid offences (e.g., plagiarism, cheating) or about “rules” for group work/collaboration should seek guidance from the course instructor, academic advisor, or the undergraduate Associate Dean.
  • For information on categories of offences and types of penalties, students should refer to Policy 71, Student Discipline.
  • For typical penalties check Guidelines for the Assessment of Penalties.


  • A decision made or penalty imposed under Policy 70 (Student Petitions and Grievances) (other than a petition) or Policy 71 (Student Discipline) may be appealed if there is a ground.
  • A student who believes he/she has a ground for an appeal should refer to Policy 72 (Student Appeals).