Contributions published at Human Aspects of Software Engineering (Thomas Fritz)

The aim of this thesis has been to develop a visualization application that supports the analysis of psycho-physiological data recorded from software developers working on code comprehension tasks. Since psycho-physiological (also known as biometric) measurements, such as electrodermal activity (EDA), or electroencephalography (EEG), can be used as indicators for cognitive states, these data are used to detect the difficulties a developer might have experienced during source code comprehension activities. Using three different visualization approaches, a dataset consisting of EEG, EDA and eye-tracking data was investigated with a special focus on the identification of various kinds of patterns (e.g. code reading patterns or time-related biometric patterns). Based on the results of visual inspection (enabled by the visualizations developed for this purpose), significance tests were conducted to verify the findings. The analysis has confirmed eye movement patterns that had been described in previous research. New insights are made regarding time-related patterns. Metric correlations within task data were found, like the accumulation of eyeblinks with concomitant low values for mental focus (Attention eSense™ values). Additionally, metric differences in task pairs of inherently easier/harder tasks were analyzed and interpreted. For example, it was found that the use of mnemonic variable names instead of generic variable names result in a significant lower number of occurrences of the retrace declaration pattern. Learning how software developers read source code and how they emotionally and physiologically react on reading code comprehension tasks could help to locate problematic code segments. Findings in this research field can be used to develop novel programming support tools that make use of psycho-physiological sensors. Depending on programming difficulties detected on the fly (e.g. by identification of biometric patterns), appropriate interventions could be suggested by a rule engine.

The better the software development community becomes at creating software, the more software the world seems to demand. One way to address the gap between software demand and supply is to try to increase the supply, by optimizing the productivity of software developers. Although there is a large body of research about measuring and investigating productivity from an organizational point of view, there is a paucity of research about how software developers, those at the front-line of software construction, think about, assess, and try to improve their productivity. To investigate software developers' perceptions of software development productivity, we conducted two studies: a survey with 379 professional software developers to help elicit themes and an observational study with 11 professional software developers to investigate emergent themes in more detail. In the survey we found that software developers perceive their days as productive when they complete many or big tasks, without significant interruptions or context switches. Yet, the observational data we collected shows our participants performed significant task and activity switching, while still feeling productive. We analyze such apparent contradictions in our findings and use the analysis to propose ways to better support software developers in a retrospection and improvement of their productivity through the development of new tools and the sharing of best practices. Based on the finding that there might not be a single and/or simple measurement for a software developer's productivity, we discuss a new idea to provide a software developer with a meaningful retrospective analysis of his workday and workweek and its possible impact on a developer's productivity.

Software developers make programming mistakes that cause serious bugs for their customers. Existing work to detect problematic software focuses mainly on post hoc identification of correlations between bug fixes and code. We propose a new approach to address this problem --- detect when software developers are experiencing difficulty while they work on their programming tasks, and stop them before they can introduce bugs into the code. In this paper, we investigate a novel approach to classify the difficulty of code comprehension tasks using data from psycho-physiological sensors. We present the results of a study we conducted with 15 professional programmers to see how well an eye-tracker, an electrodermal activity sensor, and an electroencephalography sensor could be used to predict whether developers would find a task to be difficult. We can predict nominal task difficulty (easy/difficult) for a new developer with 64.99% precision and 64.58% recall, and for a new task with 84.38% precision and 69.79% recall. We can improve the Naive Bayes classifier's performance if we trained it on just the eye-tracking data over the entire dataset, or by using a sliding window data collection schema with a 55 second time window. Our work brings the community closer to a viable and reliable measure of task difficulty that could power the next generation of programming support tools.

Software development settings provide a great opportunity for CSCW researchers to study collaborative work. In this paper, we explore a specific work practice called bug reproduction that is a part of the software bug-fixing process. Bug reproduction is a highly collaborative process by which software developers attempt to locally replicate the ‘environment’ within which a bug was originally encountered. Customers, who encounter bugs in their everyday use of systems, play an important role in bug reproduction as they provide useful information to developers, in the form of steps for reproduction, software screenshots, trace logs, and other ways to describe a problem. Bug reproduction, however, poses major hurdles in software maintenance as it is often challenging to replicate the contextual aspects that are at play at the customers’ end. To study the bug reproduction process from a human-centered perspective, we carried out an ethnographic study at a multinational engineering company. Using semi-structured interviews, a questionnaire and half-a-day observation of sixteen software developers working on different software maintenance projects, we studied bug reproduction. In this paper, we present a holistic view of bug reproduction practices from a real-world setting and discuss implications for designing tools to address the challenges developers face during bug reproduction.

Persuasive technology to motivate healthy behavior is a growing area of research within HCI and ubiquitous computing. The emergence of commercial wearable devices for tracking health- and fitness-related activities arguably represents the first widespread adoption of dedicated ubiquitous persuasive technology. The recent ubiquity of commercial systems allows us to learn about their value and use in truly “in the wild” contexts and understand how practices evolve over long-term, naturalistic use. We present a study with 30 participants who had adopted wearable activity-tracking devices of their own volition and had continued to use them for between 3 and 54 months. The findings, which both support and contrast with those of previous research, paint a picture of the evolving benefits and practices surrounding these emerging technologies over long periods of use. They also serve as the basis for design implications for personal informatics technologies for long-term health and fitness support.

By 2020, depression will be the disease with the second-highest financial demand. Health monitor devices that have recently coming to customer markets may support treatment and reduce costs. This thesis tries to identify sensing opportunities in an inpatient facility. Therefore, a three-days at a psychiatric hospital and four interviews with therapists have been conducted. Eleven general findings are presented. Design opportunities and implications are discussed. A list of indicators for elevated suicidal-risk is compiled. And four fields of application for smart pedometers are introduced.

Developers spend a substantial amount of their time searching, navigating and reading source code while performing a change task. Several research approaches have been suggested to recommend points in the source code, which are relevant for the change task at hand. However, none of these approaches leverages information given through the Mylyn task context. We conducted an exploratory study to investigate this initial search, reading and navigation phase before the source code is changed. We found that presenting a context along with search results, supports a developer in selecting relevant search results. Furthermore, we identified that a major challenge during the initial search phase, is the finding of good search terms given the change task description. To overcome the challenge of finding good search terms for a change task at hand, we suggest two approaches which leverage information given through the Mylyn task contexts. The design implications on the presentation of the search result context, are implemented in a prototype application which automatically suggests starting points for a change task at hand by using user interaction histories.

This master thesis explores a developer's brain activity patterns. NeuroSky's MindBand, a low-cost and unobtrusive EEG monitoring device, is used to record EEG data. The data used in this thesis was obtained in a study in coorporation with Microsoft, where developers solved short code analysis tasks of varying difficulty levels. Statistical relationships between EEG related features and the task difficulty reported by the study participants are investigated to identify the most significant features. Additionally, it is shown that it is possible to classify between two levels of difficulty using EEG related features. Then, additional EEG data is collected during a real-world workday of a developer using NeuroSky's MindBand. Although the tasks solved during this recording session varied broadly, similar statistical relationships are discovered. The second part of this thesis uses the insights gathered in the first part to build a prototype application in the field of reflective and persuasive technology. Ideas are presented showing how EEG data can be used to enable a developer to analyse his state of mind during work. This might help him to indicate when, for instance, he should schedule high priority tasks during the day or to avoid interruptions during times he is particularly focused on his work.

Software developers spend much time on navigation and comprehension of code. While navigating through the code, developers build a mental model of the code. When developers are asked to draw these mental models, they draw diagrams, which often consist of objects and relations that help developers to understand the code. We developed a tool that maintains and visualizes context models, which represent these diagrams. By displaying the context model to developers while navigating through the code, we expect developers to be more efficient because they can follow track of objects and relationships displayed in the model. Developers often navigate to irrelevant code respective to the current task. In our approach, we included special proactive navigation mechanisms that help developers to avoid navigating to irrelevant code and keep developers more focused on the task. In our approach we combine context models and proactive navigation mechanism. To evaluate our approach we simulated the developer’s interaction of a previous study with our tool running in Microsoft Visual Studio. The data from the previous study contains diagrams which developers drew after they complete their tasks. We compared these diagrams with the context models displayed by our tool. The precision of the generated context model is about 75%. This indicates that the tool can automatically build models which contain elements that developers mentioned to be most relevant. The results also show that the objects of all simulated steps that lead the developer to previously visited code were displayed by our tool in 100% of cases before the revisit happened. We believe that our approach can help developers to work more efficiently because they could avoid many revisitations with our tool.

Software developers spend a significant amount of their time interpreting and navigating through code. During this process developers build an implicit model of the code structure relevant to the current task they are working on. In an exploratory study we conducted, 68% of the navigation steps of developers working on bug fixing tasks, were revisits. Based on the results of the study, we developed an approach that automatically captures a developer's interaction with code elements in an IDE and presents the relevant code structure graphically to the developer. To evaluate how relevant the elements in the generated diagram are, we simulated the developer's interaction with the IDE that we recorded during the exploratory study. We compared the elements in the diagram after each simulated step of interaction with a chart of relevant code elements that the study subjects drew after completing their tasks. The results show that in the simulations the elements which the study subject revisited were visible in the generated diagram before the re-visitation happened. From this finding, we can imply that the prototype has a potential to save time in software change tasks. Finally, we propose improvements to the system based on our evaluation.

With the paradigm shift from simple mouse and keyboard interactions to more intuitive and natural input mechanisms, one software takes advantage of such novel Natural User Interfaces after another as they allow new ways of how users can interact with digital content. Instead of simple clicks and keystrokes, more advanced movements can be captured and interpreted. In case multi-touch enabled screens are employed, a wide range of natural finger or hand gestures could act as commands. Even though such touch screens are omnipresent in our daily environment, yet little effort has been put in the research of their application in the area of software exploration. We tackle this lack of corresponding exploration tools by the development of a Microsoft Visual Studio extension, which will suit the purpose of a touch driven source code investigation. This plug-in, named Interactive Exploration, provides the opportunity to use simple touch gestures in order to analyse code elements and their dependencies. A well-structured graph serves as mental model, allows the navigation along entity relations and supports the annotation of particular elements. The conducted evaluation revealed that our approach fulfils the necessary requirements in order to be intuitive. The design of the user interface, as well as the supported gestures and the layout of the so-called Exploration Graph, were highly appreciated by the evaluators.

As a software system evolves, the system’s code base constantly changes, making it difficult for developers to answer such questions as who is knowledgeable about particular parts of the code or who needs to know about changes made. In this paper, we show that an externalized model of a developer’s individual knowledge of code can make it easier for developers to answer such questions. We introduce a degree-of-knowledge model that computes automatically, for each source code element in a code base, a real value that represents a developer’s knowledge of that element based on a developer’s authorship and interaction data. We present evidence that shows that both authorship and interaction data of the code are important in characterizing a developer’s knowledge of code. We report on the usage of our model in case studies on expert finding, knowledge transfer and identifying changes of interest. We show that our model improves upon an existing expertise finding approach and can accurately identify changes for which a developer should likely be aware. We discuss how our model may provide a starting point for knowledge transfer but that more refinement is needed. Finally, we discuss the robustness of the model across multiple development sites.

Recent advances in small inexpensive sensors, cheaper storage, and low-power processing cause an increasing popularity of trackers that quantify a user’s activities throughout his everyday life. The Fitbit and the Nike+ Fuelband are two examples of commercial approaches that motivate a user to be more active by tracking his activity and visualizing the analyzed data. In the area of software engineering there are similar tools to support a developer in a single domain of his work, such as planning tools or bug repositories. Only little research has been performed on how to integrate the available data and how to focus on providing a retrospection of a developer’s work day. In order to contribute to overcome this shortcoming we introduce a tool, Happy Coder that provides developers with a retrospective analysis of their work day, by tracking predefined metrics and visualizing them on a web client. This includes a front-end with consolidated data analysis, visualizations and representations of the collected data. Two studies revealed that developers assess their productivity based on a personal evaluation of their work day. This assessment is dominated by personal preferences of different metrics like work items, meetings, web searches or activities on the computer.

Developers heavily rely on Local Code Search (LCS)---the execution of a text-based search on a single code base---to find starting points in software maintenance tasks. While LCS approaches commonly used by developers are based on lexical matching and often result in failed searches or irrelevant results, developers have not yet migrated to the various research approaches that have made significant advancements in LCS. We hypothesize that two of the major reasons for this lack of migration are as follows. First, developers do not know which approach is the best, due to a lack of comparative field studies and the discrepancies in the underlying LCS process that these research approaches address. Second, developers lack access to a stable implementation of most of the research approaches. To address these issues, we studied a number of LCS approaches, distilled the general component structure underlying these approaches and, based on this structure, developed a LCS tool and framework, called Sando. Currently used by developers at ABB, Inc. and elsewhere, Sando also supports the flexible extension of its components to rapidly disseminate research advancements, and allows for user-based evaluation of competing approaches.

A software developer asks many questions every day. Answering this questions requires a big effort for seeking in multiple information repositories and linking this information creates a cognitive burden on the stakeholders. This thesis work is based on the paper Information fragments, published by Fritz and Murphy [1], proposing an information fragment model and discussing frequently asked questions by software developers. In this thesis work, we will extend this model, introduce data abstraction to embed any kind of information sources, and implement various data representations. Furthermore, it will be shown, how our approach can improve developer’s performance on the job.

To complete a change task, software developers spend a substantial amount of time navigating code to understand the relevant parts. During this investigation phase, they implicitly build context models of the elements and relations that are relevant to the task. Through an exploratory study with twelve developers completing change tasks in three open source systems, we identified important characteristics of these context models and how they are created. Our study uncovered that code context models are highly connected and that developers start tasks using a combination of search and navigation. Building upon our findings and drawing from related studies, we developed an approach to automate the generation of code context models that combines the previously distinct phases of search and navigation. We evaluated our approach, CoMoGen, against the study data. CoMoGen performed significantly better than state-of-the-art and state-of-the-practice approaches for locating initial code elements necessary for generating code context models. We believe this work represents a substantial step towards providing automated code context models that will reduce the time and effort needed for change tasks.

null

null