The original paper is in English. Non-English content has been machine-translated and may contain typographical errors or mistranslations. ex. Some numerals are expressed as "XNUMX".
Copyrights notice
The original paper is in English. Non-English content has been machine-translated and may contain typographical errors or mistranslations. Copyrights notice
Les mesures de complexité de conception, bien que mesurées à partir du code, se sont révélées être de bons prédicteurs de programmes orientés objet sujets aux pannes. Certaines des métriques les plus souvent utilisées sont les métriques Chidamber et Kemerer (CK). Cet article explique comment faire des prédictions précoces de classes orientées objet sujettes aux pannes, en utilisant une approximation UML de trois métriques CK. Tout d’abord, nous présentons une approche simple pour approximer les métriques CK des méthodes pondérées par classe (WMC), de la réponse pour la classe (RFC) et du couplage entre objets (CBO) à l’aide de diagrammes de collaboration UML. Ensuite, nous étudions l'application de deux techniques de normalisation des données. Une telle étude a un double objectif : diminuer l'erreur d'approximation dans la mesure des métriques CK mentionnées à partir de diagrammes UML, et obtenir une distribution de données plus similaire de ces métriques entre les projets logiciels afin que de meilleurs résultats de prédiction soient obtenus en utilisant le même modèle de prédiction dans tous les projets. différents projets logiciels. Enfin, nous construisons trois modèles de prédiction avec le code source d'un package d'un projet logiciel open source (Mylyn d'Eclipse), et nous les testons avec plusieurs autres packages et trois projets logiciels différents de petite taille, en utilisant leurs métriques UML et code à des fins de comparaison. . Les résultats de notre étude empirique nous amènent à conclure que les métriques UML RFC et UML CBO proposées peuvent prédire la prédisposition aux erreurs du code presque avec la même précision que leurs métriques de code respectives. L'élimination des valeurs aberrantes et la procédure de normalisation utilisée ont été d'une grande utilité, non seulement pour permettre à nos métriques UML de prédire la prédisposition du code aux pannes à l'aide d'un modèle de prédiction basé sur le code, mais également pour améliorer les résultats de prédiction de nos modèles dans différents progiciels et projets.
The copyright of the original papers published on this site belongs to IEICE. Unauthorized use of the original or translated papers is prohibited. See IEICE Provisions on Copyright for details.
Copier
Ana Erika CAMARGO CRUZ, Koichiro OCHIMIZU, "A UML Approximation of Three Chidamber-Kemerer Metrics and Their Ability to Predict Faulty Code across Software Projects" in IEICE TRANSACTIONS on Information,
vol. E93-D, no. 11, pp. 3038-3050, November 2010, doi: 10.1587/transinf.E93.D.3038.
Abstract: Design-complexity metrics, while measured from the code, have shown to be good predictors of fault-prone object-oriented programs. Some of the most often used metrics are the Chidamber and Kemerer metrics (CK). This paper discusses how to make early predictions of fault-prone object-oriented classes, using a UML approximation of three CK metrics. First, we present a simple approach to approximate Weighted Methods per Class (WMC), Response For Class (RFC) and Coupling Between Objects (CBO) CK metrics using UML collaboration diagrams. Then, we study the application of two data normalization techniques. Such study has a twofold purpose: to decrease the error approximation in measuring the mentioned CK metrics from UML diagrams, and to obtain a more similar data distribution of these metrics among software projects so that better prediction results are obtained when using the same prediction model across different software projects. Finally, we construct three prediction models with the source code of a package of an open source software project (Mylyn from Eclipse), and we test them with several other packages and three different small size software projects, using their UML and code metrics for comparison. The results of our empirical study lead us to conclude that the proposed UML RFC and UML CBO metrics can predict fault-proneness of code almost with the same accuracy as their respective code metrics do. The elimination of outliers and the normalization procedure used were of great utility, not only for enabling our UML metrics to predict fault-proneness of code using a code-based prediction model but also for improving the prediction results of our models across different software packages and projects.
URL: https://global.ieice.org/en_transactions/information/10.1587/transinf.E93.D.3038/_p
Copier
@ARTICLE{e93-d_11_3038,
author={Ana Erika CAMARGO CRUZ, Koichiro OCHIMIZU, },
journal={IEICE TRANSACTIONS on Information},
title={A UML Approximation of Three Chidamber-Kemerer Metrics and Their Ability to Predict Faulty Code across Software Projects},
year={2010},
volume={E93-D},
number={11},
pages={3038-3050},
abstract={Design-complexity metrics, while measured from the code, have shown to be good predictors of fault-prone object-oriented programs. Some of the most often used metrics are the Chidamber and Kemerer metrics (CK). This paper discusses how to make early predictions of fault-prone object-oriented classes, using a UML approximation of three CK metrics. First, we present a simple approach to approximate Weighted Methods per Class (WMC), Response For Class (RFC) and Coupling Between Objects (CBO) CK metrics using UML collaboration diagrams. Then, we study the application of two data normalization techniques. Such study has a twofold purpose: to decrease the error approximation in measuring the mentioned CK metrics from UML diagrams, and to obtain a more similar data distribution of these metrics among software projects so that better prediction results are obtained when using the same prediction model across different software projects. Finally, we construct three prediction models with the source code of a package of an open source software project (Mylyn from Eclipse), and we test them with several other packages and three different small size software projects, using their UML and code metrics for comparison. The results of our empirical study lead us to conclude that the proposed UML RFC and UML CBO metrics can predict fault-proneness of code almost with the same accuracy as their respective code metrics do. The elimination of outliers and the normalization procedure used were of great utility, not only for enabling our UML metrics to predict fault-proneness of code using a code-based prediction model but also for improving the prediction results of our models across different software packages and projects.},
keywords={},
doi={10.1587/transinf.E93.D.3038},
ISSN={1745-1361},
month={November},}
Copier
TY - JOUR
TI - A UML Approximation of Three Chidamber-Kemerer Metrics and Their Ability to Predict Faulty Code across Software Projects
T2 - IEICE TRANSACTIONS on Information
SP - 3038
EP - 3050
AU - Ana Erika CAMARGO CRUZ
AU - Koichiro OCHIMIZU
PY - 2010
DO - 10.1587/transinf.E93.D.3038
JO - IEICE TRANSACTIONS on Information
SN - 1745-1361
VL - E93-D
IS - 11
JA - IEICE TRANSACTIONS on Information
Y1 - November 2010
AB - Design-complexity metrics, while measured from the code, have shown to be good predictors of fault-prone object-oriented programs. Some of the most often used metrics are the Chidamber and Kemerer metrics (CK). This paper discusses how to make early predictions of fault-prone object-oriented classes, using a UML approximation of three CK metrics. First, we present a simple approach to approximate Weighted Methods per Class (WMC), Response For Class (RFC) and Coupling Between Objects (CBO) CK metrics using UML collaboration diagrams. Then, we study the application of two data normalization techniques. Such study has a twofold purpose: to decrease the error approximation in measuring the mentioned CK metrics from UML diagrams, and to obtain a more similar data distribution of these metrics among software projects so that better prediction results are obtained when using the same prediction model across different software projects. Finally, we construct three prediction models with the source code of a package of an open source software project (Mylyn from Eclipse), and we test them with several other packages and three different small size software projects, using their UML and code metrics for comparison. The results of our empirical study lead us to conclude that the proposed UML RFC and UML CBO metrics can predict fault-proneness of code almost with the same accuracy as their respective code metrics do. The elimination of outliers and the normalization procedure used were of great utility, not only for enabling our UML metrics to predict fault-proneness of code using a code-based prediction model but also for improving the prediction results of our models across different software packages and projects.
ER -