Practical Program Repair via Bytecode Mutation (1807.03512v1)

Abstract: Software debugging is tedious, time-consuming, and even error-prone by itself. So, various automated debugging techniques have been proposed in the literature to facilitate the debugging process. Automated Program Repair (APR) is one of the most recent advances in automated debugging, and can directly produce patches for buggy programs with minimal human intervention. Although various advanced APR techniques (including those that are either search-based or semantic-based) have been proposed, the simplistic mutation-based APR technique, which simply uses pre-defined mutation operators (e.g., changing a>=b into a>b) to mutate programs for finding patches, has not yet been thoroughly studied. 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 bytecode mutation. The experimental results show that surprisingly even PraPR with only the basic traditional mutators can produce genuine patches for 18 bugs. Furthermore, with our augmented mutators, PraPR is able to produce genuine patches for 43 bugs, significantly outperforming state-of-the-art APR. It is also an order of magnitude faster, indicating a promising future for bytecode-mutation-based APR.

• The paper introduces PraPR, a novel automated program repair technique that operates directly on JVM bytecode using mutation.
• PraPR successfully generated genuine patches for 43 bugs on the Defects4J dataset, demonstrating significantly higher efficiency and effectiveness compared to other state-of-the-art APR techniques.
• The bytecode-level approach offers potential advantages in efficiency and language applicability across JVM languages, suggesting future research directions for enhancing patch prioritization and validation.

Practical Program Repair via Bytecode Mutation

The paper "Practical Program Repair via Bytecode Mutation" by Ali Ghanbari and Lingming Zhang introduces PraPR, a novel automated program repair (APR) technique operating on JVM bytecode. The paper addresses the tedious nature of debugging software, which consumes substantial development time and resources. Although APR strategies have evolved significantly in recent times, bytecode-level mutation-based approaches have not been extensively studied until now.

Overview

PraPR distinguishes itself by operating at the bytecode level as opposed to the source-code level. The mutation-based approach utilizes traditional mutators, thereby altering program statements to generate potential program patches. The paper hypothesizes the mutations can effectively mimic human debugging strategies, thereby producing patches that are semantically equivalent to those crafted by developers. The research presents an extensive experimental evaluation using the Defects4J bug dataset to validate the effectiveness of PraPR.

Key Findings and Results

The experimental results reveal that PraPR could successfully generate genuine patches for 43 bugs, which is a significant improvement over other APR techniques like CapGen and JAID. Moreover, PraPR achieves this while demonstrating superior efficiency, processing validation tasks at an order of magnitude faster than comparable systems. Specifically, PraPR is able to validate large numbers of candidate patches swiftly due to its bytecode-level operations, circumventing the compilation overhead associated with source-level manipulations.

Implications for Future Research and Practice

PraPR's approach introduces several potential advantages:

• Efficiency: Its bytecode-level execution significantly expedites the patch validation process.
• Applicability: As bytecode is language-independent within JVM, PraPR can potentially be adapted to other JVM-based languages like Kotlin and Scala.
• Expansion: Future research could explore integrating learning-based techniques for enhanced patch prioritization and validation, ultimately reducing the quantity of non-genuine patches.

This work suggests that the simplistic yet practical mutation-based program repair can serve as a baseline to inspire future developments in APR. As bytecode-level repair operates independently of the source-code syntax, it can be adapted for third-party libraries lacking official patches.

Conclusion

The paper underscores the practicality and potential of bytecode mutation as a robust approach to automated program repair, setting the stage for further exploration in bytecode-level manipulations. It draws attention to how bytecode can streamline APR strategies, establishing a promising avenue for advancing debugging technologies while alleviating burdens on human developers.