Comment déterminer la priorité et la gravité d'une «amélioration de code»?

Nous avons des champs «priorité» et «gravité» dans notre système de suivi des bogues. Nous définissons la gravité comme «comment cela affecte l'utilisateur» et la priorité comme «comment cela affecte le produit».

Ma question est de savoir comment classer une tâche "d'amélioration du code" en termes de gravité et de priorité. Supposons que l'amélioration ne change aucun comportement mais en fasse un "meilleur code". Nous prévoyons une amélioration globale de la maintenance à long terme, mais il est difficile à quantifier.

Lorsque nous utilisons nos définitions pour la priorité et la gravité, une amélioration du code obtient les valeurs les plus faibles pour les deux, sauf si vous introduisez des avantages à long terme difficiles à prévoir dans l'image. Par conséquent, cela implique que l'amélioration du code est une tâche futile et ne doit jamais être tentée.

Cependant, je pense qu'il est crucial d'améliorer et de refactoriser constamment le code, car:

• Le développement logiciel est en soi un processus d'apprentissage continu et sans améliorer le code, vous ne pouvez pas vous améliorer.
• Une équipe doit être fière de son code.
• La maintenance future prendra moins de temps et à long terme, les économies seront importantes.

Ou pensez-vous que de telles tâches ne devraient jamais être créées et de telles améliorations effectuées uniquement "à la demande", "lorsqu'elles sont associées à un bogue"? Même s'il est associé à un bogue, ne serait-ce pas un point de discussion sur une révision de code, par exemple "pourquoi avez-vous fait ce changement radical de structure?".

En règle générale, je n'aime pas voir les activités "d'amélioration du code" comme une tâche distincte affectable, car l'amélioration du code elle-même ne vous rapproche jamais directement de la réalisation des user stories ou des exigences. C'est pourquoi les tâches d'amélioration du code auront toujours une priorité si faible qu'elles ne seront jamais assignées.

Je vois l'amélioration du code comme une constante, quelque chose que chaque développeur devrait faire aussi naturellement que taper sur un clavier. Je le prends en compte dans mes estimations pour n'importe quelle tâche. Si ma tâche consiste à toucher une classe ou un code source qui n'a pas été examiné depuis longtemps, alors je supposerai que certains travaux de conciergerie sont probablement en ordre et augmenter mon estimation en conséquence.

Dans le meilleur des cas, je termine la tâche plus tôt et je peux utiliser le temps restant pour améliorer le code ou même la conception. Dans le pire des cas, la tâche prend beaucoup plus de temps que prévu, mais j'ai ce temps supplémentaire en tant que tampon.

Si vous souhaitez refactoriser votre code, définissez la priorité de la tâche en fonction de votre définition (c'est-à-dire "comment cela affecte le produit"). Certains refactoring n'affecteront pas beaucoup le produit et d'autres, selon l'étendue des travaux requis. La définition d'une priorité plus élevée indiquera que davantage de tests devront être effectués après la refactorisation pour s'assurer qu'aucun événement inattendu ne s'est produit.

Vous pouvez également souhaiter introduire une nouvelle catégorie dans votre système de suivi des bogues pour classer ces types de tâches en tant que tâches de «refactorisation». De cette façon, vous saurez comment interpréter la valeur de priorité; c'est-à-dire qu'une priorité plus élevée signifie un impact plus important et donc davantage de tests requis.

Ce qui manque, c'est de vérifier vos hypothèses sur le code existant: moins de temps et des économies importantes peuvent être réalisées si nous améliorons le code. Est-ce cosmétique ou y a-t-il de sérieux problèmes?

Vérifiez vos estimations de débogage et d'amélioration. S'ils prennent plus de temps et qu'il y a des commentaires continus sur la nécessité de refactoriser le code en premier ou de le nettoyer, cela peut être votre meilleure mesure. Ensuite, vous pouvez identifier votre base de code comme: bonne, nécessite une retouche mineure ou une refactorisation sérieuse requise.

Tout cela est relatif. Il est difficile d'accorder cette priorité élevée lorsque des clients souhaitent davantage de fonctionnalités et sont prêts à payer immédiatement pour les heures facturables.

Question interessante.

Je pense qu'il faudrait estimer le nombre de lignes de code et le nombre de modules qu'un changement pourrait affecter.

Vous pourriez peut-être voir combien de tests unitaires, si vous les avez, seront interrompus en effectuant le changement. Cela signifierait probablement essayer d'abord le changement dans une branche pour se faire une idée.

Ensuite, définissez des seuils pour ces niveaux de priorité et de gravité.

Vous devez également tenir compte du fait que de nombreux tests de testeurs devront être impliqués. Si le changement touche une grande surface de l'application, de nombreux tests du système peuvent devoir être revus.

Commençons par deux hypothèses ici.

1. Pour chaque nouvelle histoire, vous écrivez votre code au mieux de vos capacités, éventuellement étayé par les connaissances ambiantes de votre équipe.
2. Chaque fois que vous avez une histoire qui change la fonctionnalité du code existant, vous utilisez vos nouvelles connaissances du système et de meilleures compétences pour améliorer le code dans le processus de mise en œuvre de la nouvelle histoire.

Compte tenu de ces deux hypothèses, il n'est jamais nécessaire de faire un effort explicite d '"amélioration du code". Votre code s'améliore au fur et à mesure que vous écrivez le système. Cela signifie que tout le code n'est pas à la hauteur de vos dernières et meilleures normes de maintenabilité, mais "S'il n'est pas cassé, ne le réparez pas." Je considère le code de refactorisation qui n'a pas besoin d'être modifié pour être "plaqué or" autant que l'ajout de fonctionnalités visibles inutiles. Si le code est cassé d'une manière ou d'une autre, écrivez un test valide qui échoue; enregistrer un bug; puis refactoriser pour corriger ce bogue.

Je volerais le vote du mouvement Agile:

Entrez le bogue, devinez approximativement la gravité et la priorité,

Ensuite, revoyez quotidiennement, hebdomadairement ou mensuellement tous les nouveaux bugs, et votez sur leurs notes. Idéalement, vous le faites lors d'une réunion de planification de sprint avec les utilisateurs finaux. Ensuite, vous pouvez également parler des prochaines fonctionnalités et être positif,