- The paper surveys automatic software repair methods, categorizing them into behavioral repair (modifying code) and state repair (altering execution state).
- The paper discusses empirical studies that evaluate the effectiveness and challenges of automatic repair, including patch correctness and overfitting issues.
- The paper explores related areas such as repair suggestion systems and theoretical foundations, making it a vital resource for researchers in automatic software repair.
Automatic Software Repair: A Comprehensive Bibliography
The paper "Automatic Software Repair: A Bibliography" authored by Martin Monperrus offers an extensive survey of the current landscape of automatic software repair methodologies. Automatic software repair involves the autonomous detection and correction of software bugs without human intervention. This survey provides an insightful categorization and analysis of various repair strategies, offering an in-depth view suitable for researchers in software engineering, dependability, programming languages, and related fields.
The paper categorizes automatic repair strategies into two primary classes: behavioral repair and state repair. Behavioral repair methodologies focus on modifying the code itself, which can involve changing source code or binary code at runtime. This category encompasses techniques such as test-suite based repair (e.g., Genprog), use of pre- and post-conditions (e.g., AutoFix-E), and static analysis (e.g., Logozzo and Ball's work on .Net). These techniques leverage various bug oracles like test cases and specifications to guide code transformations that rectify software faults.
State repair strategies, on the other hand, involve altering the execution state at runtime without modifying the program code itself. This can include approaches like reinitialization, checkpoint and rollback, or reconfiguration. Classic techniques in this domain include microrebooting and software rejuvenation. The state repair methodologies often rely on runtime detection of state anomalies or violations of inferred contracts.
The survey also explores empirical studies, which assess the effectiveness and practical applicability of automatic repair techniques. Studies on the correctness and maintainability of machine-generated patches (e.g., Fry et al.) and the exploration of overfitting issues in test-suite based systems reveal vital insights into the challenges faced in this research domain.
Moreover, the paper explores related techniques such as speculative forward engineering for repair and repair suggestion systems. These approaches involve integrating self-repair principles into software design from the outset or providing developers with automatic repair suggestions based on mined data from past debugging sessions or software repositories.
From a theoretical perspective, the survey highlights work on automatic repair that capitalizes on strong formal underpinnings, albeit under assumptions difficult to realize in practice. These theoretical explorations often involve complex formal languages or logical systems that provide robust guarantees of repair correctness but need further scalability and applicability enhancements.
The paper's summarization of diverse repair techniques, combined with its inclusion of numerous empirical investigations, makes it a vital resource for understanding the current state and future directions of automatic software repair research. Future advancements in this field may focus on enhancing the scalability of existing methods, addressing practical deployment challenges, and expanding the contexts in which these repairs can be efficiently applied.
Overall, Monperrus's detailed survey serves as a foundational document for researchers aiming to either enter the field of automatic software repair or those interested in gaining a deeper understanding of its current advancements and challenges. As the field continues to evolve, the synthesis of behavioral and state repair strategies, along with insights from empirical research, will undoubtedly contribute to more sophisticated and robust automated repair systems capable of addressing the complexity of modern software.