©2004 IEEE. Personal use of this material is permitted. However, permission to reprint/republish this material for advertising or promotional purposes or for creating new collective works for resale or redistribution to servers or lists, or to reuse any copyrighted component of this work in other works must be obtained from the IEEE.

Much of software developers’ time is spent understanding unfamiliar code. To better understand how developers gain this understanding and how software development environments might be involved, a study was performed in which developers were given an unfamiliar program and asked to work on two debugging tasks and three enhancement tasks for 70 minutes. The study found that developers interleaved three activities. They began by searching for relevant code both manually and using search tools; however, they based their searches on limited and misrepresentative cues in the code, environment, and executing program, often leading to failed searches. When developers found relevant code, they followed its incoming and outgoing dependencies, often returning to it and navigating its other dependencies; while doing so, however, Eclipse’s navigational tools caused significant overhead. Developers collected code and other information that they believed would be necessary to edit, duplicate, or otherwise refer to later by encoding it in the interactive state of Eclipse’s package explorer, file tabs, and scroll bars. However, developers lost track of relevant code as these interfaces were used for other tasks, and developers were forced to find it again. These issues caused developers to spend, on average, 35 percent of their time performing the mechanics of navigation within and between source files. These observations suggest a new model of program understanding grounded in theories of information foraging and suggest ideas for tools that help developers seek, relate, and collect information in a more effective and explicit manner.

Models of programming and debugging suggest many causes of errors, and many classifications of error types exist. Yet, there has been no attempt to link causes of errors to these classifications, nor is there a common vocabulary for reasoning about such causal links. This makes it difficult to compare the abilities of programming styles, languages, and environments to prevent errors. To address this issue, this paper presents a model of programming errors based on past studies of errors. The model was evaluated with two observational of Alice, an event-based programming system, revealing that most errors were due to attentional and strategic problems in implementing algorithms, language constructs, and uses of libraries. In general, the model can support theoretical, design, and educational programming research.

An essential aspect of programmers' work is the correctness of their code. This makes current HCI techniques ichnikTz to analyze and desiW the programmiz systems that programmers use everyday,siry thesetechnixb% focus more on problemswib learnabifi%x andefficiqxk of use, and less on error-proneness. We propose a frameworkand methodology that focusesspeci-q-%b on errors bysupportiz thedescrizkTz andikb-zW-kTzzW of the causes of software errorsi terms ofchaib ofcogniqfik breakdowns. The frameworki based on both old and newstudiW ofprogrammiqfi as well as general research on themechanikT of human error. Our experi%kT- usie the frameworkand methodology to study theAlib programmiT system havediek-W% iek-W% thedesib of several newprogrammitools and idkfi-WbWkT Thi ii-Wb theWhyliO debuggib iuggibkT whi we have shown to reduce debuggifi tiu by a factor of 8 and help programmers get 40% further throughthei tasks. WediOEfi% the framework's and methodology'sithodology' forprogrammisystem desimk softwareengirek%EbO and the psychology of programming.

Abstract. The goal of our study is to evaluate the effect on program comprehension of three factors that have not previously been studied in a single experiment. These factors are programmer expertise (expert versus novice), programming task (documentation versus reuse), and the development of understanding over time (phase 1 versus phase 2). This study is carried out in the context of the mental model approach to comprehension based on van Dijk and Kintsch’s model [(1983) Strategies of Discourse Comprehension. New York: Academic]. One key aspect of this model is the distinction between two kinds of representation the reader might construct from a text: (1) the textbase, which refers to what is said in the text and how it is said, and (2) the situation model, which represents the situation referred to by the text. We have evaluated the effect of the three factors mentioned above on the development of both the textbase (or program model) and the situation model in object-oriented program comprehension. We found a four-way interaction of expertise, phase, task and type of model. For the documentation group we found that experts and novices differ in the elaboration of their situation model but not their program model. There was no interaction of expertise with phase and type of model in the documentation group. For the reuse group, there was a three-way interaction between phase, expertise and type of model. For the novice reuse group, the effect of the phase was to increase the construction of the situation model but not the program model.

Many of the object-oriented metrics that have been developed by the research community are believed to measure some aspect of complexity. As such, they can serve as leading indicators of problematic classes, for example, those classes that are most fault-prone. If faulty classes can be detected early in the development project's life cycle, mitigating actions can be taken, such as focused inspections. Prediction models using design metrics can be used to identify faulty classes early on. In this paper, we present a cognitive theory of object-oriented metrics and an empirical study which has as objectives to formally test this theory while validating the metrics and to build a post-release fault-proneness prediction model. The cognitive mechanisms which we apply in this study to object-oriented metrics are based on contemporary models of human memory. They are: familiarity, interference, and fan effects. Our empirical study was performed with data from a commercial Java application. We found that Depth of Inheritance Tree (DIT) is a good measure of familiarity and, as predicted, has a quadratic relationship with fault-proneness. Our hypotheses were confirmed for Import Coupling to other classes, Export Coupling and Number of Children metrics. The Ancestor based Import Coupling metrics were not associated with fault-proneness after controlling for the confounding effect of DIT. The prediction model constructed had a good accuracy. Finally, we formulated a cost savings model and applied it to our predictive model. This demonstrated a 42% reduction in post-release costs if the prediction model is used to identify the classes that should be inspected.

Roles can be assigned to occurrences of variables in programs according to a small number of stereotypical patterns of use. Studies on explicitly teaching roles to novices learning programming have shown that roles are an excellent pedagogical tool for clarifying the structure and meaning of programs and that their use improves students ’ programming skills. This paper describes how roles can be applied in various programming paradigms and presents the results of three studies designed to test the understandability and acceptability of the role concept and of the individual roles in procedural, object-oriented and functional programming. Based on the results, two new roles and small modifications to the definitions of the original roles are suggested.

This study examines the direction and scope of comprehension-related activities of professional programmers carrying out several comprehension and maintenance activities over time. Procedural and object-oriented (OO) programmers studied a program and subsequently performed modifications during two sessions. Results showed that the OO programmers tended to use a strongly top-down approach to program understanding during an early phase of study of the program but increasingly used a bottom-up approach during the maintenance tasks. The procedural programmers used a more bottom-up orientation throughout all activities. The scope of the activities was greater for the procedural than for the OO programmers. However, regardless of paradigm, the programmers over time built a broad, rather than a localized, view of the program. 1.

Abstract Program comprehension research can be characterized by both the theories that provide rich explanations about how programmers understand software, as well as the tools that are used to assist in comprehension tasks. In this paper, I review some of the key cognitive theories of program comprehension that have emerged over the past thirty years. Using these theories as a canvas, I then explore how tools that are commonly used today have evolved to support program comprehension. Specifically, I discuss how the theories and tools are related and reflect on the research methods that were used to construct the theories and evaluate the tools. The reviewed theories and tools are distinguished according to human characteristics, program characteristics, and the context for the various comprehension tasks. Finally, I predict how these characteristics will change in the future and speculate on how a number of important research directions could lead to improvements in program comprehension tool development and research methods.

First and foremost I would like to thank my advisor, Alex Kirlik. As this project has traveled through numerous literatures and tried to find a balance between cognitive psychology and software engineering, he has really helped to get to the bottom of what matters and is important. He has always had something useful to provide despite not having a background in software engineering or the psychology of programming, and his perspectives have shaped this project. I would like to thank Ralph Johnson for providing advice and suggestions and for inspiring me to be interested in software design and the topic of this thesis. I would like to thank my roommates for helping me practice presentations, proof materials, figure out statistics, and whatever else I needed help with at a moments notice. I would like to thank my all of my friends who were willing to be participants, especially the two willing to be unpaid pilot participants. I would like to thank Susan Garnsey for teaching me what a research life is like and for always having something kind, understanding, and constructive to say no matter what the situation. I would like to Colleen Conley for having a handout for every question and all of the psych honors students for being good comrades. And finally I would like to thank my parents for always being supportive of everything I do.