Dr. Lingming Zhang recently was awarded the ACM SIGSOFT Distinguished Paper Award for two separate papers presented at the 28th ACM International Symposium on Software Testing and Analysis (ISSTA 2019), a top-tier conference according to csrankings.org and CCF ranking. Dr. Zhang’s group presented three research papers on automated bug diagnosis and repair, and two of the three papers won this prestigious award. In total, three Distinguished Paper Awards were given this year. According to the ISSTA 2019 general chair, Dr. Anders Møller, this is the first time in the 30-year ISSTA history, that two ACM SIGSOFT Distinguished Paper Awards go to the same researcher in the same ISSTA conference. The first work (DeepFL: Integrating Multiple Fault Diagnosis Dimensions for Deep Fault Localization), led by Dr. Zhang’s Ph.D. student Xia Li, leverages recent advances in both Deep Neural Networks and System Engineering for powerful bug diagnosis of modern Java software systems. The second work (History-Driven Build Failure Fixing: How Far Are We?), led by Yiling Lou, a visiting student in Dr. Zhang’s research group, proposes the first technique that generates potential build-error patches via searching from the existing project under test and external resources rather than the historical fix information.
In addition to the two award-winning papers, the third paper (Practical Program Repair via Bytecode Mutation), led by Dr. Zhang’s Ph.D. student Ali Ghanbari, has also been very well received and has been in the top ten most-downloaded papers among all the research papers in ISSTA history within the past six weeks. This work proposes the first practical bytecode-level APR technique, PraPR, and demonstrates that PraPR can fix many more bugs than the state-of-the-art bugs fully automatically with over 10X speedup. Furthermore, PraPR is also the first general-purpose program repair technique that can fix bugs for multiple JVM languages besides Java (e.g., the popular Kotlin language).
As background to Dr. Zhang’s research, it is worth noting that in modern society, almost all aspects of our life are monitored/controlled by software systems, from banking to health care to transportation. Meanwhile, software bugs (also called software faults, errors, defects, flaws, or failures) are prevalent in modern software systems and are widely recognized as notoriously costly and disastrous. In practice, software developers need to spend a tremendous amount of time diagnosing and fixing potential bugs. Dr. Zhang’s recent research on automated bug diagnosis and repair can significantly alleviate this crucial problem.
Below is the summary for all the three papers that Dr. Zhang’s group published in ISSTA 2019:
DeepFL: Integrating Multiple Fault Diagnosis Dimensions for Deep Fault Localization – Xia Li, Wei Li, Yuqun Zhang, and Lingming Zhang
Abstract: Learning-based fault localization has been intensively studied recently. Prior studies have shown that traditional Learning-to-Rank techniques can help precisely diagnose fault locations using various dimensions of fault-diagnosis features, such as suspiciousness values computed by various off-the-shelf fault localization techniques. However, with the increasing dimensions of features considered by advanced fault localization techniques, it can be quite challenging for the traditional Learning-to-Rank algorithms to automatically identify effective existing/latent features. In this work, we propose DeepFL, a deep learning approach to automatically learn the most effective existing/latent features for precise fault localization. Although the approach is general, in this work, we collect various suspiciousness-value-based, fault-proneness-based, and textual-similarity-based features from the fault localization, defect prediction and information retrieval areas, respectively. The corresponding DeepFL techniques have been studied on 395 real bugs from the widely used Defects4J benchmark. The experimental results show that DeepFL can significantly outperform state-of-the-art TraPT/FLUCCS (e.g., localizing 50+ more faults within Top-1). We also investigate the impacts of deep model configurations (e.g., loss functions and epoch settings) and features. Furthermore, DeepFL is also surprisingly effective for cross-project prediction.
History-driven Build Failure Fixing: How Far Are We? – Yiling Lou, Junjie Chen, Lingming Zhang, Dan Hao, and Lu Zhang
Abstract: Build systems are essential for modern software development and maintenance since they are widely used to transform source code artifacts into executable software. Previous work shows that build systems frequently break during software evolution. Therefore, automated build-fixing techniques are in huge demand. In this paper, we target a mainstream build system, Gradle, which has become the most widely used build system for Java projects in the open-source community (e.g., GitHub). HireBuild, a state-of-the-art build-fixing tool for Gradle, has been recently proposed to fix Gradle build failures via mining the history of prior fixes. Although HireBuild has been shown to be effective for fixing real-world Gradle build failures, it was evaluated on only a limited set of build failures, and largely depends on the quality/availability of historical fix information. To investigate the efficacy and limitations of the history-driven build fix, we first construct a new and large build failure dataset from Top-1000 GitHub projects. Then, we evaluate HireBuild on the extended dataset both quantitatively and qualitatively. Inspired by the findings of the study, we propose a simplistic new technique that generates potential patches via searching from the present project under test and external resources rather than the historical fix information. According to our experimental results, the simplistic approach based on present information successfully fixes 2X more reproducible build failures than the state-of-art HireBuild based on history fix information. Furthermore, our results also reveal various findings/guidelines for future advanced build failure fixing.
Practical Program Repair via Bytecode Mutation – Ali Ghanbari, Samuel Benton, and Lingming Zhang
Abstract: Automated Program Repair (APR) is one of the most recent advances in automated debugging, and can directly fix buggy programs with minimal human intervention. Although various advanced APR techniques (including search-based or semantic-based ones) have been proposed, they mainly work at the source-code level, and it is not clear how bytecode-level APR performs in practice. Also, extensive studies of the existing techniques on bugs beyond what has been reported in the original papers are rather limited. In this paper, we implement the first practical bytecode-level APR technique, PraPR, and present the first extensive study on fixing real-world bugs (e.g., Defects4J bugs) using JVM bytecode mutation. The experimental results show that surprisingly even PraPR with only the basic traditional mutators can produce genuine fixes for 17 bugs; with some additional commonly used APR mutators, PraPR is able to produce genuine fixes for 43 bugs, significantly outperforming state-of-the-art APR and being an order of magnitude faster. Furthermore, we also performed an extensive study of PraPR and other recent APR tools on a large number of real-world “unexpected” bugs. Lastly, PraPR has also successfully fixed bugs for other JVM languages (e.g., Kotlin), indicating that bytecode-mutation-based APR can greatly complement the existing source-code-level APR.
ABOUT THE UT DALLAS COMPUTER SCIENCE DEPARTMENT
The UT Dallas Computer Science program is one of the largest Computer Science departments in the United States with over 3,315 bachelors-degree students, more than 1,110 master’s students, 165 Ph.D. students, 56 tenure-track faculty members, and 41 full-time senior lecturers, as of Fall 2019. With The University of Texas at Dallas’ unique history of starting as a graduate institution first, the CS Department is built on a legacy of valuing innovative research and providing advanced training for software engineers and computer scientists.