Modern software development communities are increasingly social. Popular chat platforms such as Slack host public chat communities that focus on specific development topics such as Python or Ruby-on-Rails. Conversations in these public chats often follow a Q&A format, with someone seeking information and others providing answers in chat form. In this paper, we describe an exploratory study into the potential use-fulness and challenges of mining developer Q&A conversations for supporting software maintenance and evolution tools. We designed the study to investigate the availability of information that has been successfully mined from other developer communications, particularly Stack Overflow. We also analyze characteristics of chat conversations that might inhibit accurate automated analysis. Our results indicate the prevalence of useful information, including API mentions and code snippets with descriptions, and several hurdles that need to be overcome to automate mining that information.

Implementing a software engineering analytics solution poses challenges and offers significant value for the globally distributed software development organization at ABB. Because software development activities in agile methodologies revolve around the team, ABB decided to implement an analytics solution focused on team metrics as part of its Software Development Improvement Program. Using key in...

ABSTRACTThis paper summarizes the initial experiences and lessons learned while enabling and practicing agile methods at an industrial research lab. Lab staff are highly‐educated personnel who innovate in complex mixed hardware/software systems, software‐intensive systems, hardware components, and systems of systems. We discuss our goals in introducing agile, the challenges we faced with globally distributed industrial research in our capricious, uncertain, risky, variable, and evolving (CURVE) domains, how we addressed these challenges, results and lessons learned to date, and our next steps.

Due to the high number and cost of interruptions at work, several approaches have been suggested to reduce this cost for knowledge workers. These approaches predominantly focus either on a manual and physical indicator, such as headphones or a closed office door, or on the automatic measure of a worker's interruptibilty in combination with a computer-based indicator. Little is known about the combination of a physical indicator with an automatic interruptibility measure and its long-term impact in the workplace. In our research, we developed the FlowLight, that combines a physical traffic-light like LED with an automatic interruptibility measure based on computer interaction data. In a large-scale and long-term field study with 449 participants from 12 countries, we found, amongst other results, that the FlowLight reduced the interruptions of participants by 46%, increased their awareness on the potential disruptiveness of interruptions and most participants never stopped using it.

A large corpora of software-related documents is available on the Web, and these documents offer the unique opportunity to learn from what developers are saying or asking about the code snippets that they are discussing. For example, the natural language in a bug report provides information about what is not functioning properly in a particular code snippet. Previous research has mined information about code snippets from bug reports, emails, and Q&A forums. This paper describes an exploratory study into the kinds of information that is embedded in different software-related documents. The goal of the study is to gain insight into the potential value and difficulty of mining the natural language text associated with the code snippets found in a variety of software-related documents, including blog posts, API documentation, code reviews, and public chats.

Past studies show that developers who navigate code in a structural manner complete tasks faster and more correctly than those whose behavior is more opportunistic. The goal of this work is to move professional developers towards more effective program comprehension and maintenance habits by providing an approach that fosters structural code navigation. To this end, we created a Visual Studio plugin called Prodet that integrates an always-on navigable visualization of the most contextually relevant portions of the call graph. We evaluated the effectiveness of our approach by deploying it in a six week field study with professional software developers. The study results show a statistically significant increase in developers' use of structural navigation after installing Prodet. The results also show that developers continuously used the filtered and navigable call graph over the three week period in which it was deployed in production. These results indicate the maturity and value of our approach to increase developers' effectiveness in a practical and professional environment.

Software engineering researchers develop great techniques consisting of practices and tools that improve efficiency and quality of software development. Prior work evaluates developers' use of techniques such as Test-Driven-Development and refactoring by measuring actions in the development environment. What we still lack is a method to communicate effectively and motivate developers to adopt best practices and tools. This work proposes a game-like system to motivate adoption while continuously measuring developers' use of more efficient development techniques.

Automated program transformation can significantly improve the speed and accuracy of adaptive maintenance tasks. However, developers typically eschew program transformation because of the difficulty in creating, using, and maintaining transformations. They may also be unwilling to learn a new technique that will be used infrequently. We present an approach that leverages programmers' existing knowledge of C# and LINQ to drastically reduce the learning curve associated with program transformation.

This paper presents an automatic technique for generating maintainable regression unit tests for programs. We found previous test generation techniques inadequate for two main reasons. First. they were designed for and evaluated upon libraries rather than applications. Second, they were designed to find bugs rather than to create maintainable regression test suites: the test suites that they generated were brittle and hard to understand. This paper presents a suite of techniques that address these problems by enhancing an existing unit test generation system. In experiments using an industrial system, the generated tests achieved good coverage and mutation kill score, were readable by the product's developers, and required few edits as the system under test evolved. While our evaluation is in the context of one test generator, we are aware of many research systems that suffer similar limitations, so our approach and observations are more generally relevant.

Collaboration between research groups can be quite difficult. Differences in hardware, software, and operating environments can lead to differences in results or even errors. Overcoming these difficulties can take significant time, or even result in ending the collaboration. A solution is presented and applied to two collaborations between ABB and universities. This collaboration involves using virtual machines as a way to create and deploy environments to each collaborator. The results show that this virtual machine solution allows for significant time savings in experimental setup. Also, collaborators are able to quickly reproduce results and remotely investigate any issues uncovered. Finally, this solution allows experiments to be rerun at later points in time without the need to recreate the environment.

Recent progress in the use of data mining and statistical techniques to automatically classify related software failures and to localize defects suggests that if appropriate information is collected about executions of deployed software, then such techniques can assist developers in prioritizing action on soft failures reported by users and in diagnosing their causes. Users, however, are not reliable judges of correct software behavior: they may overlook real failures, neglect to report failures they do observe, or report spurious failures. Instead, I propose to employ users as independent checks on each other. Previous work demonstrated that executions with similar execution profiles often represent similar program behavior. By grouping similar executions together, developers can use user-submitted labels to corroborate each other: similar executions with the same label represent consensus, and similar executions with differing labels represent suspicious or confusing behavior. An empirical evaluation of two proposed techniques, Corroboration-based Filtering, Review-All-FAILUREs plus k-Nearest Neighbors, indicates that they discover significantly more failures and defects than the naive review-all-FAILUREs strategy. A third technique, round-robin cluster sampling, discovers failures and defects more quickly than RAF.

Operational or "beta" testing of software has a number of benefits for software vendors and has become common industry practice. However, ordinary users are more likely to overlook or misreport software problems than experienced software testers are. To compensate for this shortcoming, we present a technique called corroboration-based filtering for corroborating user assessments of individual operational executions for which audit information has been captured for possible offline review. Independent assessments concerning similar executions are pooled by automatically clustering together executions with similar execution profiles. Executions are chosen for review based on their user assessments, the size of the cluster each execution belongs to, and whether the cluster has already been confirmed by developers to contain an actual failure. We explain the rationale for this technique, analyze it probabilistically, and present the results of empirically comparing it to alternative techniques.

This paper describes an automated tool called Dex (Difference extractor) for analyzing syntactic and semantic changes in large C-language code bases. It is applied to patches obtained from a source code repository, each of which comprises the code changes made to accomplish a particular task. Dex produces summary statistics characterizing these changes for all of the patches that are analyzed. Dex applies a graph differencing algorithm to abstract semantic graphs (ASGs) representing each version. The differences are then analyzed to identify higher-level program changes. We describe the design of Dex, its potential applications, and the results of applying it to analyze bug fixes from the Apache and GCC projects. The results include detailed information about the nature and frequency of missing condition defects in these projects.