Automatically finding patches using genetic programming

Westley Weimer, Thanh Vu Nguyen, Claire Le Goues, Stephanie Forrest

Research output: Chapter in Book/Report/Conference proceedingConference contribution

343 Citations (Scopus)

Abstract

Automatic program repair has been a longstanding goal in software engineering, yet debugging remains a largely manual process. We introduce a fully automated method for locating and repairing bugs in software. The approach works on off-the-shelf legacy applications and does not require formal specifications, program annotations or special coding practices. Once a program fault is discovered, an extended form of genetic programming is used to evolve program variants until one is found that both retains required functionality and also avoids the defect in question. Standard test cases are used to exercise the fault and to encode program requirements. After a successful repair has been discovered, it is minimized using structural differencing algorithms and delta debugging. We describe the proposed method and report experimental results demonstrating that it can successfully repair ten different C programs totaling 63,000 lines in under 200 seconds, on average.

Original languageEnglish (US)
Title of host publication2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009
Pages364-374
Number of pages11
DOIs
StatePublished - Dec 1 2009
Externally publishedYes
Event2009 31st International Conference on Software Engineering, ICSE 2009 - Vancouver, BC, Canada
Duration: May 16 2009May 24 2009

Other

Other2009 31st International Conference on Software Engineering, ICSE 2009
CountryCanada
CityVancouver, BC
Period5/16/095/24/09

Fingerprint

Genetic programming
Repair
Software engineering
Defects

ASJC Scopus subject areas

  • Software

Cite this

Weimer, W., Nguyen, T. V., Le Goues, C., & Forrest, S. (2009). Automatically finding patches using genetic programming. In 2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009 (pp. 364-374). [5070536] https://doi.org/10.1109/ICSE.2009.5070536

Automatically finding patches using genetic programming. / Weimer, Westley; Nguyen, Thanh Vu; Le Goues, Claire; Forrest, Stephanie.

2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009. 2009. p. 364-374 5070536.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Weimer, W, Nguyen, TV, Le Goues, C & Forrest, S 2009, Automatically finding patches using genetic programming. in 2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009., 5070536, pp. 364-374, 2009 31st International Conference on Software Engineering, ICSE 2009, Vancouver, BC, Canada, 5/16/09. https://doi.org/10.1109/ICSE.2009.5070536
Weimer W, Nguyen TV, Le Goues C, Forrest S. Automatically finding patches using genetic programming. In 2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009. 2009. p. 364-374. 5070536 https://doi.org/10.1109/ICSE.2009.5070536
Weimer, Westley ; Nguyen, Thanh Vu ; Le Goues, Claire ; Forrest, Stephanie. / Automatically finding patches using genetic programming. 2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009. 2009. pp. 364-374
@inproceedings{c7a4889e1aa241c6bbad128abff235d4,
title = "Automatically finding patches using genetic programming",
abstract = "Automatic program repair has been a longstanding goal in software engineering, yet debugging remains a largely manual process. We introduce a fully automated method for locating and repairing bugs in software. The approach works on off-the-shelf legacy applications and does not require formal specifications, program annotations or special coding practices. Once a program fault is discovered, an extended form of genetic programming is used to evolve program variants until one is found that both retains required functionality and also avoids the defect in question. Standard test cases are used to exercise the fault and to encode program requirements. After a successful repair has been discovered, it is minimized using structural differencing algorithms and delta debugging. We describe the proposed method and report experimental results demonstrating that it can successfully repair ten different C programs totaling 63,000 lines in under 200 seconds, on average.",
author = "Westley Weimer and Nguyen, {Thanh Vu} and {Le Goues}, Claire and Stephanie Forrest",
year = "2009",
month = "12",
day = "1",
doi = "10.1109/ICSE.2009.5070536",
language = "English (US)",
isbn = "9781424434527",
pages = "364--374",
booktitle = "2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009",

}

TY - GEN

T1 - Automatically finding patches using genetic programming

AU - Weimer, Westley

AU - Nguyen, Thanh Vu

AU - Le Goues, Claire

AU - Forrest, Stephanie

PY - 2009/12/1

Y1 - 2009/12/1

N2 - Automatic program repair has been a longstanding goal in software engineering, yet debugging remains a largely manual process. We introduce a fully automated method for locating and repairing bugs in software. The approach works on off-the-shelf legacy applications and does not require formal specifications, program annotations or special coding practices. Once a program fault is discovered, an extended form of genetic programming is used to evolve program variants until one is found that both retains required functionality and also avoids the defect in question. Standard test cases are used to exercise the fault and to encode program requirements. After a successful repair has been discovered, it is minimized using structural differencing algorithms and delta debugging. We describe the proposed method and report experimental results demonstrating that it can successfully repair ten different C programs totaling 63,000 lines in under 200 seconds, on average.

AB - Automatic program repair has been a longstanding goal in software engineering, yet debugging remains a largely manual process. We introduce a fully automated method for locating and repairing bugs in software. The approach works on off-the-shelf legacy applications and does not require formal specifications, program annotations or special coding practices. Once a program fault is discovered, an extended form of genetic programming is used to evolve program variants until one is found that both retains required functionality and also avoids the defect in question. Standard test cases are used to exercise the fault and to encode program requirements. After a successful repair has been discovered, it is minimized using structural differencing algorithms and delta debugging. We describe the proposed method and report experimental results demonstrating that it can successfully repair ten different C programs totaling 63,000 lines in under 200 seconds, on average.

UR - http://www.scopus.com/inward/record.url?scp=70549112781&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=70549112781&partnerID=8YFLogxK

U2 - 10.1109/ICSE.2009.5070536

DO - 10.1109/ICSE.2009.5070536

M3 - Conference contribution

SN - 9781424434527

SP - 364

EP - 374

BT - 2009 31st International Conference on Software Engineering - Proceedings, ICSE 2009

ER -