Gammes de complexité cyclomatique [fermé]

27

Quelles sont les catégories de complexité cyclomatique? Par exemple:

1-5: facile à entretenir
6-10: difficile
11-15: très difficile
20+: approche impossible

Depuis des années, je suis parti de l'hypothèse que 10 était la limite. Et tout ce qui est au-delà est mauvais. J'analyse une solution et j'essaie de déterminer la qualité du code. Certes, la complexité cyclomatique n'est pas la seule mesure, mais elle peut aider. Il existe des méthodes avec une complexité cyclomatique de 200+. Je sais que c'est terrible, mais je suis curieux de connaître les plages inférieures, comme dans mon exemple ci-dessus.

J'ai trouvé ceci :

Les valeurs de référence susmentionnées de Carnegie Mellon définissent quatre plages approximatives pour les valeurs de complexité cyclomatique:

  • les méthodes entre 1 et 10 sont considérées comme simples et faciles à comprendre
  • les valeurs comprises entre 10 et 20 indiquent un code plus complexe, qui peut encore être compréhensible; cependant les tests deviennent plus difficiles à cause du plus grand nombre de branches possibles que le code peut prendre
  • les valeurs de 20 et plus sont typiques du code avec un très grand nombre de chemins d'exécution potentiels et ne peuvent être entièrement saisies et testées qu'avec beaucoup de difficulté et d'efforts
  • les méthodes allant encore plus haut, par exemple> 50, sont certainement irréalisables

Lors de l'exécution de métriques de code pour une solution, les résultats apparaissent en vert pour tout ce qui est inférieur à 25. Je ne suis pas d'accord avec cela, mais j'espérais obtenir d'autres entrées.

Existe-t-il une liste de plages généralement acceptées pour la complexité cyclomatique?

design programming-practices metrics Bob Horn
la source
2
Vous avez trouvé des données du Software Engineering Institute, une organisation reconnue comme un chef de file en génie logiciel. Je ne comprends pas votre question - vous avez trouvé une liste de plages de complexité cyclomatique. Que cherchez-vous d'autre?
Thomas Owens
1
J'ai vu différentes gammes; ce n'était qu'un exemple. Et MS montre « vert » pour quoi que ce soit moins de 25 ans , je me demandais s'il y avait une liste de gamme acceptée. Je l'ai peut-être trouvé alors.
Bob Horn
1
Je suis d'accord avec @ThomasOwens, mais je suis content que vous ayez posé cette question. Je l'ai voté à la fois comme une question et comme une réponse.
Evorlor
1
Dans la 2e édition du Code Complete de Steve McConnell, il recommande qu'une complexité cyclomatique de 0 à 5 soit généralement correcte, mais vous devez savoir si la complexité commence à se situer dans la plage de 6 à 10. Il explique en outre que tout ce qui dépasse une complexité de 10, vous devriez sérieusement envisager de refactoriser votre code.
GibboK

Réponses:

19

Je suppose que cela dépend des capacités de votre personnel de programmation et en grande partie de votre sensibilité en tant que gestionnaire.

Certains programmeurs sont de fervents défenseurs du TDD et n'écriront aucun code sans avoir d'abord écrit un test unitaire. D'autres programmeurs sont parfaitement capables de créer des programmes parfaitement bons et sans bogue sans écrire un seul test unitaire. Le niveau de complexité cyclomatique que chaque groupe peut tolérer va très certainement varier considérablement.

C'est une métrique subjective; évaluez le paramètre de votre solution Code Metrics et ajustez-le à un endroit idéal avec lequel vous vous sentez à l'aise et qui vous donne des résultats raisonnables.

Robert Harvey
la source
3
D'accord, cela dépend en outre de la cause de la complexité. Une grande instruction switch qui appelle d'autres fonctions, dans le cadre d'une machine à états ou quelque chose de similaire, peut avoir une complexité très élevée, même si elle est potentiellement triviale à comprendre.
whatsisname
1
Les grandes instructions de commutation ne sont-elles pas généralement une indication d'un manque de principes de POO, tels que le polymorphisme? Les machines d'état peuvent être implémentées de manière élégante, avec des modèles de POO ou de conception. Non?
Bob Horn
3
Pour certains problèmes, «l'élégance» est utile, pour d'autres, cela rend les choses plus confuses. Il n'y a pas de solution miracle.
whatsisname
1
-1 Pour "D'autres programmeurs sont parfaitement capables de créer des programmes parfaitement bons et sans bogues sans écrire un seul test unitaire." Vous ne pouvez pas connaître son bug sans l'avoir testé.
Sebastien
1
@Sebastien: L'absence de tests unitaires ne signifie pas qu'il n'est pas testé. Et oui, si vous êtes assez bon, il est absolument possible d'écrire du code sans bug sans test ni test de fumée rudimentaire. Certes, ces gens sont une race rare.
Robert Harvey
10

Il n'y a pas de catégories prédéfinies et aucune catégorisation ne serait possible pour plusieurs raisons:

  1. Certaines techniques de refactoring déplacent simplement la complexité d'un point à un autre (pas de votre code vers le framework ou une bibliothèque externe bien testée, mais d'un emplacement à un autre de la base de code). Cela aide à réduire la complexité cyclomatique et à convaincre votre patron (ou toute personne qui aime les présentations avec des graphiques en constante augmentation) que vous avez passé votre temps à créer quelque chose de génial, mais le code reste aussi mauvais qu'il l'était auparavant.

  2. Au contraire, parfois, lorsque vous refactorisez un projet en appliquant des modèles de conception et de programmation, la complexité cyclomatique peut empirer, tandis que le code refactorisé devrait être clair: les développeurs connaissent les modèles de programmation (au moins, ils sont censés les connaître), il simplifie donc le code pour eux, mais la complexité cyclomatique n'en tient pas compte.

  3. Certaines autres techniques de non-refactoring n'affectent pas du tout la complexité cyclomatique, tout en diminuant fortement la complexité d'un code pour les développeurs. Exemples: ajout de commentaires ou de documentation pertinents. "Moderniser" le code en utilisant du sucre syntaxique.

  4. Il y a simplement des cas où la complexité cyclomatique n'est pas pertinente. J'aime l'exemple donné par whatsisname dans son commentaire : certaines grandes switchdéclarations peuvent être extrêmement claires et les réécrire d'une manière plus OOPy ne serait pas très utile (et compliquerait la compréhension du code par les débutants). En même temps, ces déclarations sont un désastre, en termes de complexité cyclomatique.

  5. Comme Robert Harvey l'a déjà dit plus haut , cela dépend de l'équipe elle-même.

En pratique, j'ai vu du code source qui avait une bonne complexité cyclomatique, mais qui était terrible. En même temps, j'ai vu du code à haute complexité cyclomatique, mais je n'ai pas eu trop de mal à le comprendre.

C'est juste qu'il n'y a pas et qu'il ne pourrait pas y avoir d'outil qui indiquerait parfaitement le bien ou le mal d'un morceau de code donné ou sa facilité de maintenance . Comme vous ne pouvez pas programmer une application qui dira qu'une peinture donnée est un chef-d'œuvre et qu'une autre doit être jetée, car elle n'a aucune valeur artistique.

Il y a des métriques qui sont brisées par conception (comme LOC ou le nombre de commentaires par fichier), et il y a des métriques qui peuvent donner quelques indices bruts (comme le nombre de bogues ou la complexité cyclomatique). Dans tous les cas, ce ne sont que des conseils et doivent être utilisés avec prudence.

Arseni Mourzenko
la source
2
+1 Je suis d'accord avec tout ce qui a été dit. La complexité cyclomatique ou LOC n'est que des métriques qui vous sont transmises par l'analyse de code statique. Les analyseurs statiques sont d'excellents outils, mais ils manquent de bon sens. Ces métriques doivent être traitées par un cerveau humain, de préférence celui d'un programmeur expérimenté. Ce n'est qu'alors que vous pourrez savoir si un logiciel particulier est inutilement complexe.