Loading…

Do automated program repair techniques repair hard and important bugs?

Existing evaluations of automated repair techniques focus on the fraction of the defects for which the technique can produce a patch, the time needed to produce patches, and how well patches generalize to the intended specification. However, these evaluations have not focused on the applicability of...

Full description

Saved in:
Bibliographic Details
Published in:Empirical software engineering : an international journal 2018-10, Vol.23 (5), p.2901-2947
Main Authors: Motwani, Manish, Sankaranarayanan, Sandhya, Just, René, Brun, Yuriy
Format: Article
Language:English
Subjects:
Citations: Items that this one cites
Items that cite this one
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by cdi_FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13
cites cdi_FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13
container_end_page 2947
container_issue 5
container_start_page 2901
container_title Empirical software engineering : an international journal
container_volume 23
creator Motwani, Manish
Sankaranarayanan, Sandhya
Just, René
Brun, Yuriy
description Existing evaluations of automated repair techniques focus on the fraction of the defects for which the technique can produce a patch, the time needed to produce patches, and how well patches generalize to the intended specification. However, these evaluations have not focused on the applicability of repair techniques and the characteristics of the defects that these techniques can repair. Questions such as “Can automated repair techniques repair defects that are hard for developers to repair?” and “Are automated repair techniques less likely to repair defects that involve loops?” have not, as of yet, been answered. To address such questions, we annotate two large benchmarks totaling 409 C and Java defects in real-world software, ranging from 22K to 2.8M lines of code, with measures of the defect’s importance, the developer-written patch’s complexity, and the quality of the test suite. We then analyze relationships between these measures and the ability to produce patches for the defects of seven automated repair techniques —AE, GenProg, Kali, Nopol, Prophet, SPR, and TrpAutoRepair. We find that automated repair techniques are less likely to produce patches for defects that required developers to write a lot of code or edit many files, or that have many tests relevant to the defect. Java techniques are more likely to produce patches for high-priority defects. Neither the time it took developers to fix a defect nor the test suite’s coverage correlate with the automated repair techniques’ ability to produce patches. Finally, automated repair techniques are less capable of fixing defects that require developers to add loops and new function calls, or to change method signatures. These findings identify strengths and shortcomings of the state-of-the-art of automated program repair along new dimensions. The presented methodology can drive research toward improving the applicability of automated repair techniques to hard and important bugs.
doi_str_mv 10.1007/s10664-017-9550-0
format article
fullrecord <record><control><sourceid>proquest_cross</sourceid><recordid>TN_cdi_proquest_journals_2075614666</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2075614666</sourcerecordid><originalsourceid>FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13</originalsourceid><addsrcrecordid>eNp1kE9PwzAMxSMEEmPwAbhV4hywkyZpTggNNpAmcYFzlLbp1on-IUkPfHsyFcSJky37PfvpR8g1wi0CqLuAIGVOARXVQgCFE7JAoThVEuVp6nnBKGdCnpOLEA4AoFUuFmT9OGR2ikNno6uz0Q87b7vMu9G2Pouu2vft5-TC72RvfZ3Zvs7abhx8tH3MymkX7i_JWWM_grv6qUvyvn56Wz3T7evmZfWwpRWXOlLOrXSF5thgoRtZV4g1d4w3TuUgHGukhlJZ7Qp0vFSyTEtkyllVlVVeIl-Sm_luSnrMFc1hmHyfXhoGSkjMpZRJhbOq8kMI3jVm9G1n_ZdBMEdcZsZlEi5zxGUgedjsCUnb75z_u_y_6RsIBmz9</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2075614666</pqid></control><display><type>article</type><title>Do automated program repair techniques repair hard and important bugs?</title><source>Springer Nature</source><creator>Motwani, Manish ; Sankaranarayanan, Sandhya ; Just, René ; Brun, Yuriy</creator><creatorcontrib>Motwani, Manish ; Sankaranarayanan, Sandhya ; Just, René ; Brun, Yuriy</creatorcontrib><description>Existing evaluations of automated repair techniques focus on the fraction of the defects for which the technique can produce a patch, the time needed to produce patches, and how well patches generalize to the intended specification. However, these evaluations have not focused on the applicability of repair techniques and the characteristics of the defects that these techniques can repair. Questions such as “Can automated repair techniques repair defects that are hard for developers to repair?” and “Are automated repair techniques less likely to repair defects that involve loops?” have not, as of yet, been answered. To address such questions, we annotate two large benchmarks totaling 409 C and Java defects in real-world software, ranging from 22K to 2.8M lines of code, with measures of the defect’s importance, the developer-written patch’s complexity, and the quality of the test suite. We then analyze relationships between these measures and the ability to produce patches for the defects of seven automated repair techniques —AE, GenProg, Kali, Nopol, Prophet, SPR, and TrpAutoRepair. We find that automated repair techniques are less likely to produce patches for defects that required developers to write a lot of code or edit many files, or that have many tests relevant to the defect. Java techniques are more likely to produce patches for high-priority defects. Neither the time it took developers to fix a defect nor the test suite’s coverage correlate with the automated repair techniques’ ability to produce patches. Finally, automated repair techniques are less capable of fixing defects that require developers to add loops and new function calls, or to change method signatures. These findings identify strengths and shortcomings of the state-of-the-art of automated program repair along new dimensions. The presented methodology can drive research toward improving the applicability of automated repair techniques to hard and important bugs.</description><identifier>ISSN: 1382-3256</identifier><identifier>EISSN: 1573-7616</identifier><identifier>DOI: 10.1007/s10664-017-9550-0</identifier><language>eng</language><publisher>New York: Springer US</publisher><subject>Automation ; Compilers ; Computer programming ; Computer Science ; Defects ; Interpreters ; Patches (structures) ; Programming Languages ; Repair ; Repair &amp; maintenance ; Software Engineering/Programming and Operating Systems</subject><ispartof>Empirical software engineering : an international journal, 2018-10, Vol.23 (5), p.2901-2947</ispartof><rights>Springer Science+Business Media, LLC 2017</rights><rights>Copyright Springer Science &amp; Business Media 2018</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><citedby>FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13</citedby><cites>FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13</cites><orcidid>0000-0001-5129-3980 ; 0000-0003-3027-7986</orcidid></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>Motwani, Manish</creatorcontrib><creatorcontrib>Sankaranarayanan, Sandhya</creatorcontrib><creatorcontrib>Just, René</creatorcontrib><creatorcontrib>Brun, Yuriy</creatorcontrib><title>Do automated program repair techniques repair hard and important bugs?</title><title>Empirical software engineering : an international journal</title><addtitle>Empir Software Eng</addtitle><description>Existing evaluations of automated repair techniques focus on the fraction of the defects for which the technique can produce a patch, the time needed to produce patches, and how well patches generalize to the intended specification. However, these evaluations have not focused on the applicability of repair techniques and the characteristics of the defects that these techniques can repair. Questions such as “Can automated repair techniques repair defects that are hard for developers to repair?” and “Are automated repair techniques less likely to repair defects that involve loops?” have not, as of yet, been answered. To address such questions, we annotate two large benchmarks totaling 409 C and Java defects in real-world software, ranging from 22K to 2.8M lines of code, with measures of the defect’s importance, the developer-written patch’s complexity, and the quality of the test suite. We then analyze relationships between these measures and the ability to produce patches for the defects of seven automated repair techniques —AE, GenProg, Kali, Nopol, Prophet, SPR, and TrpAutoRepair. We find that automated repair techniques are less likely to produce patches for defects that required developers to write a lot of code or edit many files, or that have many tests relevant to the defect. Java techniques are more likely to produce patches for high-priority defects. Neither the time it took developers to fix a defect nor the test suite’s coverage correlate with the automated repair techniques’ ability to produce patches. Finally, automated repair techniques are less capable of fixing defects that require developers to add loops and new function calls, or to change method signatures. These findings identify strengths and shortcomings of the state-of-the-art of automated program repair along new dimensions. The presented methodology can drive research toward improving the applicability of automated repair techniques to hard and important bugs.</description><subject>Automation</subject><subject>Compilers</subject><subject>Computer programming</subject><subject>Computer Science</subject><subject>Defects</subject><subject>Interpreters</subject><subject>Patches (structures)</subject><subject>Programming Languages</subject><subject>Repair</subject><subject>Repair &amp; maintenance</subject><subject>Software Engineering/Programming and Operating Systems</subject><issn>1382-3256</issn><issn>1573-7616</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2018</creationdate><recordtype>article</recordtype><recordid>eNp1kE9PwzAMxSMEEmPwAbhV4hywkyZpTggNNpAmcYFzlLbp1on-IUkPfHsyFcSJky37PfvpR8g1wi0CqLuAIGVOARXVQgCFE7JAoThVEuVp6nnBKGdCnpOLEA4AoFUuFmT9OGR2ikNno6uz0Q87b7vMu9G2Pouu2vft5-TC72RvfZ3Zvs7abhx8tH3MymkX7i_JWWM_grv6qUvyvn56Wz3T7evmZfWwpRWXOlLOrXSF5thgoRtZV4g1d4w3TuUgHGukhlJZ7Qp0vFSyTEtkyllVlVVeIl-Sm_luSnrMFc1hmHyfXhoGSkjMpZRJhbOq8kMI3jVm9G1n_ZdBMEdcZsZlEi5zxGUgedjsCUnb75z_u_y_6RsIBmz9</recordid><startdate>20181001</startdate><enddate>20181001</enddate><creator>Motwani, Manish</creator><creator>Sankaranarayanan, Sandhya</creator><creator>Just, René</creator><creator>Brun, Yuriy</creator><general>Springer US</general><general>Springer Nature B.V</general><scope>AAYXX</scope><scope>CITATION</scope><scope>7SC</scope><scope>8FD</scope><scope>JQ2</scope><scope>L7M</scope><scope>L~C</scope><scope>L~D</scope><orcidid>https://orcid.org/0000-0001-5129-3980</orcidid><orcidid>https://orcid.org/0000-0003-3027-7986</orcidid></search><sort><creationdate>20181001</creationdate><title>Do automated program repair techniques repair hard and important bugs?</title><author>Motwani, Manish ; Sankaranarayanan, Sandhya ; Just, René ; Brun, Yuriy</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2018</creationdate><topic>Automation</topic><topic>Compilers</topic><topic>Computer programming</topic><topic>Computer Science</topic><topic>Defects</topic><topic>Interpreters</topic><topic>Patches (structures)</topic><topic>Programming Languages</topic><topic>Repair</topic><topic>Repair &amp; maintenance</topic><topic>Software Engineering/Programming and Operating Systems</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Motwani, Manish</creatorcontrib><creatorcontrib>Sankaranarayanan, Sandhya</creatorcontrib><creatorcontrib>Just, René</creatorcontrib><creatorcontrib>Brun, Yuriy</creatorcontrib><collection>CrossRef</collection><collection>Computer and Information Systems Abstracts</collection><collection>Technology Research Database</collection><collection>ProQuest Computer Science Collection</collection><collection>Advanced Technologies Database with Aerospace</collection><collection>Computer and Information Systems Abstracts – Academic</collection><collection>Computer and Information Systems Abstracts Professional</collection><jtitle>Empirical software engineering : an international journal</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Motwani, Manish</au><au>Sankaranarayanan, Sandhya</au><au>Just, René</au><au>Brun, Yuriy</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Do automated program repair techniques repair hard and important bugs?</atitle><jtitle>Empirical software engineering : an international journal</jtitle><stitle>Empir Software Eng</stitle><date>2018-10-01</date><risdate>2018</risdate><volume>23</volume><issue>5</issue><spage>2901</spage><epage>2947</epage><pages>2901-2947</pages><issn>1382-3256</issn><eissn>1573-7616</eissn><abstract>Existing evaluations of automated repair techniques focus on the fraction of the defects for which the technique can produce a patch, the time needed to produce patches, and how well patches generalize to the intended specification. However, these evaluations have not focused on the applicability of repair techniques and the characteristics of the defects that these techniques can repair. Questions such as “Can automated repair techniques repair defects that are hard for developers to repair?” and “Are automated repair techniques less likely to repair defects that involve loops?” have not, as of yet, been answered. To address such questions, we annotate two large benchmarks totaling 409 C and Java defects in real-world software, ranging from 22K to 2.8M lines of code, with measures of the defect’s importance, the developer-written patch’s complexity, and the quality of the test suite. We then analyze relationships between these measures and the ability to produce patches for the defects of seven automated repair techniques —AE, GenProg, Kali, Nopol, Prophet, SPR, and TrpAutoRepair. We find that automated repair techniques are less likely to produce patches for defects that required developers to write a lot of code or edit many files, or that have many tests relevant to the defect. Java techniques are more likely to produce patches for high-priority defects. Neither the time it took developers to fix a defect nor the test suite’s coverage correlate with the automated repair techniques’ ability to produce patches. Finally, automated repair techniques are less capable of fixing defects that require developers to add loops and new function calls, or to change method signatures. These findings identify strengths and shortcomings of the state-of-the-art of automated program repair along new dimensions. The presented methodology can drive research toward improving the applicability of automated repair techniques to hard and important bugs.</abstract><cop>New York</cop><pub>Springer US</pub><doi>10.1007/s10664-017-9550-0</doi><tpages>47</tpages><orcidid>https://orcid.org/0000-0001-5129-3980</orcidid><orcidid>https://orcid.org/0000-0003-3027-7986</orcidid></addata></record>
fulltext fulltext
identifier ISSN: 1382-3256
ispartof Empirical software engineering : an international journal, 2018-10, Vol.23 (5), p.2901-2947
issn 1382-3256
1573-7616
language eng
recordid cdi_proquest_journals_2075614666
source Springer Nature
subjects Automation
Compilers
Computer programming
Computer Science
Defects
Interpreters
Patches (structures)
Programming Languages
Repair
Repair & maintenance
Software Engineering/Programming and Operating Systems
title Do automated program repair techniques repair hard and important bugs?
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-05T09%3A21%3A26IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_cross&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Do%20automated%20program%20repair%20techniques%20repair%20hard%20and%20important%20bugs?&rft.jtitle=Empirical%20software%20engineering%20:%20an%20international%20journal&rft.au=Motwani,%20Manish&rft.date=2018-10-01&rft.volume=23&rft.issue=5&rft.spage=2901&rft.epage=2947&rft.pages=2901-2947&rft.issn=1382-3256&rft.eissn=1573-7616&rft_id=info:doi/10.1007/s10664-017-9550-0&rft_dat=%3Cproquest_cross%3E2075614666%3C/proquest_cross%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-c369t-33a6e8931f189f6dc11d3e23fe7405e2f690b7a9e81e3b76b3e2127ea7cbc4b13%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_pqid=2075614666&rft_id=info:pmid/&rfr_iscdi=true