An analysis of developer metrics for fault prediction

Shinsuke Matsumoto, Yasutaka Kamei, Akito Monden, Ken Ichi Matsumoto, Masahide Nakamura

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

39 Citations (Scopus)

Abstract

Background: Software product metrics have been widely used as independent variables for constructing a fault prediction model. However, fault injection depends not only on characteristics of the products themselves, but also on characteristics of developers involved in the project. Aims: The goal of this paper is to study the effects of developer features on software reliability. Method: This paper proposes developer metrics such as the number of code churns made by each developer, the number of commitments made by each developer and the number of developers for each module. By using the eclipse project dataset, we experimentally analyzed the relationship between the number of faults and developer metrics. Second, the effective of developer metrics for performance improvements of fault prediction models were evaluated. Results: The result revealed that the modules touched by more developer contained more faults. Compared with conventional fault prediction models, developer metrics improved the prediction performance. Conclusions: We conclude that developer metrics are good predictor of faults and we must consider the human factors for improving the software reliability.

Original languageEnglish
Title of host publication6th International Conference on Predictive Models in Software Engineering, PROMISE 2010
DOIs
Publication statusPublished - Dec 10 2010
Externally publishedYes
Event6th International Conference on Predictive Models in Software Engineering, PROMISE 2010 - Timisoara, Romania
Duration: Sep 12 2010Sep 13 2010

Publication series

NameACM International Conference Proceeding Series

Conference

Conference6th International Conference on Predictive Models in Software Engineering, PROMISE 2010
CountryRomania
CityTimisoara
Period9/12/109/13/10

Fingerprint

Software reliability
Human engineering

All Science Journal Classification (ASJC) codes

  • Software
  • Human-Computer Interaction
  • Computer Vision and Pattern Recognition
  • Computer Networks and Communications

Cite this

Matsumoto, S., Kamei, Y., Monden, A., Matsumoto, K. I., & Nakamura, M. (2010). An analysis of developer metrics for fault prediction. In 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010 [18] (ACM International Conference Proceeding Series). https://doi.org/10.1145/1868328.1868356

An analysis of developer metrics for fault prediction. / Matsumoto, Shinsuke; Kamei, Yasutaka; Monden, Akito; Matsumoto, Ken Ichi; Nakamura, Masahide.

6th International Conference on Predictive Models in Software Engineering, PROMISE 2010. 2010. 18 (ACM International Conference Proceeding Series).

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

Matsumoto, S, Kamei, Y, Monden, A, Matsumoto, KI & Nakamura, M 2010, An analysis of developer metrics for fault prediction. in 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010., 18, ACM International Conference Proceeding Series, 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010, Timisoara, Romania, 9/12/10. https://doi.org/10.1145/1868328.1868356
Matsumoto S, Kamei Y, Monden A, Matsumoto KI, Nakamura M. An analysis of developer metrics for fault prediction. In 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010. 2010. 18. (ACM International Conference Proceeding Series). https://doi.org/10.1145/1868328.1868356
Matsumoto, Shinsuke ; Kamei, Yasutaka ; Monden, Akito ; Matsumoto, Ken Ichi ; Nakamura, Masahide. / An analysis of developer metrics for fault prediction. 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010. 2010. (ACM International Conference Proceeding Series).
@inproceedings{d92bc0ecce054bd7a02afd84795b12f8,
title = "An analysis of developer metrics for fault prediction",
abstract = "Background: Software product metrics have been widely used as independent variables for constructing a fault prediction model. However, fault injection depends not only on characteristics of the products themselves, but also on characteristics of developers involved in the project. Aims: The goal of this paper is to study the effects of developer features on software reliability. Method: This paper proposes developer metrics such as the number of code churns made by each developer, the number of commitments made by each developer and the number of developers for each module. By using the eclipse project dataset, we experimentally analyzed the relationship between the number of faults and developer metrics. Second, the effective of developer metrics for performance improvements of fault prediction models were evaluated. Results: The result revealed that the modules touched by more developer contained more faults. Compared with conventional fault prediction models, developer metrics improved the prediction performance. Conclusions: We conclude that developer metrics are good predictor of faults and we must consider the human factors for improving the software reliability.",
author = "Shinsuke Matsumoto and Yasutaka Kamei and Akito Monden and Matsumoto, {Ken Ichi} and Masahide Nakamura",
year = "2010",
month = "12",
day = "10",
doi = "10.1145/1868328.1868356",
language = "English",
isbn = "9781450304047",
series = "ACM International Conference Proceeding Series",
booktitle = "6th International Conference on Predictive Models in Software Engineering, PROMISE 2010",

}

TY - GEN

T1 - An analysis of developer metrics for fault prediction

AU - Matsumoto, Shinsuke

AU - Kamei, Yasutaka

AU - Monden, Akito

AU - Matsumoto, Ken Ichi

AU - Nakamura, Masahide

PY - 2010/12/10

Y1 - 2010/12/10

N2 - Background: Software product metrics have been widely used as independent variables for constructing a fault prediction model. However, fault injection depends not only on characteristics of the products themselves, but also on characteristics of developers involved in the project. Aims: The goal of this paper is to study the effects of developer features on software reliability. Method: This paper proposes developer metrics such as the number of code churns made by each developer, the number of commitments made by each developer and the number of developers for each module. By using the eclipse project dataset, we experimentally analyzed the relationship between the number of faults and developer metrics. Second, the effective of developer metrics for performance improvements of fault prediction models were evaluated. Results: The result revealed that the modules touched by more developer contained more faults. Compared with conventional fault prediction models, developer metrics improved the prediction performance. Conclusions: We conclude that developer metrics are good predictor of faults and we must consider the human factors for improving the software reliability.

AB - Background: Software product metrics have been widely used as independent variables for constructing a fault prediction model. However, fault injection depends not only on characteristics of the products themselves, but also on characteristics of developers involved in the project. Aims: The goal of this paper is to study the effects of developer features on software reliability. Method: This paper proposes developer metrics such as the number of code churns made by each developer, the number of commitments made by each developer and the number of developers for each module. By using the eclipse project dataset, we experimentally analyzed the relationship between the number of faults and developer metrics. Second, the effective of developer metrics for performance improvements of fault prediction models were evaluated. Results: The result revealed that the modules touched by more developer contained more faults. Compared with conventional fault prediction models, developer metrics improved the prediction performance. Conclusions: We conclude that developer metrics are good predictor of faults and we must consider the human factors for improving the software reliability.

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

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

U2 - 10.1145/1868328.1868356

DO - 10.1145/1868328.1868356

M3 - Conference contribution

AN - SCOPUS:78649777129

SN - 9781450304047

T3 - ACM International Conference Proceeding Series

BT - 6th International Conference on Predictive Models in Software Engineering, PROMISE 2010

ER -