Automatic patch generation learned from human-written patches

@article{Kim2013AutomaticPG,
  title={Automatic patch generation learned from human-written patches},
  author={Dongsun Kim and Jaechang Nam and Jaewoo Song and Sunghun Kim},
  journal={2013 35th International Conference on Software Engineering (ICSE)},
  year={2013},
  pages={802-811}
}
Patch generation is an essential software maintenance task because most software systems inevitably have bugs that need to be fixed. [] Key Method In particular, a genetic-programming-based patch generation technique, GenProg, proposed by Weimer et al., has shown promising results. However, these techniques can generate nonsensical patches due to the randomness of their mutation operations. To address this limitation, we propose a novel patch generation approach, Pattern-based Automatic program Repair (Par…

Figures and Tables from this paper

Automatically generated patches as debugging aids: a human study
TLDR
It is observed that high-quality patches significantly improve debugging correctness and such improvements are more obvious for difficult bugs, and debugging time is significantly affected not by debugging aids, but by participant type and the specific bug to fix.
Anti-Patterns for Automatic Program Repairs
TLDR
Two orthogonal approaches are proposed to preserve correct tool-generated patches and filter out only overfitted patches, and some patterns, named anti-patterns, are proposed that can efficiently distinguish correct patches against over fitted patches.
Automated Patch Correctness Assessment: How Far are We?
  • Shangwen Wang, Ming Wen, Hai Jin
  • Computer Science
    2020 35th IEEE/ACM International Conference on Automated Software Engineering (ASE)
  • 2020
TLDR
An integration strategy is designed to first integrate static code features via learning, and then combine with others by the majority voting strategy to enhance the performance of existing patch correctness assessment techniques significantly.
A Closer Look at Real-World Patches
TLDR
It is found that there are opportunities for APR techniques to improve their effectiveness by looking at code elements that have not yet been investigated, and expression-level granularity could reduce search space of finding fix ingredients, where previous studies never explored.
High-Quality Automated Program Repair
  • Manish Motwani
  • Computer Science
    2021 IEEE/ACM 43rd International Conference on Software Engineering: Companion Proceedings (ICSE-Companion)
  • 2021
TLDR
This work proposes to equip APR tools with additional constraints derived from natural-language software artifacts such as bug reports and requirements specifications that describe the bug and intended software behavior but are not typically used by the APR tools.
AVATAR: Fixing Semantic Bugs with Fix Patterns of Static Analysis Violations
TLDR
This study builds the AVATAR APR system, which exploits fix patterns of static analysis violations as ingredients for patch generation, and highlights the relevance of static bug finding tools as indirect contributors of fix ingredients for addressing code defects identified with functional test cases.
Automatic Program Repair as Semantic Suggestions: An Empirical Study
TLDR
This paper believes that by using existing low-cost APR techniques, fast enough to provide real-time feedback, and encouraging the developer to work together with the APR inside the IDE, will allow them to immediately discard proposed fixes deemed inappropriate or prone to reduce maintainability.
Learning to Generate Corrective Patches using Neural Machine Translation
TLDR
This paper proposes Ratchet, a corrective patch generation system using neural machine translation, and shows that Ratchet can generate syntactically valid statements 98.7% of the time, and achieve an F1-measure between 0.41-0.83 with respect to the actual fixes adopted in the code base.
Improving the Correctness of Automated Program Repair
TLDR
This thesis proposes novel APR techniques to repair more bugs correctly, by leveraging human knowledge, so that APR techniques can repair new types of bugs that are not currently targeted by G&V APR techniques.
DirectFix: Looking for Simple Program Repairs
TLDR
This paper presents a novel semantics-based repair method that generates the simplest patch such that the program structure of the buggy program is maximally preserved and fuses fault localization and repair generation into one step.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 42 REFERENCES
A human study of patch maintainability
TLDR
This work presents a human study involving over 150 participants, 32 real-world defects, and 40 distinct patches, and proposes a system wherein machine-generated patches are augmented with synthesized, human-readable documentation that summarizes their effects and context.
A systematic study of automated program repair: Fixing 55 out of 105 bugs for $8 each
TLDR
This paper evaluates GenProg, which uses genetic programming to repair defects in off-the-shelf C programs, and proposes novel algorithmic improvements that allow it to scale to large programs and find repairs 68% more often.
OCAT: object capture-based automated testing
TLDR
This work proposes a novel approach called Object Capture based Automated Testing (OCAT), which captures object instances dynamically from program executions and helps an existing automated test-generation tool, such as a random testing tool, to achieve higher code coverage.
A novel co-evolutionary approach to automatic software bug fixing
  • A. Arcuri, X. Yao
  • Computer Science
    2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence)
  • 2008
TLDR
This paper proposes an evolutionary approach to automate the task of fixing bugs based on co-evolution, in which programs and test cases co- evolve, influencing each other with the aim of fixing the bugs of the programs.
Identifying Linux bug fixing patches
TLDR
This paper proposes an approach that automatically identifies bug fixing patches based on the changes and commit messages recorded in code repositories, and compares it with the keyword-based approach for identifying bug-fixing patches used in the literature.
Mining Repair Actions for Guiding Automated Program Fixing
TLDR
The intuition is that automated program fixing can imitate human-based program fixing, and a method to mine repair actions from software repositories is presented, which enables us to mathematically reason on the automated software repair process.
Lase: Locating and applying systematic edits by learning from examples
TLDR
The results indicate that LASE should help developers in automating systematic editing, as it is the first to do both for nontrivial program edits.
Automatically documenting program changes
TLDR
An automatic technique for synthesizing succinct human-readable documentation for arbitrary program differences is presented, based on a combination of symbolic execution and a novel approach to code summarization, that is suitable for supplementing or replacing 89% of existing log messages that directly describe a code change.
Understanding myths and realities of test-suite evolution
TLDR
The findings show that test repair is just one possible reason for test-suite evolution, whereas most changes involve refactorings, deletions, and additions of test cases, and that existing test-repair techniques that focus exclusively on assertions may have limited practical applicability.
Generating Fixes from Object Behavior Anomalies
TLDR
The new PACHIKA tool leverages differences in program behavior to generate program fixes directly, and automatically summarizes executions to object behavior models, determines differences between passing and failing runs, generates possible fixes, and assesses them via the regression test suite.
...
1
2
3
4
5
...