Automatic bug fixing

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

Automatic bug-fixing is the automatic repair of software bugs without the intervention of a human programmer.[1][2] It is also commonly referred to as automatic patch generation, automatic bug repair, or automatic program repair.[3][4] The typical goal of such techniques is to automatically generate correct patches to eliminate bugs in software programs without causing software regression.[5]

Specification[edit]

Automatic bug fixing is made according to a specification of the expected behavior which can be for instance a formal specification or a test suite.[6]

A test-suite – the input/output pairs specify the functionality of the program, possibly captured in assertions can be used as a test oracle to drive the search. This oracle can in fact be divided between the bug oracle that exposes the faulty behavior, and the regression oracle, which encapsulates the functionality any program repair method must preserve. Note that a test suite is typically incomplete and does not cover all possible cases. Therefore, it is often possible for a validated patch to produce expected outputs for all inputs in the test suite but incorrect outputs for other inputs.[7] The existence of such validated but incorrect patches is a major challenge for generate-and-validate techniques.[7] Recent successful automatic bug-fixing techniques often rely on additional information other than the test suite, such as information learned from previous human patches, to further identify correct patches among validated patches.[8]

Another way to specify the expected behavior is to use formal specifications [9][10] Verification against full specifications that specify the whole program behavior including functionalities is less common because such specifications are typically not available in practice and the computation cost of such verification is prohibitive. For specific classes of errors, however, implicit partial specifications are often available. For example, there are targeted bug-fixing techniques validating that the patched program can no longer trigger overflow errors in the same execution path.[11]

Techniques[edit]

Generate-and-validate[edit]

Generate-and-validate approaches compile and test each candidate patch to collect all validated patches that produce expected outputs for all inputs in the test suite.[6][7] Such a technique typically starts with a test suite of the program, i.e., a set of test cases, at least one of which exposes the bug.[6][8][12][13] An early generate-and-validate bug-fixing systems is GenProg.[6] The effectiveness of generate-and-validate techniques remains controversial, because they typically do not provide patch correctness guarantees.[7][14] Nevertheless, the reported results of recent state-of-the-art techniques are generally promising. For example, on systematically collected 69 real world bugs in eight large C software programs, the state-of-the-art bug-fixing system Prophet generates correct patches for 18 out of the 69 bugs.[8]

One way to generate candidate patches is to apply mutation operators on the original program. Mutation operators manipulate the original program, potentially via its abstract syntax tree representation, or a more coarse-grained representation such as operating at the statement-level or block-level. Earlier genetic improvement approaches operate at the statement level and carry out simple delete/replace operations such as deleting an existing statement or replacing an existing statement with another statement in the same source file.[6][15] Recent approaches use more fine-grained operators at the abstract syntax tree level to generate more diverse set of candidate patches.[8][13]

Many generate-and-validate techniques rely on the redundancy insight: the code of the patch can be found elsewhere in the application. This idea was introduced in the Genprog system, where two operators, addition and replacement of AST nodes, were based on code taken from elsewhere (i.e. adding an existing AST node). This idea has been validated empirically, with two independent studies that have shown that a significant proportion of commits (3%-17%) are composed of existing code.[16][17] Beyond the fact that the code to reuse exists somewhere else, it has also been shown that the context of the potential repair ingredients is useful: often, the donor context is similar to the recipient context. [18][19]

Using fix templates is an alternative way to generate candidate patches. Fix templates are typically predefined program mutation rules for fixing specific classes of bugs.[20] Examples of fix templates include inserting a conditional statement to check whether the value of a variable is null to fix null pointer exception, and changing an integer constant by one to fix off-by-one errors.[20] Fix templates are therefore often adopted by targeted techniques.[21] It is also possible to automatically mine fix templates for generate-and-validate approches.[22]

Synthesis-based[edit]

Repair techniques exist that are based on symbolic execution. For example, Semfix[23] uses symbolic execution to extract a repair constraint. Angelix[24] introduced the concept of angelic forest in order to deal with multiline patches.

Under certain assumptions, it is possible to state the repair problem as a synthesis problem. SemFix[23] and Nopol[25] uses component-based synthesis.[26] Dynamoth[27] uses dynamic synthesis.[28] S3[29] is based on syntax-guided synthesis.[30] SearchRepair[31] converts potential patches into an SMT formula and queries candidate patches that allow the patched program to pass all supplied test cases.

Data-driven[edit]

Machine learning techniques can improve the effectiveness of automatic bug-fixing systems.[8] One example of such techniques learns from past successful patches from human developers collected from open source repositories in GitHub and SourceForge.[8] It then use the learned information to recognize and prioritize potentially correct patches among all generated candidate patches.[8] Alternatively, patches can be directly mined from existing sources. Example approaches include mining patches from donor applications[11] or from QA web sites.[32]

SequenceR uses sequence-to-sequence learning on source code in order to generate one-line patches.[33] It defines a neural network architecture that works well with source code, with the copy mechanism that allows to produce patches with tokens that are not in the learned vocabulary. Those tokens are taken from the code of the Java class under repair.

Other[edit]

Targeted automatic bug-fixing techniques generate repairs for specific classes of errors such as null pointer exception[34][35][20] integer overflow ,[11] buffer overflow ,[11] memory leak ,[21] etc.. Such techniques often use empirical fix templates to fix bugs in the targeted scope. For example, insert a conditional statement to check whether the value of a variable is null[20] or insert missing memory deallocation statements.[21] Comparing to generate-and-validate techniques, targeted techniques tend to have better bug-fixing accuracy but a much narrowed scope.[7][21]

Use[edit]

There are multiple uses of automatic bug fixing:

  • in the development environment: when the developer encounters a bug, she activates a feature to search for a patch (for instance by clicking on a button). This search can even happen in the background, when the IDE proactively searches for solutions to potential problems, without waiting for a developer explicit action.[36]
  • in the continuous integration server: when a build fails during continuous, a patch search can be attempted as soon as the build has failed. If the search is successful, the patch is given to the developer before she has started working on it, or before she has found the solution.[37] When a synthesized patch is suggested to the developers as pull-request, an explanation has to be provided in addition to the code changes (eg. a pull request title and description).[38] An experiment has shown that generated patches can be accepted by open-source developers and merged in the code repository.[39]
  • at runtime: when a failure happens at runtime, a binary patch can be searched for and applied online. An example of such a repair system is ClearView,[40] which does repair on x86 code, with x86 binary patches. The Itzal system[41] is different from Clearview: while the repair search happens at runtime, in production, the produced patches are at the source code level. The BikiniProxy system does online repair of Javascript errors happening in the browser.[42]

Search space[edit]

In essence, automatic bug fixing is a search activity, whether deductive-based or heuristic-based. The search space of automatic bug fixing is composed of all edits that can be possibly made to a program. There have been studies to understand the structure of this search space. Qi et al.[43] showed that the original fitness function of Genprog is not better than random search to drive the search. Martinez et al.[44] explored the imbalance between possible repair actions, showing its significant impact on the search. Long et al.'s[45] study indicated that correct patches can be considered as sparse in the search space and that incorrect overfitting patches are vastly more abundant (see also discussion about overfitting below).

If one explicitly enumerates all possible variants in a repair algorithm, this defines a design space for program repair.[46] Each variant selects an algorithm involved at some point in the repair process (eg the fault localization algorithm), or selects a specific heuristic which yields different patches. For instance, in the design space of generate-and-validate program repair, there is one variation point about the granularity of the program elements to be modified: an expression, a statement, a block, etc.[46]

Limitations of automatic bug-fixing[edit]

Automatic bug-fixing techniques that rely on a test suite do not provide patch correctness guarantees, because the test suite is incomplete and does not cover all cases.[7] A weak test suite may cause generate-and-validate techniques to produce validated but incorrect patches that have negative effects such as eliminating desirable functionalities, causing memory leaks, and introducing security vulnerabilities.[7]

Sometimes, in test-suite based program repair, tools generate patches that pass the test suite, yet are actually incorrect, this is known as the "overfitting" problem.[47] "Overfitting" in this context refers to the fact that the patch overfits to the test inputs. There are different kinds of overfitting:[48] incomplete fixing means that only some buggy inputs are fixed, regression introduction means some previously working features are broken after the patch (because they were poorly tested). Early prototypes for automatic repair suffered a lot from overfitting: on the Manybugs C benchmark, Qi et al.[7] reported that 104/110 of plausible GenProg patches were overfitting; on the Defects4J Java benchmark, Martinez et al.[49] reported that 73/84 plausible patches as overfitting. In the context of synthesis-based repair, Le et al.[50] obtained more than 80% of overfitting patches.

Another limitation of generate-and-validate systems is the search space explosion.[45] For a program, there are a large number of statements to change and for each statement there are a large number of possible modifications. State-of-the-art systems address this problem by assuming that a small modification is enough for fixing a bug, resulting in a search space reduction.

The limitation of approaches based on symbolic analysis[23][24] is that real world programs are often converted to intractably large formulas especially for modifying statements with side effects.

Benchmarks[edit]

The benchmark collected by GenProg authors contains 69 real world defects and it is widely used to evaluate many other bug-fixing tools in C as well.[15][8][13][24] The state-of-the-art tool evaluated on GenProg benchmark is Prophet,[8] generating correct patches for 18 out of 69 defects.

In Java, the main benchmark is Defects4J, initially explored by Martinez et al.,[49] and now extensively used in most research papers on program repair for Java.[19][51] Alternative benchmarks exist, such as the Quixbugs benchmark,[52] which contains original bugs for program repair.[53] Other benchmarks of Java bugs include Bugs.jar,[54] based on past commits, and BEARS [55] which is a benchmark of continuous integration build failures.

Example tools[edit]

Automatic bug-fixing is an active research topic in computer science. There are many implementations of various bug-fixing techniques especially for C and Java programs. Note that most of these implementations are research prototypes for demonstrating their techniques, i.e., it is unclear whether their current implementations are ready for industrial usage or not.

C[edit]

  • ClearView:[40] A generate-and-validate tool of generating binary patches for deployed systems. It is evaluated on 10 security vulnerability cases. A later study shows that it generates correct patches for at least 4 of the 10 cases.[7]
  • GenProg:[6][15] A seminal generate-and-validate bug-fixing tool. It has been extensively studied in the context of the ManyBugs benchmark.
  • SemFix:[23] The first solver-based bug-fixing tool for C.
  • CodePhage:[11] The first bug-fixing tool that directly transfer code across programs to generate patch for C program. Note that although it generates C patches, it can extract code from binary programs without source code.[11]
  • LeakFix:[21] A tool that automatically fixes memory leaks in C programs.
  • Prophet:[8] The first generate-and-validate tool that uses machine learning techniques to learn useful knowledge from past human patches to recognize correct patches. It is evaluated on the same benchmark as GenProg and generate correct patches (i.e., equivalent to human patches) for 18 out of 69 cases.[8]
  • SearchRepair:[31] A tool for replacing buggy code using snippets of code from elsewhere. It is evaluated on the IntroClass benchmark[56] and generates much higher quality patches on that benchmark than GenProg, RSRepair, and AE.
  • Angelix:[24] An improved solver-based bug-fixing tool. It is evaluated on the GenProg benchmark. For 10 out of the 69 cases, it generate patches that is equivalent to human patches.

Java[edit]

  • PAR:[20] A generate-and-validate tool that uses a set of manually defined fix templates. A later study raised concerns about the generalizability of the fix templates in PAR.[14]
  • NOPOL:[25] A solver-based tool focusing on modifying condition statements.
  • QACrashFix:[32] A tool that fixes Java crash bugs by mining fixes from Q&A web site.
  • Astor:[57] An automatic repair library for Java, containing jGenProg, a Java implementation of GenProg.
  • NpeFix:[58] An automatic repair tool for NullPointerException in Java, available on Github.

Other languages[edit]

  • AutoFixE:[9] A bug-fixing tool for Eiffel language. It relies the contracts (i.e., a form of formal specification) in Eiffel programs to validate generated patches.

Proprietary[edit]

References[edit]

  1. ^ Rinard, Martin C. (2008). "Technical perspective Patching program errors". Communications of the ACM. 51 (12): 86. doi:10.1145/1409360.1409381.
  2. ^ Harman, Mark (2010). "Automated patching techniques". Communications of the ACM. 53 (5): 108. doi:10.1145/1735223.1735248.
  3. ^ Monperrus, Martin (2018). "Automatic Software Repair". ACM Computing Surveys. 51 (1): 1–24. arXiv:1807.00515. doi:10.1145/3105906.
  4. ^ Gazzola, Luca; Micucci, Daniela; Mariani, Leonardo (2019). "Automatic Software Repair: A Survey" (PDF). IEEE Transactions on Software Engineering. 45 (1): 34–67. doi:10.1109/TSE.2017.2755013.
  5. ^ Tan, Shin Hwei; Roychoudhury, Abhik (2015). "relifix: Automated repair of software regressions". 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering. IEEE. pp. 471–482. doi:10.1109/ICSE.2015.65. ISBN 978-1-4799-1934-5.
  6. ^ a b c d e f Weimer, Westley; Nguyen, ThanhVu; Le Goues, Claire; Forrest, Stephanie (2009). "Automatically finding patches using genetic programming". Proceedings of the 31st International Conference on Software Engineering. IEEE. pp. 364–374. CiteSeerX 10.1.1.147.8995. doi:10.1109/ICSE.2009.5070536. ISBN 978-1-4244-3453-4.
  7. ^ a b c d e f g h i Qi, Zichao; Long, Fan; Achour, Sara; Rinard, Martin (2015). "An Anlysis of Patch Plausibility and Correctness for Generate-and-Validate Patch Generation Systems". Proceedings of the 2015 International Symposium on Software Testing and Analysis. ACM. CiteSeerX 10.1.1.696.5616. doi:10.1145/2771783.2771791. ISBN 978-1-4503-3620-8.
  8. ^ a b c d e f g h i j k Long, Fan; Rinard, Martin (2016). "Automatic patch generation by learning correct code". Proceedings of the 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM. pp. 298–312. doi:10.1145/2837614.2837617. ISBN 978-1-4503-3549-2.
  9. ^ a b Pei, Yu; Furia, Carlo A.; Nordio, Martin; Wei, Yi; Meyer, Bertrand; Zeller, Andreas (May 2014). "Automated Fixing of Programs with Contracts". IEEE Trans. Softw. Eng. 40 (5): 427–449. arXiv:1403.1117. Bibcode:2014arXiv1403.1117P. doi:10.1109/TSE.2014.2312918.
  10. ^ "Contract-based Data Structure Repair Using Alloy". CiteSeerX 10.1.1.182.4390. Cite journal requires |journal= (help)
  11. ^ a b c d e f Sidiroglou, Stelios; Lahtinen, Eric; Long, Fan; Rinard, Martin (2015). "Automatic Error Elimination by Multi-Application Code Transfer". Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation.
  12. ^ Qi, Yuhua; Mao, Xiaoguang; Lei, Yan; Dai, Ziying; Wang, Chengsong (2014). "The Strength of Random Search on Automated Program Repair". Proceedings of the 36th International Conference on Software Engineering. ICSE 2014. Austin, Texas: ACM. pp. 254–265. doi:10.1145/2568225.2568254. ISBN 978-1-4503-2756-5.
  13. ^ a b c Long, Fan; Rinard, Martin (2015). "Staged Program Repair with Condition Synthesis". Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering. ESEC/FSE 2015. Bergamo, Italy: ACM. pp. 166–178. CiteSeerX 10.1.1.696.9059. doi:10.1145/2786805.2786811. ISBN 978-1-4503-3675-8.
  14. ^ a b Monperrus, Martin (2014). "A Critical Review of "Automatic Patch Generation Learned from Human-written Patches": Essay on the Problem Statement and the Evaluation of Automatic Software Repair". Proceedings of the 36th International Conference on Software Engineering. ICSE 2014. New York, New York: ACM. pp. 234–242. arXiv:1408.2103. doi:10.1145/2568225.2568324. ISBN 978-1-4503-2756-5.
  15. ^ a b c Le Goues, Claire; Dewey-Vogt, Michael; Forrest, Stephanie; Weimer, Westley (2012). "A Systematic Study of Automated Program Repair: Fixing 55 out of 105 Bugs for $8 Each". 2012 34th International Conference on Software Engineering (ICSE). IEEE. pp. 3–13. CiteSeerX 10.1.1.661.9690. doi:10.1109/ICSE.2012.6227211. ISBN 978-1-4673-1067-3.
  16. ^ Martinez, Matias; Weimer, Westley; Monperrus, Martin (2014). "Do the fix ingredients already exist? An empirical inquiry into the redundancy assumptions of program repair approaches". Proceedings of the 36th International Conference on Software Engineering. pp. 492–495. arXiv:1403.6322. doi:10.1145/2591062.2591114. ISBN 9781450327688.
  17. ^ Barr, Earl T.; Brun, Yuriy; Devanbu, Premkumar; Harman, Mark; Sarro, Federica (2014). "The plastic surgery hypothesis". Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering - FSE 2014. pp. 306–317. CiteSeerX 10.1.1.646.9678. doi:10.1145/2635868.2635898. ISBN 9781450330565.
  18. ^ White, Martin; Tufano, Michele; Martinez, Matias; Monperrus, Martin; Poshyvanyk, Denys (2019). "Sorting and Transforming Program Repair Ingredients via Deep Learning Code Similarities". IEEE 26th International Conference on Software Analysis, Evolution and Reengineering. IEEE: 479–490. arXiv:1707.04742. doi:10.1109/SANER.2019.8668043. ISBN 978-1-7281-0591-8.
  19. ^ a b Wen, Ming; Chen, Junjie; Wu, Rongxin; Hao, Dan; Cheung, Shing-Chi (2018). "Context-aware patch generation for better automated program repair". Proceedings of the 40th International Conference on Software Engineering - ICSE '18. New York, New York, USA: ACM Press: 1–11. doi:10.1145/3180155.3180233. ISBN 9781450356381.
  20. ^ a b c d e Kim, Dongsun; Nam, Jaechang; Song, Jaewoo; Kim, Sunghun (2013). "Automatic Patch Generation Learned from Human-written Patches". Proceedings of the 2013 International Conference on Software Engineering. ICSE '13'. IEEE Press. pp. 802–811. ISBN 978-1-4673-3076-3.
  21. ^ a b c d e Gao, Qing; Xiong, Yingfei; Mi, Yaqing; Zhang, Lu; Yang, Weikun; Zhou, Zhaoping; Xie, Bing; Mei, Hong (2015). "Safe Memory-leak Fixing for C Programs". Proceedings of the 37th International Conference on Software Engineering – Volume 1. ICSE '15'. Piscataway, New Jersey: IEEE Press. pp. 459–470. ISBN 978-1-4799-1934-5.
  22. ^ Martinez, Matias; Monperrus, Martin (2018), "Ultra-Large Repair Search Space with Automatically Mined Templates: The Cardumen Mode of Astor", Search-Based Software Engineering, Springer International Publishing, pp. 65–86, arXiv:1712.03854, doi:10.1007/978-3-319-99241-9_3, ISBN 9783319992402
  23. ^ a b c d Nguyen, Hoang Duong Thien; Qi, Dawei; Roychoudhury, Abhik; Chandra, Satish (2013). "SemFix: Program Repair via Semantic Analysis". Proceedings of the 2013 International Conference on Software Engineering. ICSE '13'. San Francisco, California: IEEE Press. pp. 772–781. ISBN 978-1-4673-3076-3.
  24. ^ a b c d Mechtaev, Sergey; Yi, Jooyong; Roychoudhury, Abhik (2016). "Angelix: scalable multiline program patch synthesis via symbolic analysis". Proceedings of the 38th International Conference on Software Engineering, ICSE 2016, Austin, Texas, May 14-22, 2016. pp. 691–701.
  25. ^ a b Xuan, Jifeng; Martinez, Matias; DeMarco, Favio; Clément, Maxime; Lamelas, Sebastian; Durieux, Thomas; Le Berre, Daniel; Monperrus, Martin (2016). "Nopol: Automatic Repair of Conditional Statement Bugs in Java Programs". IEEE Transactions on Software Engineering. 43: 34–55. arXiv:1811.04211. doi:10.1109/TSE.2016.2560811.
  26. ^ Jha, Susmit; Gulwani, Sumit; Seshia, Sanjit A.; Tiwari, Ashish (2010-05-01). Oracle-guided component-based program synthesis. ACM. pp. 215–224. doi:10.1145/1806799.1806833. ISBN 9781605587196.
  27. ^ Durieux, Thomas; Monperrus, Martin (2016-05-14). "DynaMoth". DynaMoth: dynamic code synthesis for automatic program repair. pp. 85–91. doi:10.1145/2896921.2896931. ISBN 9781450341516.
  28. ^ Galenson, Joel; Reames, Philip; Bodik, Rastislav; Hartmann, Björn; Sen, Koushik (2014-05-31). CodeHint: dynamic and interactive synthesis of code snippets. ACM. pp. 653–663. doi:10.1145/2568225.2568250. ISBN 9781450327565.
  29. ^ Le, Xuan-Bach D.; Chu, Duc-Hiep; Lo, David; Le Goues, Claire; Visser, Willem (2017-08-21). Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering - ESEC/FSE 2017. ACM. pp. 593–604. doi:10.1145/3106237.3106309. ISBN 9781450351058.
  30. ^ Alur, Rajeev; Bodik, Rastislav; Juniwal, Garvit; Martin, Milo M. K.; Raghothaman, Mukund; Seshia, Sanjit A.; Singh, Rishabh; Solar-Lezama, Armando; Torlak, Emina (2013). Syntax-guided synthesis. 2013 Formal Methods in Computer-Aided Design. IEEE. pp. 1–8. CiteSeerX 10.1.1.377.2829. doi:10.1109/fmcad.2013.6679385. ISBN 9780983567837.
  31. ^ a b Ke, Yalin; Stolee, Kathryn; Le Goues, Claire; Brun, Yuriy (2015). "Repairing Programs with Semantic Code Search". Proceedings of the 2015 30th IEEE/ACM International Conference on Automated Software Engineering. ASE 2015. Lincoln, Nebraska: ACM. pp. 295–306. doi:10.1109/ASE.2015.60. ISBN 978-1-5090-0025-8.
  32. ^ a b Gao, Qing; Zhang, Hansheng; Wang, Jie; Xiong, Yingfei; Zhang, Lu; Mei, Hong (2015). "Fixing Recurring Crash Bugs via Analyzing Q&A Sites". 2015 30th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE. pp. 307–318. doi:10.1109/ASE.2015.81. ISBN 978-1-5090-0025-8.
  33. ^ Chen, Zimin; Kommrusch, Steve James; Tufano, Michele; Pouchet, Louis-Noel; Poshyvanyk, Denys; Monperrus, Martin (2019). "SEQUENCER: Sequence-to-Sequence Learning for End-to-End Program Repair". IEEE Transactions on Software Engineering. doi:10.1109/TSE.2019.2940179. ISSN 0098-5589.
  34. ^ Long, Fan; Sidiroglou-Douskos, Stelios; Rinard, Martin (2014). "Automatic Runtime Error Repair and Containment via Recovery Shepherding". Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. PLDI '14'. New York, New York: ACM. pp. 227–238. doi:10.1145/2594291.2594337. ISBN 978-1-4503-2784-8.
  35. ^ Dobolyi, Kinga; Weimer, Westley (2008). "Changing Java's Semantics for Handling Null Pointer Exceptions". 2008 19th International Symposium on Software Reliability Engineering (ISSRE). pp. 47–56. CiteSeerX 10.1.1.147.6158. doi:10.1109/ISSRE.2008.59.
  36. ^ Muşlu, Kıvanç; Brun, Yuriy; Holmes, Reid; Ernst, Michael D.; Notkin, David; Muşlu, Kıvanç; Brun, Yuriy; Holmes, Reid; Ernst, Michael D.; Notkin, David (19 October 2012). "Speculative analysis of integrated development environment recommendations, Speculative analysis of integrated development environment recommendations". ACM SIGPLAN Notices. 47 (10): 669, 669–682, 682. CiteSeerX 10.1.1.259.6341. doi:10.1145/2384616.2384665. ISSN 0362-1340.
  37. ^ Urli, Simon; Yu, Zhongxing; Seinturier, Lionel; Monperrus, Martin (27 May 2018). "How to design a program repair bot?". How to design a program repair bot?: insights from the repairnator project. pp. 95–104. arXiv:1811.09852. doi:10.1145/3183519.3183540. ISBN 9781450356596.
  38. ^ Monperrus, Martin (2019). "Explainable Software Bot Contributions: Case Study of Automated Bug Fixes". Proceedings of IEEE/ACM International Workshop on Bots in Software Engineering (BotSE). arXiv:1905.02597. Bibcode:2019arXiv190502597M. doi:10.1109/BotSE.2019.00010 (inactive 2019-08-20).
  39. ^ Monperrus, Martin; Urli, Simon; Durieux, Thomas; Martinez, Matias; Baudry, Benoit; Seinturier, Lionel (2019). "Repairnator patches programs automatically". Ubiquity. 2019 (July): 1–12. doi:10.1145/3349589.
  40. ^ a b Perkins, Jeff H.; et al. (2009). "Automatically patching errors in deployed software". Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles. ACM. pp. 87–102. CiteSeerX 10.1.1.157.5877. doi:10.1145/1629575.1629585. ISBN 978-1-60558-752-3.
  41. ^ Durieux, Thomas; Hamadi, Youssef; Monperrus, Martin (May 2017). Production-driven patch generation. 2017 IEEE/ACM 39th International Conference on Software Engineering: New Ideas and Emerging Technologies Results Track (ICSE-NIER). pp. 23–26. arXiv:1812.04475. doi:10.1109/icse-nier.2017.8. ISBN 978-1-5386-2675-7.
  42. ^ Durieux, T.; Hamadi, Y.; Monperrus, M. (2018). Fully Automated HTML and Javascript Rewriting for Constructing a Self-Healing Web Proxy. 2018 IEEE 29th International Symposium on Software Reliability Engineering (ISSRE). pp. 1–12. arXiv:1803.08725. Bibcode:2018arXiv180308725D. doi:10.1109/ISSRE.2018.00012. ISBN 978-1-5386-8321-7.[permanent dead link]
  43. ^ Qi, Yuhua; Mao, Xiaoguang; Lei, Yan; Dai, Ziying; Wang, Chengsong (2014-05-31). The strength of random search on automated program repair. ACM. pp. 254–265. doi:10.1145/2568225.2568254. ISBN 9781450327565.
  44. ^ Martinez, Matias; Monperrus, Martin (2013-11-28). "Mining software repair models for reasoning on the search space of automated program fixing". Empirical Software Engineering. 20 (1): 176–205. arXiv:1311.3414. Bibcode:2013arXiv1311.3414M. doi:10.1007/s10664-013-9282-8. ISSN 1382-3256.
  45. ^ a b Long, Fan; Rinard, Martin (2016). "An Analysis of the Search Spaces for Generate and Validate Patch Generation Systems". Proceedings of the 38th International Conference on Software Engineering. ICSE '16. New York, New York: ACM. pp. 702–713. arXiv:1602.05643. doi:10.1145/2884781.2884872. hdl:1721.1/113656. ISBN 978-1-4503-3900-1.
  46. ^ a b Martinez, Matias; Monperrus, Martin (2019). "Astor: Exploring the design space of generate-and-validate program repair beyond GenProg". Journal of Systems and Software. 151: 65–80. arXiv:1802.03365. doi:10.1016/j.jss.2019.01.069.
  47. ^ Smith, Edward K.; Barr, Earl T.; Le Goues, Claire; Brun, Yuriy (2015). "Is the Cure Worse Than the Disease? Overfitting in Automated Program Repair". Proceedings of the 2015 10th Joint Meeting on Foundations of Software Engineering. ESEC/FSE 2015. New York, New York: ACM. pp. 532–543. doi:10.1145/2786805.2786825. ISBN 978-1-4503-3675-8.
  48. ^ Yu, Zhongxing; Martinez, Matias; Danglot, Benjamin; Durieux, Thomas; Monperrus, Martin (2018). "Alleviating patch overfitting with automatic test generation: a study of feasibility and effectiveness for the Nopol repair system". Empirical Software Engineering. 24: 33–67. arXiv:1810.10614. Bibcode:2018arXiv181010614Y. doi:10.1007/s10664-018-9619-4. ISSN 1382-3256.
  49. ^ a b Martinez, Matias; Durieux, Thomas; Sommerard, Romain; Xuan, Jifeng; Monperrus, Martin (2016-10-25). "Automatic repair of real bugs in java: a large-scale experiment on the defects4j dataset". Empirical Software Engineering. 22 (4): 1936–1964. arXiv:1811.02429. doi:10.1007/s10664-016-9470-4. ISSN 1382-3256.
  50. ^ Le, Xuan Bach D.; Thung, Ferdian; Lo, David; Goues, Claire Le (2018-03-02). "Overfitting in semantics-based automated program repair". Empirical Software Engineering. 23 (5): 3007–3033. doi:10.1007/s10664-017-9577-2. ISSN 1382-3256.
  51. ^ Hua, Jinru; Zhang, Mengshi; Wang, Kaiyuan; Khurshid, Sarfraz (2018). "Towards practical program repair with on-demand candidate generation". Proceedings of the 40th International Conference on Software Engineering - ICSE '18. New York, New York, USA: ACM Press: 12–23. doi:10.1145/3180155.3180245. ISBN 9781450356381.
  52. ^ Lin, Derrick; Koppel, James; Chen, Angela; Solar-Lezama, Armando (2017). "QuixBugs: a multi-lingual program repair benchmark set based on the quixey challenge". Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity - SPLASH Companion 2017. New York, New York, USA: ACM Press: 55–56. doi:10.1145/3135932.3135941. ISBN 9781450355148.
  53. ^ Ye, He; Martinez, Matias; Durieux, Thomas; Monperrus, Martin (2019). "A Comprehensive Study of Automatic Program Repair on the QuixBugs Benchmark". 2019 IEEE 1st International Workshop on Intelligent Bug Fixing (IBF). IEEE: 1–10. arXiv:1805.03454. doi:10.1109/ibf.2019.8665475. ISBN 978-1-7281-1809-3.
  54. ^ Saha, Ripon K.; Lyu, Yingjun; Lam, Wing; Yoshida, Hiroaki; Prasad, Mukul R. (2018). "Bugs.jar: a large-scale, diverse dataset of real-world Java bugs". Proceedings of the 15th International Conference on Mining Software Repositories. MSR '18: 10–13. doi:10.1145/3196398.3196473. ISBN 9781450357166.
  55. ^ Madeiral, Fernanda; Urli, Simon; Maia, Marcelo; Monperrus, Martin (2019). "BEARS: An Extensible Java Bug Benchmark for Automatic Program Repair Studies". 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER). Hangzhou, China: IEEE: 468–478. arXiv:1901.06024. doi:10.1109/SANER.2019.8667991. ISBN 978-1-7281-0591-8.
  56. ^ Le Goues, Claire; Holtschulte, Neal; Smith, Edward; Brun, Yuriy; Devanbu, Premkumar; Forrest, Stephanie; Weimer, Westley (2015). "The Many Bugs and Intro Class Benchmarks for Automated Repair of C Programs". IEEE Transactions on Software Engineering. 41 (12): 1236–1256. doi:10.1109/TSE.2015.2454513.
  57. ^ Martinez, Matias; Monperrus, Martin (2016). "ASTOR: A Program Repair Library for Java" (PDF). Proceedings of ISSTA, Demonstration Track. pp. 441–444. doi:10.1145/2931037.2948705. ISBN 978-1-4503-4390-9.
  58. ^ Durieux, Thomas (2017). "Dynamic Patch Generation for Null Pointer Exceptions Using Metaprogramming". 2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER). pp. 349–358. arXiv:1812.00409. doi:10.1109/SANER.2017.7884635. ISBN 978-1-5090-5501-2.
  59. ^ "AI is coming for your coding job". Sifted. Retrieved 2019-04-15.

External links[edit]