Mesure de métriques Halstead avec Testwell CMT++ et CMTJava (outils de mesure de complexité)

liens rapides :

1/ But et origine

Les métriques de complexité Halstead ont été développées par le défunt Maurice Halstead comme un moyen de déterminer une mesure quantitative de complexité directement des opérateurs et opérandes dans le module afin de mesurer la complexité d'un module de programme directement depuis le code source.
Parmi les précurseurs de la métrique de logiciel, ils sont les indicateurs forts de la complexité de code.
Du fait qu'ils soient appliqués au code, ils sont plus souvent utilisés comme une métrique de maintenance. Il est évident que les mesures Halstead sont aussi utiles durant le développement, pour accéder à la qualité du code dans les applications denses.
Puisque l'entretien devrait être un souci pendant le développement, les mesures de Halstead devrait être utilisées durant le développement du code, afin de suivre les tendances de complexité.
Les mesures Halstead ont été introduites en 1977 et ont été utilisées et expérimentées intensivement depuis ce temps-là. Elles font partie des plus vieilles mesures de complexité de programme.

2/ Nombre d'opérateurs et d'opérandes

Les métriques d'Halstead sont basées sur l'interprétation du code comme une séquence de marqueurs, classifiés chacun comme étant un opérateur ou une opérande.

Ainsi on compte :

nombre d'opérateurs uniques (distints)(n1)
nombre d'opérandes uniques (distinctes)(n2)
nombre total d'opérateurs (N1)
nombre total d'opérandes (N2)

Le nombre d'opérateurs et opérandes uniques (n1 et n2), aussi bien que le nombre total d'opérateurs et d'opérandes (N1 et N2) sont calculés en collectant les fréquences de chacun des opérateurs et opérandes pris dans le programme source.

D'autres mesures sont dérivées de ces quatre quantités avec des formules comme décrit plus tard.

2.1 Opérandes

Les marqueurs des catégories suivantes sont toutes comptées comme des opérandes par CMT++ :

IDENTIFIER	Toutes les marques qui ne sont pas des mots réservés
TYPENAME
TYPESPEC	(spécificateurs de type) Mots réservés qui spécifient le type : bool, char, double, float, int, long, short, signed, unsigned, void. Cette classe inclut aussi quelques mots clefs non standards spécifiques de compilateur.
CONSTANT	caractère, nombre, constante ou chaîne de caractères.

2.2 Opérateurs

Les marqueurs des catégories suivantes sont tous comptés comme opérateurs par les directives du préprocesseurs de CMT++ (cependant, les marqueurs asm et this sont comptés comme opérandes) :

SCSPEC	(spécificateurs de classes de stockage) mots réservés qui spécifient la classe de stockage : auto, extern, inlin, register, static, typedef, virtual, mtuable.
TYPE_QUAL	(qualifieurs de type) mots réservés qui qualifient le type : const, friend, volatile.
RESERVED	Autres mots réservés de C++ : asm, break, case, class, continue, default, delete, do, else, enum, for, goto, if, new, operator, private, protected, public, return, sizeof, struct, switch, this, union, while, namespace, using, try, catch, throw, const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, template, explicit, true, false, typename. Cette classe inclut aussi quelques mots clefs non standards spécifiques de compilateur.
OPERATOR	Un des suivants : ! != % %= & && \|\| &= ( ) * *= + ++ += , - -- -= -> . ... / /= : :: < << <<= <= = == > >= >> >>= ? [ ] ^ ^= { } \| \|= ~

Les structures de contrôle suivantes case ...: for (...) if (...) seitch (...) while for (...) et catch (...) sont traitées d'une manière spéciale.
Les ':' ';' et les parenthèses sont considérés comme étant une partie des constructions. Le cas et les ':' ';' ou les for (...) if (...) switch (...) while for (...) et catch (...) et les parenthèses sont comptés ensemble comme un opérateur.

2.3 Autre

COMMENTS

Les commentaires délimités par /* et */ ou // et les nouvelles lignes n'appartiennent pas à l'ensemble de marques de C++, mais ils sont comptés par CMT++.

3/ Mesure d'Halstead dérivé du nombre d'unique et du nombre total d'opérandes et opérateurs

Le nombre d'opérateurs et opérandes uniques (n1 et n2), aussi bien que le nombre total d'opérateurs et opérandes (N1 et N2) sont calculés en collectant les fréquences de chaque opérateur et opérande trouvé dans le programme source.
Toutes les autres mesures d'Halstead sont dérivées des quatre quantités utilisant l'ensemble suivant de formules.

3.1 Longueur du programme (N)

La longueur du programme (N) est la somme du nombre total d'opérateurs and opérandes du programme :

N = N1 + N2

3.2 Taille du vocabulaire (n)

La taille du vocabulaire (n) est la somme du nombre d'opérateurs and opérandes unique :

n = n1 + n2

3.3 Volume du programme (V)

Le volume du programme (V) est le contenu de l'information du programme, mesuré en bits mathématiques. Il est calculé avec la longueur du programme multipliée par le logarythme 2 de la taille du vocabulaire (n) :

V = N * log2(n)

Le volume d'Halstead (V) décrit la taille de l'implémentation d'un algorithme. Le calcul de V est basé sur le nombre d'opérations effectuées et d'opérandes gérées dans l'algorithme. Par conséquent V est moins sensible à la disposition du code que les mesures de lignes de code.

Le volume d'une fonction devrait être au moins de 20 et au plus de 1000. Le volume d'une fonction, d'une ligne et sans paramètre, qui n'est pas vide est d'environ 20. Un volume plus grand que 1000 indique de la fonction comporte probablement trop de choses.

Le volume d'un fichier devrait être d'au moins 100 et au plus 8000. Ces limites sont basées sur les volumes mesurés pour les fichiers pour lesquels LOCpro et v(G) sont près de leurs limites recommandées. Les limites de volume peuvent être utilisées pour une double vérification.

3.4 Niveau de difficulté (D)

Le niveau de difficulté ou propension d'erreurs du programme est proportionnel au nombre d'opérateurs uniques dans le programme.
D est aussi proportionnel au ratio entre le nombre total d' opérandes et le nombre d'opérandes uniques (ex : si les mêmes opérandes sont utilisées plusieurs fois dans le programme, il est plus enclin aux erreurs).

D = ( n1 / 2 ) * ( N2 / n2 )

3.5 Niveau de programme (L)

Le niveau de programme (L) est l'inverse de la propension d'erreurs du programme
Ex : un programme de bas niveau est plus enclin aux erreurs qu'un programme de haut niveau.

L = 1 / D

3.6 Effort à l'implémentation (E)

L'effort à l'implementation (E) ou la compréhension d'un programme est proportionnel au volume et au niveau de difficulté du programme.

E = V * D

3.7 Temps pour implémenter (T)

Le temps pour implémenter ou comprendre un programme (T) est proportionnel à l'effort. Des expérimentations empiriques peuvent être utilisées pour le calibrage de cette quantité.
Halstead a découvert que diviser l'effort par 18 donne une approximation pour le temps en secondes.

T = E / 18

3.8 Nombre de bugs fournis (B)

Le nombre de bugs fournis (B) corrèle avec la complexité globale du logiciel.
Halstead donne la formule suivante pour B :

B = ( E ** (2/3) ) / 3000 ** correspond " à l'exposant"

Les bugs livrés d'Halstead sont une estimation du nombre d'erreurs dans l'implémentation.
Les bugs livrés dans un fichier devraient être moins de 2. Des expériences ont montrées que, quand on programme en C ou C++, un fichier source contient presque toujours plus d'erreurs que B ne suggère. Le nombre de défaut tend à grandir plus rapidement que B.

Quand le test de dynamique est concerné, la métrique de Halstead la plus importante est le nombre de bugs livrés. Ce nombre approche le nombre d'erreurs dans un module. Comme objectif, au moins autant d'erreurs que B indique devraient être trouvées pendant le test du module.

4/ Autres métriques-"CMT" mentionnées dans ce document

LOCpro
LOCpro est une métrique de ligne de code, qui montre le nombre de lignes de programme (déclarations, définitions, directives, et code).
Plus sur les métriques de lignes de code.

v(G)
Le nombre cyclomatic de McCabe v(G) montre la complexité du flux de contrôle dans une partie du code. v(G) est le nombre de branches conditionnelles dans l'organigramme.
Plus sur les métriques McCabe.

Davantage d'informations sur nos outils de mesure de complexité :

Testwell CMT++/CMTJava

last updated: 05.06.2010