Despite significant existing empirical work, little is known about the specific kinds of questions programmers ask when evolving a code base. Understanding precisely what information a programmer needs about the code base as they work is key to determining how to better support the activity of programming. The goal of this research is to provide an empirical foundation for tool design based on an exploration of what programmers need to understand about a code base and of how they use tools to discover that information. To this end, we undertook two qualitative studies of programmers performing change tasks to medium to large sized programs. One study involved newcomers working on assigned change tasks to a mediumsized code base. The other study involved industrial programmers working on their own change tasks to code with which they had experience. The focus of our analysis has been on what information a programmer needs to know about a code base while performing a change task and also on how they go about discovering that information. Based on a systematic analysis of the data from these user studies as well as an analysis of the support that current programming tools provide for these activities, this research makes four key contributions: (1) a catalog of 44 types of questions programmers ask, (2) a categorization of those questions into four categories based on the kind and scope of information needed to answer a question, (3) a description of important context for the process of answering questions, and (4) a description of support that is missing from current programming tools.

Debugging is notoriously difficult and extremely time consuming. Researchers have therefore invested a considerable amount of effort in developing automated techniques and tools for supporting various debugging tasks. Although potentially useful, most of these techniques have yet to demonstrate their practical effectiveness. One common limitation of existing approaches, for instance, is their reliance on a set of strong assumptions on how developers behave when debugging (e.g., the fact that examining a faulty statement in isolation is enough for a developer to understand and fix the corresponding bug). In more general terms, most existing techniques just focus on selecting subsets of potentially faulty statements and ranking them according to some criterion. By doing so, they ignore the fact that understanding the root cause of a failure typically involves complex activities, such as navigating program dependencies and rerunning the program with different inputs. The overall goal of this research is to investigate how developers use and benefit from automated debugging tools through a set of human studies. As a first step in this direction, we perform a preliminary study on a set of developers by providing them with an automated debugging tool and two tasks to be performed with and without the tool. Our results provide initial evidence that several assumptions made by automated debugging techniques do not hold in practice. Through an analysis of the results, we also provide insights on potential directions for future work in the area of automated debugging.

Interactive grouping and filtering in software visualization tools are essential mechanisms enabling the users to build views that match the information needs of their software comprehension task at hand. In this paper we systematically survey these mechanisms in eight graph-based software visualization tools. 1

Previous research has identified several challenges that programmers face in answering questions about a code base. To explore ways to overcome those challenges, we have developed a prototypical programming tool called the Code Set tool. The tool allows programmers to work with sets of source code entities in novel ways, and this support allows programmers to more directly answer a range of questions about a code base. The main focus of this paper is on the design and implementation of the Code Set tool. We also report on a small user study that serves as a first step in evaluating the effectiveness of the Code Set tool. 1

When software developers work with a program’s source code, the structure of the source code often requires that they split their attention simultaneously across several documents and artifacts. Disruptions to programmers ’ concentration caused by overwhelmed capacity can then lead to programming errors and increases in the time to perform a task. We suggest the addition of peripheral interactive spaces to programming environments for supporting developers in maintaining their concentration. We introduce the novel concept of a CodePad, a peripheral, multi-touch enabled display that allows developers to engage with and manipulate multiple programming artifacts. We illustrate visualizations built for a CodePad that support multiple development scenarios and we describe how developers can coordinate the interaction and communication between a Code-Pad and a programming environment in personal and collaborative tasks. Additionally, we propose a design space for other visualization tools and detail our initial prototype.