Métriques de code source pour mesurer la stabilité du code?

Compte tenu de la façon dont le logiciel est développé au cours d'un cycle de publication (implémentation, test, correction de bogues, publication), je pensais que l'on devrait pouvoir voir un modèle dans les lignes de code qui sont modifiées dans la base de code; par exemple vers la fin d'un projet, si le code devient plus stable, on devrait voir que moins de lignes de code sont modifiées par unité de temps.

Par exemple, on a pu voir qu'au cours des six premiers mois du projet, la moyenne était de 200 lignes de code par jour alors qu'au cours du dernier mois c'était 50 lignes de code par jour, et au cours de la dernière semaine (juste avant les DVD du produit ont été expédiés), aucune ligne de code n'a été modifiée (gel du code). Ce n'est qu'un exemple, et différents modèles pourraient émerger en fonction du processus de développement adopté par une équipe particulière.

Quoi qu'il en soit, existe-t-il des mesures de code (de la littérature à leur sujet?) Qui utilisent le nombre de lignes de code modifiées par unité de temps pour mesurer la stabilité d'une base de code? Sont-ils utiles pour se faire une idée si un projet arrive quelque part ou s'il est encore loin d'être prêt à sortir? Existe-t-il des outils qui peuvent extraire ces informations d'un système de contrôle de version et produire des statistiques?

Une mesure que Michael Feather a décrite est " L'ensemble actif de classes ".

Il mesure le nombre de classes ajoutées par rapport à celles "fermées". Le décrit la fermeture de classe comme:

Un cours est fermé à la date à laquelle aucune autre modification ne lui est apportée depuis cette date jusqu'à aujourd'hui.

Il utilise ces mesures pour créer des graphiques comme celui-ci:

Plus l'écart est petit entre les deux lignes, mieux c'est.

Vous pourrez peut-être appliquer une mesure similaire à votre base de code. Il est probable que le nombre de classes soit en corrélation avec le nombre de lignes de code. Il peut même être possible de l'étendre pour incorporer une ligne de code par mesure de classe, ce qui pourrait changer la forme du graphique si vous avez de grandes classes monolithiques.

Tant qu'il existe un mappage relativement cohérent des fonctionnalités vers les classes, ou d'ailleurs, le système de fichiers, vous pouvez connecter quelque chose comme gource dans votre système de contrôle de version et obtenir très rapidement une idée de l'endroit où la plupart du développement est concentré (et donc quelles parties du code sont les plus instables).

Cela suppose que vous ayez une base de code relativement ordonnée. Si la base de code est une boule de boue, vous verrez essentiellement chaque petite partie en cours de travail en raison des interdépendances. Cela dit, peut-être que cela en soi (le clustering tout en travaillant sur une fonctionnalité) est une bonne indication de la qualité de la base de code.

Cela suppose également que votre entreprise et votre équipe de développement dans son ensemble aient un moyen de séparer les fonctionnalités dans le développement (que ce soit des branches dans le contrôle de version, une fonctionnalité à la fois, peu importe). Si, par exemple, vous travaillez sur 3 fonctionnalités principales sur la même branche, cette méthode produit des résultats sans signification, car vous avez un problème plus important que la stabilité du code entre vos mains.

Malheureusement, je n'ai pas de littérature pour prouver mon point. Il est uniquement basé sur mon expérience d'utilisation de gource sur de bonnes (et pas si bonnes) bases de code.

Si vous utilisez git ou svn et que votre version de gource est> = 0,39, c'est aussi simple que d'exécuter gource dans le dossier du projet.

L'utilisation de la fréquence des lignes modifiées comme indicateur de la stabilité du code est au moins discutable.

Dans un premier temps, la répartition dans le temps des lignes modifiées, dépend fortement du modèle de gestion logicielle du projet. Il existe de grandes différences dans les différents modèles de gestion.

En second lieu, la victime dans cette hypothèse n'est pas claire - est le nombre inférieur de lignes modifiées provoqué par la stabilité du logiciel, ou simplement parce que le délai expire et que les développeurs ont décidé de ne pas apporter de changements maintenant, mais de le faire après la Libération?

Au troisième, la plupart des lignes sont modifiées lorsque de nouvelles fonctionnalités sont introduites. Mais la nouvelle fonctionnalité ne rend pas le code instable. Cela dépend de la compétence du développeur et de la qualité de la conception. D'un autre côté, même des bugs graves peuvent être corrigés avec très peu de lignes modifiées - dans ce cas, la stabilité du logiciel est considérablement augmentée, mais le nombre de lignes modifiées n'est pas trop important.

La robustesse est un terme qui se rapporte à la fonction correcte d'un ensemble d'instructions, et non à la quantité, à la verbosité, à la justesse, à l'exactitude grammaticale du texte utilisé pour exprimer ces instructions.

En effet, la syntaxe est importante et doit être correcte, mais tout ce qui va au-delà, car elle se rapporte à la fonction souhaitée des instructions en regardant les `` métriques '' des instructions s'apparente à tracer votre avenir en lisant le motif des feuilles de thé au bas de vous tasse de thé.

La robustesse est mesurée au moyen de tests. Tests unitaires, tests de fumée, tests de régression automatisés; tests, tests, tests!

Ma réponse à votre question est que vous utilisez la mauvaise approche pour chercher une réponse à la robustesse. C'est un hareng rouge que les lignes de code signifient autre chose que des lignes occupant du code. Vous ne pouvez savoir si le code fait ce que vous voulez qu'il fasse que si vous testez qu'il fait ce que vous en avez besoin.

Veuillez revoir les harnais de test appropriés et éviter le mystisisme de métrique de code.

Meilleurs vœux.