In popular continuous integration (CI) practice, coding is followed by building, integration and system testing, pre-release inspection and deploying artifacts. This can reduce integration risk and speed up development process. But large number of CI build failures may interrupt normal software development process. So, the failures need to be analyzed and fixed quickly. Although various automated program repair techniques have great potential to resolve software failures, the existing techniques mostly focus on repairing source code. So, those techniques cannot directly help resolve software build failures. Apart from that, a special challenge to fix build failures in CI environment is that the failures are often involved with both source code and build scripts. This paper outlines promising preliminary work towards automatic build repair in CI environment that involves both source code and build script. As first step we conducted an empirical study on software build failures and build fix patterns. Based on the findings of the empirical study, we developed an approach that can automatically fix build errors involving build scripts. We plan to extend this repair approach considering both source code and build script. Moreover, we plan to quantify our automatic fixes by user study and comparison between fixes generated by our approach and actual fixes.

Foyzul Hassan

University of Texas at San Antonio, USA

United States

Continuous Integration (CI) is a widely-adopted software engineering practice. Despite its undisputed benefits, like higher software quality and improved developer productivity, mastering CI is not easy. Among the several barriers when transitioning to CI, developers need to face a new type of software failures (i.e., build failures). Even when a team has successfully adopted a CI culture, living up to its principles and improving the CI practice are also challenging. In my research, I want to provide developers with support for establishing CI and proper recommendation for continuously improving their CI process.

Carmine Vassallo

University of Zurich

Switzerland

Bugs in commercial software and third-party components are an undesirable and expensive phenomenon. Such software is usually released to users only in binary form. The lack of source code renders users of such software dependent on their software vendors for repairs of bugs. Such dependence is even more harmful if the bugs introduce new vulnerabilities in the software. Automatically repairing security and functionality bugs in binary code increases software robustness without any developer effort. In this research, we propose development of a binary program repair tool that uses existing bug-free fragments of code to repair buggy code.

Vaibhav Sharma

University of Minnesota

United States

The error repair process in software systems is,historically, a resource-consuming task that relies heavily in developer manual effort. Automatic program repair approaches enable the repair of software with minimum human interaction,therefore, mitigating the burden from developers. However, a problem automatically generated patches commonly suffer is generating low-quality patches (which overfit to one program specification, thus not generalizing to an independent oracle evaluation). This work proposes a set of mechanisms to increase the quality of plausible patches including an analysis of test suite behavior and their key characteristics for automatic program repair, analyzing developer behavior to inform the mutation operator selection distribution, and a study of patch diversity as a means to create consolidated higher quality fixes.

Mauricio Soto

Carnegie Mellon University

Costa Rica

Fork-based development is a lightweight mechanism that allows developers to collaborate with or without explicit coordination. Although it is easy to use and popular, when developers each create their own fork and develop independently, their contributions are usually not easily visible to others. When the number of forks grows, it becomes very difficult to maintain an overview of what happens in individual forks, which would lead to additional problems and inefficient practices: lost contributions, redundant development, fragmented communities, and so on. Facing the problems mentioned above, we developed two complementary strategies: (1) Identifying existing best practices and suggesting evidence-based interventions for projects that are inefficient; (2) designing new interventions that could improve the awareness of a community using fork-based development, and help developers to detect redundant development to reduce unnecessary effort.

Shurui Zhou

Carnegie Mellon University, USA

United States

High-fidelity GUI prototyping provides a meaningful manner for illustrating the developers’ understanding of the requirements formulated by the customer and can be used for productive discussions and clarification of requirements and expectations. However, high-fidelity prototypes are time-consuming and expensive to develop. Furthermore, the interpretation of requirements expressed in informal natural language is often error-prone due to ambiguities and misunderstandings. In this dissertation project, we will develop a methodology based on Natural Language Processing (NLP) for supporting GUI prototyping by automatically translating Natural Language Requirements (NLR) into a formal Domain-Specific Language (DSL) describing the GUI and its navigational schema. The generated DSL can be further translated into corresponding target platform prototypes and directly provided to the user for inspection. Most related systems stop after generating artifacts, however, we introduce an intelligent and automatic interaction mechanism that allows users to provide natural language feedback on generated prototypes in an iterative fashion, which accordingly will be translated into respective prototype changes.

Kristian Kolthoff

Institute for Enterprise Systems (InES), University Of Mannheim

Germany

The increasing popularity of dynamically-typed programming languages, such as JavaScript or Python, requires specific support methods for developers to avoid pitfalls arising from the dynamic nature of these languages. Static analyses are frequently used but the dynamic type systems limit their applicability. Dynamic analyses, in contrast, depend on the execution of the code under analysis, and thus depend on the quality of existing tests. This quality of the test suite can be improved by the use of automated test generation but automated test generation for dynamically-typed programming languages itself is hard due to the lack of type information in the programs. The limitations of each of these approaches will be overcome by iteratively combining test generation with static and dynamic analysis techniques for dynamically-typed programs.

Stephan Lukasczyk

University of Passau

Germany

Over the past decades, various techniques for the application of formal program analysis of software systems have been proposed. However, the application of formal methods for software verification is still limited in practise. It is acknowledged that the task of formally specifying requirements by creating property specifications and the need of the interaction by the engineer with the prover during the execution of the proof are valid hindrances. The objectives of the presented PhD project are the automated inference of declarative property specifications from example scenarios during the phase of Requirements Engineering and their automated verification on abstract model level and on code level. Applying Inductive Logic Programming, we introduce the necessary modifications and extensions of the methodology in order to enable property specification mining from example data. Example data are to be collected with the guidance by the Scenario Modeling Strategies to ensure the necessary coverage of the scenario that is stated with the application in order to correct use of the provided information in the property specification mining algorithm. However, the specification mining algorithm is expected to produce too many property specifications. To turn the weakness into strength, our approach proposes to use the properties to automate the proof and by this, reduce the necessary interaction with the prover.

Marina Reich

Chemnitz University of Technology/ Airbus Defence and Space GmbH

Germany