How long does a bug survive? An empirical study

Gerardo Canfora, Michele Ceccarelli, Luigi Cerulo, Massimiliano Di Penta

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

12 Citations (Scopus)

Abstract

Corrective maintenance activities (bug fixing) can be performed a long time after a bug introduction, or shortly after it. Such a time interval, i.e., the bug survival time, may depend on many factors, e.g., the bug severity/harmfulness, but also on how likely does the bug manifest itself and how difficult was to fix it. This paper proposes the use of survival analysis aimed at determining the relationship between the risk of not fixing a bug within a given time frame and specific source code constructs-e.g., expression operators or programming language constructs-changed when fixing the bug. We estimate the survival time by extracting, from versioning repositories, changes introducing and fixing bugs, and then correlate such a time-by means of survival models-with the constructs changed during bug-fixing. Results of a study performed on data extracted from the versioning repository of four open source projects-Eclipse, Mozilla, Open LDAP, and Vuze-indicate that long-lived bugs can be characterized by changes to specific code constructs.

Original languageEnglish
Title of host publicationProceedings - Working Conference on Reverse Engineering, WCRE
Pages191-200
Number of pages10
DOIs
Publication statusPublished - 19 Dec 2011
Externally publishedYes
Event18th Working Conference on Reverse Engineering, WCRE 2011 - Limerick, Ireland
Duration: 17 Oct 201120 Oct 2011

Other

Other18th Working Conference on Reverse Engineering, WCRE 2011
CountryIreland
CityLimerick
Period17/10/1120/10/11

Fingerprint

Computer programming languages

Keywords

  • Bug Fixing
  • Empirical Study
  • Survival Analysis

ASJC Scopus subject areas

  • Software

Cite this

Canfora, G., Ceccarelli, M., Cerulo, L., & Di Penta, M. (2011). How long does a bug survive? An empirical study. In Proceedings - Working Conference on Reverse Engineering, WCRE (pp. 191-200). [6079842] https://doi.org/10.1109/WCRE.2011.31

How long does a bug survive? An empirical study. / Canfora, Gerardo; Ceccarelli, Michele; Cerulo, Luigi; Di Penta, Massimiliano.

Proceedings - Working Conference on Reverse Engineering, WCRE. 2011. p. 191-200 6079842.

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

Canfora, G, Ceccarelli, M, Cerulo, L & Di Penta, M 2011, How long does a bug survive? An empirical study. in Proceedings - Working Conference on Reverse Engineering, WCRE., 6079842, pp. 191-200, 18th Working Conference on Reverse Engineering, WCRE 2011, Limerick, Ireland, 17/10/11. https://doi.org/10.1109/WCRE.2011.31
Canfora G, Ceccarelli M, Cerulo L, Di Penta M. How long does a bug survive? An empirical study. In Proceedings - Working Conference on Reverse Engineering, WCRE. 2011. p. 191-200. 6079842 https://doi.org/10.1109/WCRE.2011.31
Canfora, Gerardo ; Ceccarelli, Michele ; Cerulo, Luigi ; Di Penta, Massimiliano. / How long does a bug survive? An empirical study. Proceedings - Working Conference on Reverse Engineering, WCRE. 2011. pp. 191-200
@inproceedings{cbc9444c31ef4ad492ef21a276a8ca13,
title = "How long does a bug survive? An empirical study",
abstract = "Corrective maintenance activities (bug fixing) can be performed a long time after a bug introduction, or shortly after it. Such a time interval, i.e., the bug survival time, may depend on many factors, e.g., the bug severity/harmfulness, but also on how likely does the bug manifest itself and how difficult was to fix it. This paper proposes the use of survival analysis aimed at determining the relationship between the risk of not fixing a bug within a given time frame and specific source code constructs-e.g., expression operators or programming language constructs-changed when fixing the bug. We estimate the survival time by extracting, from versioning repositories, changes introducing and fixing bugs, and then correlate such a time-by means of survival models-with the constructs changed during bug-fixing. Results of a study performed on data extracted from the versioning repository of four open source projects-Eclipse, Mozilla, Open LDAP, and Vuze-indicate that long-lived bugs can be characterized by changes to specific code constructs.",
keywords = "Bug Fixing, Empirical Study, Survival Analysis",
author = "Gerardo Canfora and Michele Ceccarelli and Luigi Cerulo and {Di Penta}, Massimiliano",
year = "2011",
month = "12",
day = "19",
doi = "10.1109/WCRE.2011.31",
language = "English",
isbn = "9780769545820",
pages = "191--200",
booktitle = "Proceedings - Working Conference on Reverse Engineering, WCRE",

}

TY - GEN

T1 - How long does a bug survive? An empirical study

AU - Canfora, Gerardo

AU - Ceccarelli, Michele

AU - Cerulo, Luigi

AU - Di Penta, Massimiliano

PY - 2011/12/19

Y1 - 2011/12/19

N2 - Corrective maintenance activities (bug fixing) can be performed a long time after a bug introduction, or shortly after it. Such a time interval, i.e., the bug survival time, may depend on many factors, e.g., the bug severity/harmfulness, but also on how likely does the bug manifest itself and how difficult was to fix it. This paper proposes the use of survival analysis aimed at determining the relationship between the risk of not fixing a bug within a given time frame and specific source code constructs-e.g., expression operators or programming language constructs-changed when fixing the bug. We estimate the survival time by extracting, from versioning repositories, changes introducing and fixing bugs, and then correlate such a time-by means of survival models-with the constructs changed during bug-fixing. Results of a study performed on data extracted from the versioning repository of four open source projects-Eclipse, Mozilla, Open LDAP, and Vuze-indicate that long-lived bugs can be characterized by changes to specific code constructs.

AB - Corrective maintenance activities (bug fixing) can be performed a long time after a bug introduction, or shortly after it. Such a time interval, i.e., the bug survival time, may depend on many factors, e.g., the bug severity/harmfulness, but also on how likely does the bug manifest itself and how difficult was to fix it. This paper proposes the use of survival analysis aimed at determining the relationship between the risk of not fixing a bug within a given time frame and specific source code constructs-e.g., expression operators or programming language constructs-changed when fixing the bug. We estimate the survival time by extracting, from versioning repositories, changes introducing and fixing bugs, and then correlate such a time-by means of survival models-with the constructs changed during bug-fixing. Results of a study performed on data extracted from the versioning repository of four open source projects-Eclipse, Mozilla, Open LDAP, and Vuze-indicate that long-lived bugs can be characterized by changes to specific code constructs.

KW - Bug Fixing

KW - Empirical Study

KW - Survival Analysis

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

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

U2 - 10.1109/WCRE.2011.31

DO - 10.1109/WCRE.2011.31

M3 - Conference contribution

SN - 9780769545820

SP - 191

EP - 200

BT - Proceedings - Working Conference on Reverse Engineering, WCRE

ER -