An Information Foraging Theory Perspective on Tools for Debugging, Refactoring, and Reuse Tasks

Theories of human behavior are an important but largely untapped resource for software engineering research. They facilitate understanding of human developers’ needs and activities, and thus can serve as a valuable resource to researchers designing software engineering tools. Furthermore, theories abstract beyond specific methods and tools to fundamental principles that can be applied to new situations. Toward filling this gap, we investigate the applicability and utility of Information Foraging Theory (IFT) for understanding information-intensive software engineering tasks, drawing upon literature in three areas: debugging, refactoring, and reuse. In particular, we focus on software engineering tools that aim to support information-intensive activities, that is, activities in which developers spend time seeking information. Regarding applicability, we consider whether and how the mathematical equations within IFT can be used to explain why certain existing tools have proven empirically successful at helping software engineers. Regarding utility, we applied an IFT perspective to identify recurring design patterns in these successful tools, and consider what opportunities for future research are revealed by our IFT perspective.Keywords: Programming Environments, Software maintenance, Integrated environments, Information foraging, Interactive environments, Programmer workbench, Human Factors, DesignKeywords: Programming Environments, Software maintenance, Integrated environments, Information foraging, Interactive environments, Programmer workbench, Human Factors, Desig

Find Unique Usages: Helping Developers Understand Common Usages

When working in large and complex codebases, developers face challenges using \textit{Find Usages} to understand how to reuse classes and methods. To better understand these challenges, we conducted a small exploratory study with 4 participants. We found that developers often wasted time reading long lists of similar usages or prematurely focused on a single usage. Based on these findings, we hypothesized that clustering usages by the similarity of their surrounding context might enable developers to more rapidly understand how to use a function. To explore this idea, we designed and implemented \textit{Find Unique Usages}, which extracts usages, computes a diff between pairs of usages, generates similarity scores, and uses these scores to form usage clusters. To evaluate this approach, we conducted a controlled experiment with 12 participants. We found that developers with Find Unique Usages were significantly faster, completing their task in 35% less time

Software Engineers' Information Seeking Behavior in Change Impact Analysis - An Interview Study

Software engineers working in large projects must navigate complex information landscapes. Change Impact Analysis (CIA) is a task that relies on engineers' successful information seeking in databases storing, e.g., source code, requirements, design descriptions, and test case specifications. Several previous approaches to support information seeking are task-specific, thus understanding engineers' seeking behavior in specific tasks is fundamental. We present an industrial case study on how engineers seek information in CIA, with a particular focus on traceability and development artifacts that are not source code. We show that engineers have different information seeking behavior, and that some do not consider traceability particularly useful when conducting CIA. Furthermore, we observe a tendency for engineers to prefer less rigid types of support rather than formal approaches, i.e., engineers value support that allows flexibility in how to practically conduct CIA. Finally, due to diverse information seeking behavior, we argue that future CIA support should embrace individual preferences to identify change impact by empowering several seeking alternatives, including searching, browsing, and tracing.Comment: Accepted for publication in the proceedings of the 25th International Conference on Program Comprehensio

How do coupled file changes influence how developers seek help during maintenance tasks?

Software repositories contain a lot of information that can be transformed into suggestions other files they need to modify during maintenance tasks (so-called “coupled changes”). Existing studies however ignore developer feedback and their influence on the developer strategy for getting help during maintenance tasks. We used the Grounded Theory approach to investigate screen capture videos from an experiment to find which information sources developers use to find help and what is their relevance. We compared the frequency as well as the sequence patterns of used information sources both for the developers using coupled change suggestions and those not using them. We found a set of information sources where the developers seek for help and identified two categories of relevance. Also, we discovered that for the tasks using coupled change suggestions, the developers used mostly the internal IDE elements as an information source whereby the developers not using coupled change suggestions often used external sources like the documentation or the web. Coupled change suggestions influence the strategy how the developers seek for help by reducing the search for information on external locations which makes the process of solving maintenance tasks more compact

Exploring Usage of Web Resources Through a Model of API Learning

Application programming interfaces (APIs) are essential to modern software development, and new APIs are frequently being produced. Consequently, software developers must regularly learn new APIs, which they typically do on the job from online resources rather than in a formal educational context. The Kelleher–Ichinco COIL model, an acronym for “Collection and Organization of Information for Learning,” was recently developed to model the entire API learning process, drawing from information foraging theory, cognitive load theory, and external memory research. We ran an exploratory empirical user study in which participants performed a programming task using the React API with the goal of validating and refining this model. Our results support the predictions made by the COIL model, especially the role of external memory in the API learning process. Participants extensively used browser tabs to store web resources in external memory, but their behavior suggests some inefficiencies that incur extraneous cognitive load

A study of refactorings during software change tasks

Developers frequently undertake software change tasks that could be partially or fully automated by refactoring tools. As has been reported by others, all too often, these refactoring steps are instead performed manually by developers. These missed opportunities are referred to as occasions of disuse of refactoring tools. We perform an observational study in which 17 developers with professional experience attempt to solve three change tasks with steps amenable to the use of refactoring tools. We found that the strategies developers use to approach these tasks shape their workflow, which, in turn, shape the opportunities for refactoring tool use. We report on a number of findings about developer strategies, demonstrating the difficulty of aligning the kind of refactoring steps that emerge during a change task based on the strategy with the tools available. We also report on findings about refactoring tools, such as the difficulties developers face in controlling the scope of application of the tools. Our findings can help inform the designers of refactoring tools.publishedVersio

End-user programming tool for analyzing food composition data from Automated Multiple-Pass Method (AMPM) food surveys and building a comprehensive food profile

Surveys are often used in health studies to collect data about participants for scientific research. An increasing number of health scientists are turning to online data collection methods because they are less costly and can reach a large diverse population quickly. Online surveys also make it easy to track and manage the responses from participants. The WAVE project is a 5 year childhood obesity prevention study being conducted at Oregon State University by health scientists utilizing a web application called WavePipe. WavePipe enables the health scientists to create studies, enroll subjects, assign mobile devices, collect physical activity data, collect nutritional data through online surveys, and analyze the data. This Master’s project presents a new sub-system that enables health scientists to analyze and visualize large quantities of AMPM 24-hour dietary recalls for sub-groups of participants over any desired period of time. In addition, the sub-system enables scientists to import new food information from multiple food composition databases and create entries of new foods to build a comprehensive food profile. The output from this sub-system is customized report that shows a selection of nutrients by a sub-group of subjects

Towards helping end-user programmers’ information foraging by manipulating information features in a patch

Software maintenance tasks often require finding information within existing code, which is time-consuming and difficult even for professional programmers. For example, programmers may need to know what code implements certain functionality or what is the purpose of certain code. In response, researchers have developed tools to help programmers find information during programming tasks. The empirical success of these tools can be explained by Information Foraging Theory (IFT), which predicts how people will seek information by navigating through virtual patches in an information system. In the case of programming, these patches are often chunks of code (e.g., functions), with navigable links for moving among methods. IFT predicts people will perceive cues (such as words or symbols) associated with navigable links, select links that seem relevant to their information needs, and attempt to obtain the needed information by maximizing the rate of information gained relative to the cost of navigating and understanding patches. Many existing tools accelerate foraging by decreasing the cost associated with navigating from one patch to another. IFT suggests that the visual weight of the information features in a patch can have a strong effect on a predator’s foraging choices and, consequently, on how well the predator succeeds in maximizing the rate of information gain. In an ideal situation, visual weight will efficiently lead the predator to the needed information; on the other hand, if visual weight leads the predator astray, then this could lead the predator to process more patches than necessary (increasing cost and reducing the rate of information gain). Therefore, it is anticipated that increasing the relative weight of important information features with respect to unimportant information features will aid an end-user programmer’s foraging effort. Towards this end, two prototypes were implemented: each of these uses an existing algorithm to identify the most important lines of code in a function. One prototype increases the relative weight of important information features by highlighting important lines of code; the other prototype decreases the relative weight of unimportant information features by hiding unimportant lines of code. This research's focus is end-user programmers, who have received minimal attention in prior work. An empirical study evaluated the effectiveness of the prototypes relative to the baseline (no information feature modification). These results indicate that increasing the relative weight of important information features by highlighting important statements had a significant effect on the amount of information foraged and the rate of information gained; on the other hand, decreasing the relative weight of unimportant information features by hiding unimportant statements had a significant effect on the rate of information gained, but not on the amount of information foraged. Neither approaches seemed to have any effect on the amount of time spent on information foraging or patch-to-patch navigation

Exploring How Novice Programmers Pick Debugging Tactics When Debugging: A Student’s Perspective

Novice developers use a variety of debugging tactics to debug. However, how they select a tactic still remains unclear. Many studies in Software Engineering describe programmers using tactics like adding print statements, but only a few studies hint at factors such as knowledge and habits, social environment, and experience that may influence these decisions. To help us understand how novice programmers select debugging tactics, we turned to Information Foraging Theory (IFT) to analyze this decision-making process through the lens of a cost-benefit analysis. We conducted a qualitative study that explored how novice programmers describe their decision-making process when deciding which debugging tactics to use when debugging. We found that novice programmers use a variety of debugging tactics including testing code, searching for help, and taking notes on paper. Furthermore, we reported activities where novices leverage their past experiences, adapt to their task environments, and anticipate future risks and rewards to decide among a variety of tactics to pursue. From our results, we offer suggestions to educators to explicitly teach the value and costs of using certain tactics so that novice programmers may select the optimal tactic in any debugging situation. Furthermore, we suggest future research to explore novice debugging behaviors within non-computing environments to gain a holistic understanding of the debugging process