Comment puis-je faire du refactoring une priorité pour mon équipe?

La base de code avec laquelle je travaille quotidiennement ne contient pas de tests automatisés, de nom incohérent et de tonnes de commentaires tels que "Pourquoi est-ce ici?", "Pas sûr que cela soit nécessaire" ou "Cette méthode n'est pas nommée à droite" et le code est encombré "Changelogs" malgré le fait que nous utilisons le contrôle de source. Disons simplement que notre code pourrait utiliser le refactoring.

Nous avons toujours des tâches pour corriger les bogues ou ajouter de nouvelles fonctionnalités. Par conséquent, nous ne perdons pas de temps pour refactoriser le code pour qu'il soit meilleur et plus modulaire, et cela ne semble pas être une priorité.

Comment puis-je démontrer la valeur de la refactorisation de telle sorte qu'elle soit ajoutée à nos listes de tâches? Vaut-il la peine de simplement refacturer au fur et à mesure, demandant pardon plutôt que par permission?

"Mieux vaut demander pardon que permission" est vrai.

Pourquoi t'inquiéter pour ça? Juste refacturer les parties les plus horribles.

Vous savez déjà quelles sont les erreurs les plus coûteuses , non?

Sinon, l'étape 1 consiste à définir de manière positive et non ambiguë le code du problème le plus coûteux, le plus complexe, le plus complexe en raison d'erreurs et de bogues.

Identifiez le nombre de tickets d'incident, les heures de débogage et d'autres coûts très spécifiques et très mesurables .

Ensuite, corrigez quelque chose sur cette liste de problèmes de coûts élevés .

Lorsque vous devez demander pardon, vous pouvez indiquer des réductions de coûts.

Si vous ne le savez pas, le refactoring nécessite des tests unitaires pour prouver que les comportements avant-après correspondent. Idéalement, il devrait s'agir d'un test automatisé et codé, par exemple un test unitaire.

Cela signifie choisir une chose. Ecrivez un test unitaire. Fixer cette une chose. Vous avez apporté deux améliorations. (1) a écrit un test et (2) a corrigé le code.

Répéter.

Suivez la règle du scoutisme: laissez le code du camping un peu meilleur que vous ne l'avez trouvé. Je n'ai jamais entendu parler d'une personne en train de se faire reprocher des améliorations de code mineures "alors qu'elle y était".

Je vais prendre un point de vue peut-être trop cynique.

Le refactoring est une pilule difficile à avaler. Vous obtenez la responsabilité et le blâme, et les fruits de votre travail vont souvent à quelqu'un d'autre qui s'appuie sur votre base de code propre.

Je dirais que si de telles pratiques d'ingénierie sont devenues la culture de votre entreprise, vous devrez peut-être vous battre à un niveau supérieur. Vous ne vous battez pas vraiment pour le refactoring, mais pour l'excellence en ingénierie, et c'est le genre de changement qui n'apparaît que chez le management quand il se sent mal à l'aise. Dans ce scénario, ils vont probablement chercher à l'extérieur un tsar des meilleures pratiques, et toutes vos bonnes idées seront englobées de toute façon.

Pensez à vous joindre à une autre société où ils prennent les pratiques d'ingénierie plus au sérieux.

Je remarque que bon nombre des affiches ici semblent convaincues que le problème de gestion est abordé - bien que la question ne le mentionne pas.

J'irais plus loin que cela: à mon avis, une base de code moche n'est presque jamais directement la faute de la direction. La direction n’a pas écrit ce code, contrairement aux développeurs (il existe des exceptions dans mon entreprise où certains membres de la direction actuelle ont écrit la base de code initiale). Par conséquent, le problème de la culture réside chez les développeurs - s'ils veulent que la culture change, ils doivent eux-mêmes changer.

J'essaie également de faire comprendre cette réalisation et ce changement d'attitude à "mes" développeurs. Chaque fois qu'ils me demandent "quand aurons-nous le temps de refactoriser?", Je suis surpris et réponds "tu devrais déjà refactoriser tout le temps!". La seule façon, selon moi, de garder une base de code saine est triple:

1. N'ajoutez jamais que du code sain.
2. Corrigez toujours le code pas si sain dès que vous le voyez.
3. Si, pour des raisons de délai, vous ne pouvez pas exécuter les tâches 1 ou 2, ayez toujours une liste des problèmes de «réparation immédiatement après la date limite» et n'acceptez aucune excuse pour ne pas avoir travaillé sur cette liste après la date limite.

Invariablement, la remarque suivante des développeurs est "mais comment pouvons-nous avoir le temps de le faire - nous n’avons pas le temps maintenant?". La seule réponse correcte (encore une fois à mon humble avis) est "vous n’avez pas le temps de NE PAS faire cela". Si vous ne maintenez pas la base de code en bonne santé, vous constaterez que les délais d'exécution deviennent de plus en plus longs, les calendriers de plus en plus imprévisibles, les bugs de plus en plus méchants et la valeur de plus en plus basse.

Le plus grand changement d’attitude que vous devez effectuer dans l’équipe de développement est le fait que la "qualité" n’est pas quelque chose que vous faites à un moment donné ("quand nous avons le temps de refactoriser") - c’est quelque chose que vous devez faire TOUT le temps.

Enfin, une histoire d'avertissement. Si on appuie dessus, je nierai que cela soit jamais arrivé. Dans une entreprise pour laquelle je travaillais, il y avait une application de longue date avec une grande base de code héritée datant de plus de 10 ans. Beaucoup de développeurs, dont moi, croyaient que cette ancienne base de code était mauvaise ou du moins obsolète, et non à la pointe de la technologie. Nous avons donc fait pression pour un grand projet de refactorisation et avons démarré le projet de réécriture, après quoi nous pensions que tout irait mieux.
Nous avons travaillé longtemps et implémenter presque tout d'une manière nouvelle et moderne, en utilisant de nouvelles bibliothèques, de nouvelles fonctionnalités de langage. Vers la fin, nous avons déployé des efforts considérables pour réunir tous les éléments afin de permettre une nouvelle version de l’application de longue date avec la nouvelle base de code améliorée.
Comme prévu, la nouvelle version posait quelques problèmes de démarrage, à cause des nouvelles bibliothèques que nous ne connaissions pas encore si bien, et de certaines interactions dans notre code que nous n'avions pas prévues. Cependant, nous avons finalement réussi à obtenir la publication au même niveau que nos versions précédentes et à la porte. Nous avons poussé un soupir de soulagement à notre "succès". Ensuite, un sous-groupe de développeurs est retourné à la gestion, demandant un nouveau projet de refactoring car notre nouveau code n'était pas tout à fait la solution miracle qu'ils s'attendaient à ce qu'il soit, et ils ont vu des possibilités de réécrire complètement certaines choses ...

Morale de l'histoire: souvent, les choses ne sont pas aussi cassées qu'elles le paraissent, et «recommencer» signifie généralement que vous échangerez un ensemble de problèmes connus contre un ensemble de problèmes inconnus, du moins poilus. Refactoriser une partie à la fois!

Quelqu'un m'a dit un jour que, lors d'un entretien, je ne devais pas oublier que j'interviewais également la société. Est-ce un endroit où je veux travailler? Est-ce qu'ils font des revues de code? Ont-ils des tests d'intégration automatisés? Tests unitaires? Que pensent-ils de la programmation en binôme? Personnellement, je trouverais un autre travail et n'oublierai pas de poser des questions aussi cette fois-ci.

Trouver une autre entreprise, honnêtement. De telles améliorations du processus de développement nécessitent d'énormes sauts culturels. Il faudra beaucoup de temps avant que tout le monde ne se retrouve sur la même page et d'ici là, vous ne vous soucierez plus autant.

Si vous sentez que vous avez encore du mal à vous battre et que vous n’avez pas encore perdu la partie, faites un dernier effort. Essayez d’obtenir le plus de soutien possible de la part de membres d’équipe aux vues similaires, communiquez votre épuisement aux supérieurs qui se soucient de votre bien-être, contournez-le et distanciez ceux qui pourraient s’opposer à vos convictions et tentez de passer des heures de refactorisation obligatoires à la planification de nouvelles projets / fonctionnalités.

Si vous êtes passionné par ce que vous faites et que vous vous souciez de votre entreprise, ce serait un effort louable de votre part. Si vous ne l'appréciez pas, respectez-vous et libérez-vous avant de devenir un programmeur creux.

Si je devais introduire une pratique pour améliorer les choses dans ce genre de contexte, ce serait des revues de code. Les revues de code sont

• généralement accepté intuitivement par les développeurs comme facteur pour un meilleur code, moins de bugs, etc.
• collaboratif et démocratique
• pas trop de temps si vous les chronométrez correctement
• un bon endroit pour faire du refactoring si vous n'avez pas le temps de le faire pendant un développement "normal"
• Un cheval de Troie assez efficace pour introduire progressivement toutes sortes de meilleures pratiques en termes de conception de code, de tests unitaires ...

Vous n'êtes pas obligé de procéder systématiquement à des révisions de code, mais uniquement lorsque vous validez des portions de code volumineuses / complexes.

Bien sûr, si vous pensez avoir besoin de l'approbation officielle avant d'introduire des révisions de code, vous devrez peut-être d'abord convaincre votre patron que la base de code risque de s'effondrer si les choses restent comme elles sont.

Voici ce que je fais dans de telles situations (au cours de mes 15 années de carrière en tant que développeur, j'ai rencontré ce code presque tous les jours)

1. Donner l'exemple - Je m'assure de re-factoriser le code que je touche. Je supprime impitoyablement l'ancien code commenté et les grands paragraphes de commentaires.
2. Demandez à refactoriser chaque fois que l'on me demande de réviser un changement de code, sans lequel je n'approuve pas la révision du code.
3. Lentement, les gens voient le changement, lorsque le code devient plus léger, plus lisible et donc moins bogué. Cela prend du temps mais lentement, toute l’équipe apprécie et adopte la pratique.

La direction ne réserve jamais de temps pour la reconfiguration du code (elle n'a jamais assez de ressources!), Il est donc judicieux de procéder lentement et régulièrement.

Demander à la direction de faire des recherches sur la "dette technique". Reportez-vous également à la "théorie de la fenêtre brisée", ces deux effets ayant un impact direct sur l'efficacité, la qualité et le moral.

"Un chantier propre est un chantier sûr et productif", et chaque contribution à un gâchis aggrave le gâchis de manière exponentielle et non linéaire.

Si la situation n'est pas réglée, vous rencontrerez éventuellement un point de non-retour, où cela deviendra économiquement irréalisable. En y remédier progressivement avant que cela ne se produise, les avantages vont rebondir, ce qui vous donnera plus de carburant pour gérer le problème au fur et à mesure.

On dirait que vos problèmes sont plus généraux.
La question de la refactorisation est à la fois un symptôme et un soulagement potentiel d’une partie du problème.

Le responsable logiciel et l'équipe allouent le temps de l'équipe

D'après mon expérience, je pense que vous rencontrez peut-être un problème que j'appelle "tout le monde est un gestionnaire de logiciel". Les chefs de produit, les chefs de projet et parfois les ingénieurs système et les testeurs peuvent être connus pour tenter de microgérer les développeurs qui ont probablement déjà un gestionnaire de logiciel expérimenté. Il se peut même que quelques membres de votre équipe croient que leur rôle est de gérer.

Si vous êtes le responsable logiciel, définissez les affectations pour le refactoring souhaité ou, mieux encore, demandez à votre équipe de vous proposer le refactoring pour approbation. Afin de ne pas microgérer, vous pourriez avoir des directives sur l’âge / l’auteur / la taille / le contexte du code à refactoriser pouvant être librement refactorisées par opposition à une approbation. Si un membre de votre équipe souhaite modifier en profondeur quatre grandes classes de code complexe qu'il n'a pas écrit et qui ne font pas partie de son long métrage, ses deux semaines de déjudiciarisation sont votre problème. Vous devez donc avoir la possibilité de dire non.

Vous pouvez vous faufiler, mais je pense qu'il est préférable de construire vos estimations avec soin avec du temps pour l'analyse, la conception, le codage, de multiples formes de test (au moins unité et intégration), la refactorisation et le risque tel que jugé historiquement et par le manque de précision. expérience ou clarté associée à la tâche. Si vous avez été trop ouvert sur le fonctionnement de votre équipe (ou si des membres de votre équipe le sont), il peut être judicieux de restreindre les canaux de communication afin qu'ils analysent vos ressources et discutent des ressources et des résultats, et non des méthodes.

Les premiers choix de projet créent un cercle vicieux pour la refactorisation

La maintenance du logiciel est difficile. Il est doublement difficile que d’autres membres de l’organisation fassent des choix à vos dépens. C'est faux, mais ce n'est pas nouveau. Barry Boehm, l'un de nos grands rédacteurs de logiciels, a présenté le modèle de gestion qu'il décrit sous le nom de Theory W.

http://csse.usc.edu/csse/TECHRPTS/1989/usccse89-500/usccse89-500.pdf

Les développeurs de logiciels sont souvent obligés de produire en vertu de l’approche de gestion de Theory-X, qui stipule que les travailleurs sont fondamentalement paresseux et n’exécutent pas leurs tâches à moins d’être soumis à la soumission. Boehm résume et oppose son modèle proposé comme suit:

"Plutôt que de qualifier un responsable d'autocrate (Théorie X), d'entraîneur (Théorie Y) ou d'animateur (Théorie Z), la Théorie W caractérise le rôle principal d'un dirigeant en tant que négociateur entre ses diverses composantes et en tant que concepteur de solutions de projet avec des conditions de victoire pour toutes les parties. Au-delà de cela, le manager est également un buteur, un moniteur de progrès, et un activiste dans la recherche de conflits de projets quotidiens, gagnants ou perdants, auxquels il est confronté, et les transformer en situations gagnant-gagnant. "

Quick and Dirty est souvent juste sale

Boehm poursuit en expliquant la raison pour laquelle les développeurs de l’équipe de maintenance sont tellement misérables.

"Construire un produit rapide et négligé peut constituer une" victoire "à court terme et à faible coût pour le développeur de logiciel et le client, mais ce sera une" perte "pour l'utilisateur et le responsable." Veuillez noter que dans le modèle de Boehm, le client est davantage un administrateur de contrat que un utilisateur final. Dans la plupart des entreprises, considérez le responsable de produit comme un substitut du client, ou peut-être la personne qui achète le produit pour sa liste de fonctionnalités.

Ma solution serait de ne pas libérer l'équipe de développement d'origine (ou au moins son rôle principal) jusqu'à ce que le code soit refactorisé pour au moins respecter les normes de codage.

Pour les clients, je pense qu’il est raisonnable de considérer le chef de produit comme un substitut de la clientèle. Le groupe de personnes récompensées pour avoir fourni quelque chose de rapide et sale peut certainement être élargi. Il existe donc un large éventail de personnes qui agissent mal.

Le refactoring n'est pas négociable

S'il vous plaît ne reculez pas de votre rôle en tant que gestionnaire de logiciels. Vous devez avoir le pouvoir et la discrétion d'utiliser le temps passé par votre équipe pour améliorer le produit. Dans ce rôle, vous devrez peut-être négocier vos choix pour rendre votre équipe plus professionnelle. Cependant, en ce qui concerne le processus, ne négociez pas avec le marketing, car, d’après mon expérience, c’est un jeu perdant. Négocier avec la direction de l'ingénierie. Cela montre que vous avez une vision. Construire une équipe logicielle professionnelle est une extension de leur rôle et est beaucoup plus susceptible d'être perçu comme un gagnant-gagnant.

Vous pouvez toujours simplement attendre. Finalement, l’équipe ne respectera pas suffisamment de délais et produira un logiciel suffisamment buggé pour que la direction lève les mains en disant que par Dieu, il faudrait que quelque chose change!

Ok, c'est une proposition risquée. Mais c’est ce qui s’est passé dans notre magasin il ya plusieurs années (l’une des difficultés était de communiquer avec la direction au sujet des délais, mais c’est une autre histoire) et c’est en grande partie la raison pour laquelle nous avons maintenant des dizaines de milliers de tests automatisés, la propriété de code partagé, la liberté de refactoriser, la volonté de supprimer le code mort et les versions de la plus haute qualité que nous ayons jamais eues.

Le plus surprenant est peut-être que personne n’a perdu son emploi au cours du processus - quelque chose que j’attache à notre chef qui vient de le défendre pour nous et à un consultant qui a plaidé en faveur de la refactorisation et de l’intégration continue en notre nom. Cela semble toujours plus convaincant quand quelqu'un de l'extérieur le dit.

Je pense que la réponse à la question de savoir comment trouver le temps dépend de la raison pour laquelle vous voulez modifier le code.

Si cela fonctionne, il n’est pas nécessaire de recourir à un refactor spécial et vous pouvez le faire lorsque vous touchez cette partie du code. Par conséquent, vous n'avez pas besoin de temps spécial pour cela.

Si cela ralentit le développement de votre équipe, vous devez en discuter avec le chef d’équipe et créer une tâche spéciale pour le refactoring afin que vous disposiez de suffisamment de temps.

Idem pour la vitesse d'exécution et les autres cas, si le refactor peut améliorer quelque chose et pas seulement le «bon code» ou votre opinion sur, à quoi devrait ressembler le code et fournir un réel avantage, créer une tâche ou parler à quelqu'un qui en est responsable.

J'ai ri un peu de la façon dont vous avez décrit les choses, car cela ressemble assez au code de base sur lequel je travaille, je pense donc que nos situations sont assez similaires. Heureusement, dans ma situation, j'ai un responsable avant-gardiste qui a décidé que la modularisation utilisant un cadre de développement Web moderne plutôt que de simplement refactoriser l'intégralité du code était la meilleure façon d'améliorer le code. De cette façon, les points problématiques de l’application principale peuvent être réécrits en tant que modules séparés, puis intégrés dans l’application principale (tout en restant essentiellement indépendants). Il s’agit peut-être d’une approche à adopter car elle n’exigerait pas de refactoriser la base de code entière (supposément grande?) Avec laquelle vous travaillez.

Bien sûr, je suis peut-être un peu en retrait de ce que vous dites car votre base de code n'est peut-être pas aussi mauvaise que celle avec laquelle je travaille. Dans ce cas, je dirais pourquoi ne pas faire de petites optimisations au fur et à mesure? Les développeurs de mon équipe n'ont aucun problème à supprimer les commentaires stupides ou obsolètes et des choses de cette nature et je ne pense pas que ce soit quelque chose qui devrait demander l'avis de la direction, car les développeurs ont généralement le pouvoir de l'optimiser au besoin.

Si la base de code est vraiment fragile, vous devez faire attention et c'est peut-être pour cette raison qu'ils ne voudront peut-être pas procéder à une refactorisation majeure, car cela pourrait se transformer en un projet de plusieurs mois et nécessiterait probablement la création d'un branchement d'un projet et la mise en place de travaux de développement. projet et en évitant d’autres tâches de développement, telles que des corrections de bugs immédiats pouvant les amener à perdre des clients, etc.

Tout bien considéré, pour autant que les autres personnes disent que vous devriez arrêter, etc., je pense que cela dépend de la façon dont la direction perçoit les choses, si elles comprennent la situation et comprennent pourquoi certaines choses peuvent prendre plus longtemps que prévu, alors tout ira bien. En ce qui concerne l’environnement de travail, mais s’ils vous reprochent constamment de travailler en retard, cela pourrait devenir préjudiciable avec le temps. Je suis chanceux d'avoir une direction qui réalise en gros que l'application est une merde, mais elle a beaucoup de clients et rapporte de l'argent, donc c'est toujours utile et vaut la peine de faire des corrections de bugs, même si ce n'est que pour le court terme .

Votre principal problème est que les codes n'obtiennent pas une visibilité suffisante.

Je suggère d'utiliser un outil d'intégration continue comme Jenkins , et un outil d'analyse de code statique intégré qui mesure la complexité cyclomatique, les normes de nommage, la longueur du code, etc.

Lorsqu'un programmeur valide une modification, Jenkins exécute les tests d'unités, y exécute l'outil d'analyse de code statique et génère un rapport Web visible par tous, avec un statut de couleur semblable à un feu tricolore.

Lorsque la qualité du code est visible pour tout le monde (spécialement le responsable de l'équipe et le patron) et que le contrôle de version et les tests unitaires sont là pour vous aider… les gens se sentent encouragés à refactoriser.

Le code est devenu lent au fil de nombreux petits changements. Cela devra également être corrigé.

Tout d'abord, augmentez toutes les estimations de 10% pour permettre l'amélioration du code et la maintenance à long terme. Si quelqu'un se plaint, demandez-lui s'il est préférable de vérifier l'huile d'un moteur de voiture toutes les semaines ou d'attendre que le moteur se bloque complètement.

Organisez une réunion et déterminez des normes de codage cohérentes.

Introduisez les règles de base à utiliser au fur et à mesure:

Chaque fois qu'un nouveau code est introduit dans une classe, des tests automatisés doivent être écrits pour prouver que la classe fonctionne (et pas seulement le nouveau code).

Chaque fois qu'un bogue est corrigé, des tests automatisés doivent être écrits pour prouver que la classe fonctionne (pas seulement le code corrigé).

Lorsqu'un programmeur modifie un fichier, il doit corriger tous les avertissements du compilateur contenus dans ce fichier et mettre à jour le code afin qu'il réponde aux nouvelles normes de codage.

Après un certain temps, le code le plus utilisé sera à jour et fera l’objet de tests automatisés. L'ancien code sera mis à jour lorsqu'il sera modifié. S'il ne l'est jamais, vous ne devez plus vous en préoccuper.

L'important est d'intégrer ces fonctions dans les tâches de codage standard afin qu'aucune d'entre elles ne prenne une énorme quantité de temps à l'écart du «vrai» travail, mais qu'elles procurent toutes de réels avantages. N'essayez pas de transformer un ancien code en un projet, c'est une douleur horrible, ennuyeuse et fastidieuse qui vous fera perdre beaucoup de temps.

Pour obtenir les ressources (le temps) dont vous avez besoin, vous devez vous concentrer sur l’alignement des capacités et des souhaits. Votre patron est motivé par des objectifs (généralement des bénéfices ou des délais de livraison pour les nouvelles fonctionnalités), et il considère le remaniement comme une perte de temps pour les ingénieurs. Vous devez trouver un moyen de le convaincre que les objectifs seront atteints et dépassés si vous passez du temps à refactoriser.

La première étape consiste donc à déterminer la douleur ressentie par votre supérieur hiérarchique. Identifiez ses plus gros problèmes. Ensuite, déterminez si ce que vous voulez faire va dans le sens de la résolution de ses problèmes et présentez une solide analyse de rentabilisation. Utilisez vos systèmes de suivi des défauts et de planification de projet (dépassements de temps) pour fournir une preuve des problèmes. Vous avez besoin de faits, pas de sentiments. Sans métriques (nombre de bogues / module, coût pour les résoudre), la refactorisation est simplement un programmeur jouant à la charge de quelqu'un. Votre patron ne vous donnera les ressources nécessaires que si vous êtes en mesure de présenter une analyse de rentabilité solide.

Le code de la merde est le plus souvent trop coûteux à réparer. En l'absence de tests de régression automatisés, le coût du test du code refactorisé est extrêmement élevé.

La plupart du temps, j'ai vu un mauvais code nécessitant réellement une refactorisation, il y avait un grand nombre de fonctionnalités non documentées et la complexité des exigences qui ne pouvait pas être comprise dès le départ. Ce n'est pas une entreprise mineure et mon expérience est un ordre de grandeur plus difficile à estimer le coût d'un travail de refactoring que d'ajouter une nouvelle fonctionnalité.

Je m'abstiendrais d'aller de l'avant et de le faire derrière vos chefs (si ce n'était pas cassé, et vous vous l'avez cassé, comment ça ressemble) - réparer le code qui doit changer de toute façon, mais si ce n'est pas cassé, don ' pas le réparer.

Étrangement personne ne le mentionne:

Pour faire des choses une priorité, rendez-les faciles: Obtenez un bon outil de refactoring.

Il existe d'excellents outils de refactoring (du moins pour .NET autant que je sache). Oh, et n'oubliez pas d'écrire des tests unitaires à l'avance (comme d'autres l'ont déjà souligné).

Bonne chance!