Trouvez-vous la complexité cyclomatique une mesure utile?
https://stackoverflow.com/questions/745857
-
09-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je joue autour avec la mesure de la complexité cyclomatique d'une grande base de code.
complexité cyclomatique est le nombre de chemins linéairement indépendants à travers le code source d'un programme et il y a beaucoup d'outils gratuits pour langue de votre choix.
Les résultats sont intéressants, mais pas surprenant. Autrement dit, les pièces que je connais comme poilue étaient en fait le plus complexe (avec une note de> 50). Mais ce que je trouve utile est qu'un certain nombre de « mauvais état » du béton est attribué à chaque méthode comme quelque chose que je peux indiquer au moment de décider où commencer refactoring.
Utilisez-vous la complexité cyclomatique? Quel est le bit le plus complexe de code que vous avez trouvé?
La solution
Nous Refactoriser sans pitié, et de complexité de Cyclomatic comme l'une des mesures qui obtient code sur notre «liste de résultats. 1-6, nous ne pas signaler la complexité (bien qu'il puisse se doute pour d'autres raisons), 7-9 est discutable, et toute méthode sur 10 est supposé être mauvais, sauf preuve du contraire.
Le pire que nous avons vu était 87 d'un monstrueux if-else, si la chaîne dans un code de l'héritage que nous avons dû prendre le relais.
Autres conseils
En fait, la complexité cyclomatique peut être mis à contribution au-delà des seuils seulement au niveau de la méthode. Pour commencer, une grande méthode avec une grande complexité peut être divisée en plusieurs petites méthodes avec une complexité plus faible. Mais il a vraiment amélioré la base de code? Certes, vous pouvez obtenir un peu meilleure lisibilité par tous les noms de méthode. Mais la logique conditionnelle totale n'a pas changé. Et la logique totale conditionnelle peut souvent être réduite par remplacement conditionals avec le polymorphisme .
Nous avons besoin d'une mesure qui ne passe pas au vert par décomposition simple méthode. Je l'appelle CC100 .
CC100 = 100 * (complexité totale cyclomatique de codebase) / (nombre total de lignes de code)
Il est utile pour moi de la même manière que grand-O est utile: Je sais ce qu'il est, et peut l'utiliser pour obtenir un sentiment d'intestin pour déterminer si une méthode est bonne ou mauvaise, mais je ne ai pas besoin de calculer pour toutes les fonctions que je l'ai écrit.
Je pense que des mesures plus simples, comme LOC, sont au moins aussi bien dans la plupart des cas. Si une fonction ne correspond pas à l'écran, il ne fait presque pas d'importance comment il est simple. Si une fonction prend 20 paramètres et fait 40 variables locales, il n'a pas d'importance si sa complexité cyclomatique est 1.
Nous avons récemment commencé à l'utiliser. Nous utilisons NDepend pour faire une analyse de code statique, et il mesure la complexité cyclomatique. Je suis d'accord, c'est une façon décente d'identifier des méthodes pour refactoring.
Malheureusement, nous avons vu des # 200 ci-dessus pour certaines méthodes créées par nos développeurs en mer.
Tant qu'il n'y aura un outil qui peut bien travailler avec C ++ des modèles et des techniques de méta-programmation, il est pas beaucoup d'aide dans ma situation. Anyways n'oubliez pas que
"pas toutes les choses qui comptent peut être mesurée, et toutes les choses qui peuvent comptage être mesurée » Einstein
Alors souvenez-vous de transmettre toute information de ce type par le filtrage humain aussi.
Vous saurez la complexité quand vous le voyez. La principale chose que ce genre d'outil est utile pour les parties faiblit du code qui s'échappaient votre attention.
Je mesure souvent la complexité cyclomatique de mon code. Je l'ai trouvé me aide à repérer les zones de code qui font trop. Avoir un outil pointer les points chauds dans mon code est beaucoup moins de temps que d'avoir à lire des milliers de lignes de code à essayer de comprendre quelles méthodes ne suivent pas le SRP.
Cependant, j'ai trouvé que lorsque je fais une analyse de la complexité cyclomatique sur le code d'autres personnes, il conduit généralement à des sentiments de frustration, d'angoisse et de colère générale quand je trouve le code avec la complexité cyclomatique dans les années 100. Ce qui oblige les gens à écrire des méthodes qui ont plusieurs milliers de lignes de code en eux!
Il est idéal pour les aider à identifier les candidats à refactoring, mais il est important de garder votre jugement autour. Je soutiens les gammes de kenj0418 pour les guides de taille.
Il y a une métrique Java appelée CRAP4J qui combine de manière empirique la complexité cyclomatique et la couverture des tests JUnit à venir avec un seul métrique. Il a fait des recherches pour essayer d'améliorer sa formule empirique. Je ne sais pas comment il est répandu.
Je ne l'ai pas utilisé dans un certain temps, mais sur un précédent projet vraiment permis d'identifier les points chauds potentiels à quelqu'un elses le code (ne serait pas moi bien sûr!)
Lors de la recherche de vérifier, je me suis vite trouvé des problèmes numerious (aussi beaucoup de GOTOS Croiriez-vous!) Avec une logique et un code de WTF vraiment étrange de la région.
complexité cyclomatique est grande pour montrer les zones qui font sans doute beaucoup et donc briser le prinicpal de responsibilty unique. Ces est devraient idéalement être divisés en fonctions mulitple
+1 pour des années kenj0418 a frappé les valeurs de la liste.
Le pire que j'ai vu était un 275. Il y avait deux autres plus de 200 que nous avons pu factoriser jusqu'à CCs beaucoup plus petites; ils étaient encore élevés, mais il a obtenu les ont poussés plus loin dans la ligne. On n'a pas eu beaucoup de chance avec la bête 275 - il était (probablement est encore) un réseau de mise sous tension et si- déclarations qui vient d'être trop complexe. Il est seulement la valeur réelle est comme étape par quand ils décident de reconstruire le système.
Les exceptions à haute CC que j'étais à l'aise avec les usines étaient; OMI, ils sont censés avoir un haut CC mais seulement si elles ne sont en train de faire simple, la création d'objets et de retour.
Après la compréhension ce que cela signifie, j'ai maintenant commencé à l'utiliser sur une base « d'essai ». Jusqu'à présent, je l'ai trouvé pour être utile, parce que CC généralement élevé va de pair avec le flèche anti-modèle, ce qui rend code plus difficile à lire et à comprendre. Je n'ai pas encore nombre fixe, mais NDepend est alertant pour tout ce qui précède 5, qui ressemble à un bon début d'étudier les méthodes.
Oui, nous l'utilisons et je l'ai trouvé utile aussi. Nous avons une grande base de code existant pour dompter et nous avons trouvé alaraming grande complexité cyclomatique. (387 dans une méthode!). points de CC vous directement sur les zones qui méritent d'être à factoriser. Nous utilisons CCCC sur le code C ++.
complexité cyclomatique est juste un de ce qui pourrait Composant être appelé complexité Fabricated. Un peu en arrière, je l'ai écrit un article pour résumer plusieurs dimensions de la complexité du code: lutte contre la complexité Fabricated
Outillage est nécessaire pour être efficace à la manipulation complexité du code. L'outil NDepend pour le code .NET vous permet d'analyser de nombreuses dimensions de la complexité du code, y compris les mesures de code comme: La complexité cyclomatique, profondeur Nesting, le manque de cohésion des méthodes, la couverture par des tests ...
y compris l'analyse des dépendances et comprenant une langue ( code Query Language ) dédié à demander , ce qui est complexe dans mon code, et d'écrire la règle?
