ABC Software Métrique

La métrique logicielle ABC a été introduite par Jerry Fitzpatrick en 1997 pour surmonter les inconvénients du LOC . La métrique définit un score ABC comme un triplet de valeurs qui représentent la taille d'un ensemble d'instructions de code source. Un score ABC est calculé en comptant le nombre d' affectations (A), le nombre de branches (B) et le nombre de conditions (C) dans un programme. Le score ABC peut être appliqué à des méthodes , fonctions , classes , modules ou fichiers individuels au sein d'un programme.

Le score ABC est représenté par un vecteur 3D < Affectations (A), Branches (B), Conditions (C) >. Il peut également être représenté sous forme de valeur scalaire , qui est la grandeur du vecteur < Affectations (A), Branches (B), Conditions (C) >, et est calculé comme suit :

Par convention, une valeur de grandeur ABC est arrondie au dixième le plus proche.

Le concept de mesure de la taille d'un logiciel a été introduit pour la première fois par Maurice Halstead de l'Université Purdue en 1975. Il a suggéré que chaque programme informatique se compose principalement de jetons : opérateurs et opérandes . Il a conclu qu'un décompte du nombre d'opérateurs et d'opérandes uniques nous donne une mesure de la taille du programme. Cependant, cela n'a pas été adopté comme mesure de la taille d'un programme.

Les lignes de code (LOC) étaient une autre mesure populaire de la taille d'un programme. Le LOC n'était pas considéré comme une mesure précise de la taille du programme car même un programme avec des fonctionnalités identiques peut avoir un nombre différent de lignes selon le style de codage.

Une autre mesure appelée mesure du point de fonction (FP) a été introduite pour calculer le nombre de transactions d'entrée et de sortie des utilisateurs. Les calculs du point de fonction ne donnaient pas d'informations sur la fonctionnalité du programme ni sur les routines impliquées dans le programme.

La métrique ABC vise à surmonter les inconvénients des comptages LOC, FP et token (opération et opérande). Cependant, un score FP peut également être utilisé pour compléter un score ABC.

Bien que l'auteur affirme que la métrique ABC mesure la taille, certains pensent qu'elle mesure la complexité. La capacité de la métrique ABC à mesurer la complexité dépend de la manière dont la complexité est définie.

Les trois composantes du score ABC sont définies comme suit :

• Affectation : stockage ou transfert de données dans une variable .
• Branches : une branche de programme explicite en avant hors de portée .
• Conditionnels : test booléen ou logique.

Étant donné que les langages de base tels que C, C++, Java, etc. comportent uniquement des opérations telles que des affectations de variables, des appels de fonctions et des conditions de test, le score ABC comporte ces trois composants.

Si le vecteur ABC est noté ⟨5,11,9⟩ pour une sous-routine , cela signifie que la sous-routine comporte 5 affectations, 11 branches et 9 conditions. À des fins de normalisation, les nombres doivent être placés entre crochets angulaires et écrits dans le même ordre selon la notation ⟨A, B, C⟩ .

Il est souvent plus pratique de comparer les tailles de code source à l'aide d'une valeur scalaire. Les nombres ABC individuels sont distincts, c'est pourquoi, selon Jerry Fitzpatrick, nous considérons que les trois composants sont orthogonaux , ce qui permet de calculer une grandeur ABC scalaire comme indiqué ci-dessus.

Les scores ABC scalaires perdent certains des avantages du vecteur. Au lieu de calculer une magnitude vectorielle, la somme pondérée des vecteurs peut permettre une comparaison de taille plus précise. Les scores scalaires ABC ne doivent pas être présentés sans les vecteurs ABC qui les accompagnent, car les valeurs scalaires ne sont pas la représentation complète de la taille.

Les règles spécifiques de comptage des valeurs des vecteurs ABC doivent être interprétées différemment selon les langues en raison des différences sémantiques entre elles.

Par conséquent, les règles de calcul du vecteur ABC diffèrent légèrement selon le langage. Nous définissons ci-dessous les règles de calcul de la métrique ABC pour C, C++ et Java. Sur la base de ces règles, les règles des autres langages impératifs peuvent être interprétées.

Les règles suivantes donnent le nombre d'affectations, de branches et de conditions dans la métrique ABC pour C :

1. Ajoutez un au nombre d'affectations lorsque :
   • Occurrence d'un opérateur d'affectation ( =, *=, /=, %=, +=, -=, <<=, >>=, &=, !=, ^= ).
   • Occurrence d'un opérateur d'incrémentation ou de décrémentation ( ++, -- ).
2. Ajoutez un au nombre de branches lorsque :
   • Occurrence d'un appel de fonction .
   • Occurrence de toute instruction goto qui a une cible à un niveau d' imbrication plus profond que le niveau du goto.
3. Ajoutez un au nombre de conditions lorsque :
   • Occurrence d'un opérateur conditionnel ( <, >, <=, >=, ==, != ).
   • Occurrence des mots-clés suivants (' else ', ' case ', ' default ', ' ? ').
   • Occurrence d'un opérateur conditionnel unaire .

Les règles suivantes donnent le nombre d'affectations, de branches et de conditions dans la métrique ABC pour C++ :

1. Ajoutez un au nombre d'affectations lorsque :
   • Occurrence d'un opérateur d'affectation (exclure les déclarations de constantes et les affectations de paramètres par défaut ) ( =, *=, /=, %=, +=, -=, <<=, >>=, &=, !=, ^= ).
   • Occurrence d'un opérateur d'incrémentation ou de décrémentation (préfixe ou suffixe) ( ++, -- ).
   • Initialisation d'une variable ou d'un membre de classe non constant .
2. Ajoutez un au nombre de branches lorsque :
   • Occurrence d'un appel de fonction ou d'un appel de méthode de classe.
   • Occurrence de toute instruction goto qui a une cible à un niveau d'imbrication plus profond que le niveau du goto.
   • Occurrence des opérateurs « nouveau » ou « supprimer ».
3. Ajoutez un au nombre de conditions lorsque :
   • Occurrence d'un opérateur conditionnel ( <, >, <=, >=, ==, != ).
   • Occurrence des mots-clés suivants (' else ', ' case ', ' default ', ' ? ', ' try ', ' catch ').
   • Occurrence d'un opérateur conditionnel unaire.

Les règles suivantes donnent le nombre d'affectations, de branches et de conditions dans la métrique ABC pour Java :

1. Ajoutez un au nombre d'affectations lorsque :
   • Occurrence d'un opérateur d'affectation (à l'exclusion des déclarations de constantes et des affectations de paramètres par défaut) ( =, *=, /=, %=, +=, -=, <<=, >>=, &=, !=, ^=, >>>= ).
   • Occurrence d'un opérateur d'incrémentation ou de décrémentation (préfixe ou suffixe) ( ++, -- ).
2. Ajoutez un au nombre de branches lorsque
   • Occurrence d'un appel de fonction ou d'un appel de méthode de classe.
   • Occurrence d'un opérateur « nouveau ».
3. Ajoutez un au nombre de conditions lorsque :
   • Occurrence d'un opérateur conditionnel ( <, >, <=, >=, ==, != ).
   • Occurrence des mots-clés suivants (' else ', ' case ', ' default ', ' ? ', ' try ', ' catch ').
   • Occurrence d'un opérateur conditionnel unaire.

Étant donné que la mesure du score ABC repose sur l'idée que des tâches telles que le stockage de données, la ramification et les tests conditionnels , cette mesure est indépendante du style de codage de l'utilisateur.

Le calcul du score ABC permet d'estimer le temps nécessaire pour terminer un projet. Cela peut être fait en estimant approximativement le score ABC du projet et en calculant le score ABC du programme sur une journée donnée. Le temps nécessaire à l'achèvement du projet peut être obtenu en divisant le score ABC du projet par le score ABC obtenu en une journée.

Le taux de bugs était à l'origine calculé comme le nombre de bugs / LOC . Cependant, le LOC n'est pas une mesure fiable de la taille du programme car il dépend du style de codage. Une façon plus précise de mesurer le taux de bugs est de compter le nombre de bugs / score ABC .

Les programmes écrits dans différents langages peuvent être comparés à l'aide des scores ABC, car la plupart des langages utilisent des affectations, des branches et des instructions conditionnelles.

Les informations sur le nombre de paramètres individuels (nombre d'affectations, de branches et de conditions) peuvent aider à classer le programme comme « fort en données », « fort en fonctions » ou « fort en logique ». La forme vectorielle d'un score ABC peut donner un aperçu des principes directeurs de l' application , alors que les détails sont perdus dans la forme scalaire du score.

Les scores ABC sont linéaires , ce qui signifie que n'importe quel fichier, module, classe, fonction ou méthode peut être noté. Par exemple, le score ABC (vecteur) d'un module est la somme des scores de ses sous-modules. Les scores ABC scalaires, en revanche, ne sont pas linéaires.