Quelles sont les mesures utiles pour le code source?
Quelles sont les mesures utiles à capturer pour le code source?
Comment les métriques, comme par exemple (exécutable?) Lignes de code ou Complexité cyclomatique peuvent-elles aider à l'assurance qualité ou comment sont-elles bénéfiques en général pour le processus de développement logiciel?
"Mesurer la productivité d'un logiciel par des lignes de code, c'est comme mesurer la progression d'un avion en fonction de son poids." - Bill Gates
Jetez un œil aux articles de Jeff sur le sujet:
ne visite de la femme de ménage métrique
Il y a aussi un ancien mais bon article de Joel, étroitement lié aux métriques logicielles, et je recommande fortement sa lecture: The Econ 101 Management Method
Le point clé, pour moi, est le suivant, citant Jeff: "L'utilisation responsable des mesures est tout aussi importante que leur collecte en premier lieu."
Ce qui m'embrouille dans les mesures de code, c'est que cela ne se fait plus. La plupart des entreprises rendent compte de l'efficacité de leurs employés, fournisseurs et systèmes en place, mais personne ne semble vouloir signaler le code. Je serai certainement d'accord avec les réponses qui disent que plus de lignes de code sont un handicap mais ce que fait votre code est plus important.
Lines Of Code: Comme je l'ai mentionné, il s'agit d'une mesure vitale qui devrait être prise le plus au sérieux, mais à chaque niveau. Les fonctions, les classes, les fichiers et les interfaces peuvent indiquer un code à tout faire qui est difficile à maintenir et coûteux à long terme. Il est infiniment difficile de comparer le nombre total de lignes de code par rapport à ce que fait un système. Cela pourrait être quelque chose qui fait beaucoup de choses et dans ce cas, il y aura de nombreuses lignes de code!
Complexité: Cette mesure est bonne à faire sur des bases de code sur lesquelles vous n'avez pas travaillé, et peut vous donner une bonne indication de l'endroit où se trouvent les problèmes. Comme anecdote utile, j'ai mesuré la complexité sur l'une de mes propres bases de code, et la zone de complexité la plus élevée était celle que je passais le plus de temps lorsque je devais la changer. La réduction de la complexité a entraîné une réduction considérable du temps de maintenance. Si la direction avait ces mesures à portée de main, elle pourrait envisager de refactoriser les itérations ou de reconcevoir des zones spécifiques d'un système.
Duplication de code: Il s'agit d'une mesure très importante en ce qui me concerne. La duplication de code est un très mauvais signe et pourrait indiquer des problèmes profonds dans les faibles niveaux de conception d'un système ou des développeurs qui copient-collent, causant d'énormes problèmes à long terme et des systèmes qui ne sont pas gérables.
Graphiques des dépendances Trouver les mauvaises dépendances et les dépendances circulaires est une mesure importante dans le code. Cela indique presque toujours une conception de haut niveau incorrecte qui doit être révisée. Parfois, une dépendance peut aspirer de nombreuses autres inutiles, car quelqu'un utilise addNumber dans une bibliothèque de messagerie pour effectuer ses calculs financiers. Tout le monde est choqué lorsque la bibliothèque de courrier électronique est modifiée et que les finances sont interrompues. Si tout dépend d'une seule chose, cela peut également pointer vers des bibliothèques à tout faire qui sont difficiles à maintenir et mal conçues.
Une bonne mesure vous indiquera toujours que chaque caractéristique d'un système a une petite empreinte. Moins de dépendances, moins de complexité, moins de duplication. Cela indique un couplage lâche et une cohésion élevée.
Est-ce que cette merde de "métriques de code source" ne mourra JAMAIS?
Les lignes de code source brutes (SLOC) sont la métrique la plus ancienne, la plus simple et la plus basique qui soit.
Halstead a initialement proposé tout un tas de mesures. Beaucoup de gens s'amusaient beaucoup à écrire des programmes de mesure jusqu'à ce que certains spoilsport fassent l'étude évidente et démontrent que chaque métrique Halstead était fortement directement corrélée avec le SLOC.
À ce stade, les mesures de Halstead ont été abandonnées, car le SLOC est toujours plus facile à mesurer.
Les mesures du code source pour l'assurance qualité visent deux objectifs:
- écrire du code avec moins de bugs à l'intérieur
- écrire du code pour une maintenance facile
Les deux conduisent à écrire du code aussi simple que possible. Ça signifie:
- unités courtes de code (fonctions, méthodes)
- quelques éléments dans chaque unité (arguments, variables locales, instructions, chemins)
- et de nombreux autres critères plus ou moins complexes (voir métrique logicielle dans Wikipedia).
À ma connaissance, le nombre de bogues trouvés est directement en corrélation avec les lignes de code (probablement le taux de désabonnement), le langage modulo, le programmeur et le domaine.
Je ne connais aucune autre métrique simple et pratique bien corrélée avec les bugs.
Une chose que j'aimerais faire est de commencer à exécuter les nombres pour les différents projets sur lesquels je suis - Test Coverage :: kLOC, puis discuter de la "qualité perçue" pour voir s'il y a une corrélation.
Les mesures ne sont utiles que si vous savez quoi faire des réponses que vous obtenez. En substance, une métrique logicielle est comme un thermomètre. Le fait que vous mesuriez quelque chose à 98,6 ° F ne signifie rien tant que vous ne savez pas quelle est la température normale . La température ci-dessus est bonne pour la température corporelle mais vraiment mauvaise pour la crème glacée.
Les mesures courantes qui peuvent être utiles sont:
- Bugs découverts/semaine
- Bugs résolus/semaine
- # Exigences définies/libération
- # Exigences mises en œuvre/publication
Les deux premières mesures des tendances. Trouvez-vous des bogues plus rapidement que vous ne pouvez les corriger? Deux résultats possibles: peut-être avons-nous besoin de plus de ressources pour corriger les bogues, peut-être devons-nous arrêter d'implémenter de nouvelles fonctionnalités jusqu'à ce que nous rattrapions. Les deux derniers fournissent une image de la façon dont vous êtes sur le point d'être fait. Les équipes agiles appellent cela un graphique "burn down".
La complexité cyclomatique est une métrique intéressante. Dans son concept de base, c'est le nombre de chemins d'exécution uniques dans une fonction/méthode. Dans un environnement lourd de tests unitaires, cela correspond au nombre de tests nécessaires pour vérifier chaque chemin d'exécution. Néanmoins, ce n'est pas parce que vous avez une méthode qui a une complexité cyclomatique de 96 qu'il s'agit nécessairement d'un code bogué - ou que vous devez écrire 96 tests pour fournir une confiance raisonnable. Il n'est pas rare que du code généré (via WPF ou des générateurs d'analyseurs) crée quelque chose d'aussi complexe. Il peut fournir une idée approximative du niveau d'effort nécessaire pour déboguer une méthode.
Conclusion
Chaque mesure que vous prenez doit être définie comme suit ou elle est inutile:
- Une compréhension de ce qu'est "normal". Cela peut être ajusté sur la durée de vie du projet.
- Un seuil en dehors de "normal" où vous devez prendre une sorte d'action.
- Un plan pour gérer le code lorsque le seuil est dépassé.
Les mesures que vous prenez peuvent varier considérablement d'un projet à l'autre. Vous pouvez avoir quelques mesures que vous utilisez dans tous les projets, mais la définition de "normal" sera différente. Par exemple, si un projet a découvert en moyenne 5 bogues/semaine et que le nouveau projet découvre 10 bogues/semaine, cela ne signifie pas nécessairement que quelque chose ne va pas. Il se peut que l'équipe de test soit plus méticuleuse cette fois-ci. De plus, la définition de "normal" peut changer au cours de la durée de vie du projet.
La métrique n'est qu'un thermomètre, ce que vous en faites dépend de vous.
Le code source est un passif, pas un atout. Dans cet esprit, mesurer les lignes de code est analogue au suivi des dollars dépensés lors de la construction d'une maison. Cela doit être fait si vous voulez respecter le budget, mais vous ne penseriez pas nécessairement que dépenser 1 000 $ par jour est mieux que 50 $ par jour; vous voudriez savoir quelle partie de la maison a été construite pour cet argent. C'est la même chose avec des lignes de code dans un projet logiciel.
En bref, il n'y a pas de métriques utiles pour le code source car la mesure du code source en soi n'est pas utile.
Étant donné que le code source est simplement une combinaison de séquence, de sélection et de répétition. Si je devais décrire le logiciel le plus optimal que nous puissions raisonnablement espérer produire, ce serait comme suit. Logiciel avec près de 100% de couverture de code de test utilisant le moins de lignes de code nécessaire pour faire le travail et pourtant suffisamment flexible pour résister aux changements.
Une anecdote pour montrer pourquoi les comptages KLOC sont inutiles (et même nuisibles) pour évaluer les performances.
Il y a des années, j'ai travaillé sur un grand projet (plus de 70 personnes dans notre entreprise, 30 autres chez notre client) qui utilisait le KLOC comme seule mesure de la performance des équipes et des individus.
Pour notre effort de l'an 2000 (vous indique depuis combien de temps c'était :)), nous avons fait un grand nettoyage de la section du code dont mon équipe était responsable. Nous nous sommes retrouvés pour la sortie en écrivant environ 30.000 lignes de code, pas mal 3 mois de travail pour 5 personnes. Nous avons également fini par supprimer 70 000 lignes de code supplémentaires, un très bon travail pour 3 mois de travail, en particulier combiné avec le nouveau code.
Résultat final du trimestre: -40 000 lignes de code. Au cours de l'examen des performances suivant le trimestre, nous avons reçu une réprimande officielle de la société pour ne pas avoir répondu à nos exigences de productivité de 20 000 lignes de code produites par trimestre (après tout, les outils montraient que nous avions produit -40 000 lignes de code), ce qui aurait fait en sorte que nous soyons tous répertoriés comme sous-performants et contournés pour les promotions, la formation, l'augmentation de salaire, etc. etc. si le chef de projet et l'équipe AQ n'étaient pas intervenus et avaient fait annuler la réprimande et la remplacer par une mention élogieuse.
Quelques mois plus tard (de telles choses prennent du temps), on nous a dit que l'entreprise revoyait ses normes de productivité et avait embauché une équipe d'experts pour créer un nouveau système basé sur l'analyse des points de fonction.
Je suis surpris que personne n'ait mentionné pour l'instant la déclaration/la couverture des tests unitaires (pourcentage de code exercé par les tests unitaires).
La couverture du code est utile dans la mesure où vous savez quel pourcentage de l'application n'échoue pas de manière catastrophique; le reste de son utilité dépend de la qualité des tests unitaires.
Ce ne sont pas très utiles absol métriques en termes de progrès, mais peuvent être utilisées pour donner une idée générale de l'état du code.
Notamment la complexité cyclomatique s'est avérée utile pour visualiser la modularité d'une base de code donnée. Vous voulez généralement une faible complexité car cela signifie que le nombre de sources par module est faible et qu'il existe de nombreux modules.
Plus les engagements sont petits, mieux c'est généralement. Il s'agit d'outils SCM, pas de code en soi, mais c'est une mesure très mesurable. Plus le commit est petit, plus il est facile de voir chaque changement comme une unité atomique; plus il est facile de revenir sur des changements spécifiques et de localiser avec précision les événements.
Tant qu'aucun commit ne rompt la construction ...
Il y a de nombreuses situations dans mon travail où j'utilise des métriques de code:
Lors de l'écriture du code
L'utilisation la plus importante et peut-être la plus importante dans mon travail quotidien est dans Checkstyle , un outil pour Java développeurs qui vérifie continuellement les métriques (entre autres) de mon code par rapport à un ensemble de règles que nous avons définies et signale les endroits où mon code ne respecte pas ces règles. Au fur et à mesure que je développe du code, il me dit en temps réel si mes méthodes deviennent trop longues, complexes ou couplées me permettant de prendre du recul et de pensez à le refactoriser en quelque chose de mieux.
Les développeurs sont totalement libres d'enfreindre toutes les règles car ils ne s'appliqueront jamais à toutes les situations. Les "règles" sont là pour stimuler la réflexion et dire "Hé, est-ce la meilleure façon de faire ça?"
Pendant les révisions QA/Code
La première chose que je fais généralement lorsque j'effectue une révision de code est de vérifier la couverture de code du code que je suis en train d'examiner en conjonction avec un outil de couverture de code qui met en évidence les lignes de code qui ont été couvertes. Cela me donne une idée générale de la profondeur du code de test. Peu m'importe si la couverture est de 20% ou 100% tant que le code important est bien testé. Ainsi, le pourcentage couvert n'a pas beaucoup de sens, mais 0% se démarque comme un pouce endolori comme quelque chose que je veux regarder attentivement.
Je vérifie également les métriques convenues par l'équipe qui ont été `` cassées '', le cas échéant, pour voir si je suis d'accord avec le développeur que c'était OK ou si je peux suggérer des moyens de l'améliorer. Le fait que ces mesures de développement soient convenues dans notre équipe pour l'écriture de nouveau code a fait de gros progrès dans l'amélioration de notre code. Nous écrivons beaucoup moins de méthodes monolithiques et nous sommes bien meilleurs au principe de responsabilité unique maintenant.
Tendance à améliorer le code hérité Nous avons beaucoup de code hérité que nous aimerions améliorer. Les mesures à tout moment sont assez inutiles, mais ce qui est important pour nous, c'est qu'au fil du temps, la couverture du code augmente et des choses comme la complexité et le couplage diminuent. Par conséquent, nos mesures sont connectées à notre serveur d'intégration continue, ce qui nous permet de regarder dans le temps pour nous assurer que nous sommes sur la bonne voie.
Prise en main d'une nouvelle base de code La seule fois où j'utilise des lignes de métrique de code source, c'est quand je regarde une base de code que je ne connais pas avec. Cela me permet de mesurer rapidement la taille approximative du projet par rapport à d'autres avec lesquels j'ai travaillé. En utilisant d'autres mesures, je peux également avoir une idée approximative de la qualité du projet.
L'essentiel est d'utiliser les métriques comme points de départ pour les tendances, les discussions ou les voies à suivre et de ne pas les gérer religieusement avec des chiffres exacts. Mais je crois fermement qu'ils peuvent vous aider à améliorer le code qui vous convient lorsqu'il est utilisé correctement.
Je travaille souvent sur un package C++ géant, et lorsque vous recherchez du code problématique qui mérite d'être refactorisé Complexité cyclomatique ou horrible FanIn/FanOut sont généralement de très bons drapeaux rouges à rechercher. La résolution des problèmes entraînera généralement des améliorations dans l'ensemble de la base de code.
Bien sûr, ces chiffres ne peuvent servir que d'indication sur ce qui mérite d'être examiné. Il serait ridicule de fixer ce seuil difficile après lequel échouer une build ou refuser un commit.
Q: Quelles sont les mesures utiles à capturer pour le code source?
Pour les entreprises:
A: Nombre d'heures-homme
Pour le superviseur du codeur:
R: Peu importe. Faisons tout aujourd'hui
Pour l'estime de soi du codeur:
A: nombre de SLOC (lignes de code source)
Pour la mère du codeur:
A: Mangez plus de ces petits pains français doux et buvez du thé
suite dans les commentaires ci-dessous ...