Comment puis-je faire refactoriser une priorité pour mon équipe?
Le codebase i travaille avec quotidien n'a pas de tests automatisés, de nommage incohérent et de tonnes de commentaires comme "Pourquoi est-ce ici?", "Je ne sais pas si cela est nécessaire" ou "Cette méthode n'est pas nommée à droite" et que le code est jonpé de "Changelogs" malgré le fait que nous utilisons le contrôle de la source. Il suffit de dire que notre codebase pourrait utiliser le refactoring.
Nous avons toujours des tâches pour résoudre des bugs ou ajouter de nouvelles fonctionnalités, alors aucun délai n'est mis de côté au code du refacteur pour être de mieux et plus modulaire, et il ne semble pas être une priorité élevée.
Comment puis-je démontrer la valeur de refactoring de telle sorte qu'il soit ajouté à nos listes de tâches? Vaut-elle la peine de simplement refroidir au fur et à mesure que je vais, demandant le pardon plutôt que la permission?
"Il vaut mieux demander le pardon que l'autorisation" est vrai.
Pourquoi s'inquiète de ça? Il suffit de refroidir les parties les plus horribles.
Vous savez déjà ce que le les plus coûteux erreurs sont, non?
Si vous ne le faites pas, alors l'étape 1 est de définir de manière positive et sans ambiguïté le code de problème le plus coûteux, complexe et infesté par des erreurs.
Identifiez le nombre de billets de troubles, des heures de débogage et autres très spécifiques, très mesurables coûts.
Puis corrige quelque chose sur cette liste de coût élevé problèmes.
Lorsque vous devez demander pardon, vous pouvez indiquer des réductions de coûts.
Si vous n'êtes pas au courant, refactoring nécessite unité tests pour prouver que les comportements avant et après correspondent. Idéalement, cela devrait être un test automatisé et codé, par exemple un test unitaire.
Cela signifie choisir un chose. Écrivez un test de l'unité. Réparer cette chose. Vous avez fait deux améliorations. (1) a écrit un test et (2) corrigé le code.
Répéter.
Suivez la règle Boy Scout: Laissez un peu mieux le camping (code) que vous l'avez trouvé. Je n'ai jamais entendu parler de quelqu'un d'être écrit pour avoir apporté de petites améliorations de code "alors qu'ils étaient là."
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 refactoring, vous vous battez pour l'excellence en ingénierie, et c'est le genre de changement qui ne se lève que sur la direction lorsqu'il les frappe au visage. Dans ce scénario, ils vont probablement regarder à l'extérieur pour obtenir les meilleures pratiques tsar, et toutes vos bonnes idées seront de toute façon altérées.
Envisagez de rejoindre une autre entreprise où elles prennent des pratiques d'ingénierie plus au sérieux.
Je remarque que de nombreuses affiches ici semblent être convaincues que le problème de la gestion - alors que la question ne mentionne pas cela.
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, les développeurs ont fait (il y a quelques exceptions à ma société où une partie de notre gestion actuelle a réellement écrit la base de code initiale). Par conséquent, le problème de la culture réside avec les développeurs - s'ils veulent que la culture change, elles devront eux-mêmes changer.
J'essaie de mener à bien cette réalisation et de changer d'attitude à "Mes" développeurs. Chaque fois qu'ils me demandent "quand aurons-nous le temps de refracteur?", J'agis surpris et répondre "Vous devriez déjà refacter tout le temps!". La seule façon dont je pense que vous pouvez garder une base de code en bonne santé est trois fois:
- Seulement ajoutez un code sain.
- Toujours réparer le code non so sain dès que vous le voyez.
- Si, pour des raisons de délai, vous ne pouvez pas faire 1 ou 2, avez toujours une liste de "correction immédiatement après la date limite", et n'acceptez aucune excuse pour ne pas fonctionner à travers cette liste après la date limite.
invariablement la prochaine remarque 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 (à nouveau IMHO) est "Vous n'avez pas le temps de ne pas le faire.". Si vous ne conservez pas la base de CodeBase, vous trouverez un délai d'exécution de la transmission plus longue et plus longtemps, les horaires deviennent plus imprévisibles, les bogues deviennent nuls et que la valeur augmente.
La plus grande modification de l'attitude que vous devez effectuer dans l'équipe de développement est que la "qualité" n'est pas quelque chose que vous faites à un moment donné ("lorsque nous avons le temps de refacteur") - c'est quelque chose que vous devez faire tout le temps.
Enfin, une histoire d'avertissement. Si vous êtes pressé, je le refuserai jamais. Lors d'une entreprise, j'ai travaillé pour qu'il y a eu une application de longue date avec une grande base de code héritée originaire de plus de 10 ans. Beaucoup de développeurs, dont moi croyions que ce code de code hérité était mauvais ou du moins obsolète, pas la pointe de la technologie. Nous avons donc fait pression pour un grand projet de refactorisation avec succès et avons commencé le projet de réécriture après lequel nous croyions que tout serait mieux.
[.____] Nous avons travaillé longtemps et difficile à mettre en œuvre presque tout de manière moderne, en utilisant de nouvelles bibliothèques, de nouvelles fonctionnalités linguistiques. Près de la fin, nous avons mis en place un effort important pour intégrer tout ensemble pour permettre une nouvelle libération de l'application de longue date avec la nouvelle base de code améliorée.
[ Cependant, nous avons finalement réussi à obtenir la libération au même standard que nos versions précédentes et à la porte. Nous avons respiré un soupir de soulagement à notre "succès". Ensuite, un sous-groupe de développeurs est retourné à la direction, demandant un nouveau projet de refactorisation, car notre nouveau code n'était pas tout à fait la balle d'argent qu'ils s'attendaient à ce que ce soit, et ils ont vu certaines occasions de réécrire complètement certaines choses ...
Morale de l'histoire: Les choses ne sont souvent pas aussi brisées qu'elles semblent et "à partir" signifie généralement que vous échangerez un ensemble connu de problèmes avec un ensemble de problèmes inconnu à la fois à la fois. Refacteur une partie à la fois!
Quelqu'un m'a dit une fois que lorsque je vais à une interview, je ne devrais pas oublier que j'interviewe aussi l'entreprise. Est-ce un endroit où je veux travailler? Est-ce qu'ils font des critiques de codes? Ont-ils des tests d'intégration automatisés? Tests unitaires? Que pensent-ils de la programmation par paire? Personnellement, je trouverais un autre emploi et n'oubliez pas de poser des questions aussi cette fois.
Trouvez une autre entreprise, honnêtement. De telles améliorations apportées au processus de développement nécessitent d'énormes sauts culturels qu'il prend une période significative avant que tout le monde ne soit sur la même page et que vous ne vous souciez pas autant.
Si vous avez envie d'avoir encore un peu de combat en vous et que vous n'êtes pas encore passé, alors faites une dernière pression. Essayez d'obtenir autant de soutien des membres de l'équipe des mêmes idées, divulguez votre épuisement aux supérieurs qui se soucient de votre bien-être, de pontage et de la distance de votre bien-être et de la distance qui pourraient s'opposer à vos convictions et essayer de faire pousser des heures de refactorisation obligatoires à la planification de la nouvelle Projets/fonctionnalités.
Si votre passionné de ce que vous faites et que vous vous souciez de votre entreprise, ce serait un effort louable de votre côté. Si ce n'est pas apprécié, alors respectez-vous et cautionnez-vous avant de vous transformer en programmeur creux.
Si je devais introduire une pratique pour améliorer les choses dans ce type de contexte, ce serait des critiques de code. Les critiques de code sont
- généralement intuitivement accepté par les développeurs comme facteur de meilleur code, moins de bugs, etc.
- collaboratif et démocratique
- pas trop de temps si vous les timbox-battre correctement
- un bon endroit à refactoriser si vous n'avez pas le temps de le faire pendant le développement "normal"
- un cheval de Troie assez efficace pour présenter progressivement toutes sortes de meilleures pratiques en termes de conception de code, de tests unitaires ...
Vous n'êtes pas obligé de faire des critiques de codes systématiquement, uniquement lors de la validation des portions de code importantes/complexes au début.
Bien sûr, si vous pensez avoir besoin d'avance officielle avant d'introduire des critiques de code, vous devrez peut-être convaincre votre patron que la base de code est susceptible de s'effondrer si des choses sont laissées comme elles sont.
Voici ce que je fais dans de telles situations (au cours des 15 années de ma carrière en tant que développeur, je suis venu à travers ce code presque tous les jours)
- Prêcher par l'exemple - je fais en sorte de re-facteur toucher le code I. Supprimer sans pitié vieux code et commenté grands paragraphes de commentaires.
- Demandez refactoring chaque fois que je me demande d'examiner un changement de code, sans que je ne l'approuve pas la révision du code.
- Lentement, les gens voient le changement, lorsque le code devient plus maigre, plus lisible et donc moins buggé. Il faut du temps, mais lentement toute l'équipe apprécie et adopte la pratique.
La direction ne met jamais de côté le temps pour le code refactoring (ils ne disposent de ressources suffisantes!), Ce faisant, il est lentement et de façon constante une bonne approche.
Demandez à la gestion des recherches sur la "dette technique". Les renvoient également à la "théorie de la fenêtre cassée", ces deux effets ont un impact direct sur l'efficacité, la qualité et le moral.
"Un chantier propre est un lieu de travail sûr et productif", et chaque contribution à un désordre compose le désordre de manière exponentielle et non linéaire.
Si la situation n'est pas traitée, vous finirez par traverser un point de non-retour, où il devient économiquement infaisable, en traitant de cela progressivement avant que cela se produise, les avantages vont rebondir, vous donner plus de carburant pour faire face au problème que vous allez.
On dirait que vos problèmes sont plus généraux.
[.____] Le problème de refactorisation est à la fois un symptôme et un soulagement potentiel de la partie du problème.
La tête du logiciel et l'équipe allouent l'heure de l'équipe
De mon expérience, je pense que vous pouvez rencontrer un problème que j'appelle, "Tout le monde est un gestionnaire de logiciels". Les gestionnaires de produits, les chefs de projet et parfois les ingénieurs et les testeurs du système peuvent être notoires pour tenter de gérer les développeurs de micro-gérance qui ont probablement déjà un gestionnaire de logiciels expérimenté. Vous pouvez même avoir quelques membres de votre équipe qui croient que leur rôle est de gérer.
Si vous êtes le gestionnaire de logiciels, effectuez des missions pour le refactoring que vous souhaitez ou mieux encore, votre équipe vous propose de vous refactoriser pour votre approbation. Donc, comme pour ne pas micromanage, vous pourriez avoir des directives sur l'âge/l'auteur/la taille/le contexte du code à refacter qui peut être librement refactored contre une approbation nécessaire. Si un membre de votre équipe souhaite refroidir massivement quatre grandes classes d'un code ancien complexe, il n'a pas écrit que cela ne faisait pas partie de sa fonctionnalité, sa diversion de deux semaines est votre problème, vous avez donc besoin d'une chance de dire non.
Vous pouvez vous faufiler, mais je pense qu'il vaut mieux construire vos estimations avec précaution avec le temps d'analyse, de conception, de codage, de multiples formes de test (au moins une unité et une intégration), de refactoring et de risque comme jugés historiquement et par le manque de expérience ou clarté associée à la tâche. Si vous êtes trop ouvert sur le fonctionnement de votre équipe (ou si vous avez des membres de votre équipe), il peut être judicieux de réduire les canaux de communication afin qu'ils puissent vous traverser des ressources et des résultats, et non des méthodes.
Les choix de projets précoces créent un cycle vicieux de refactoring
La maintenance logicielle est difficile. Il est doublement difficile si d'autres personnes de l'organisation font des choix à vos frais. C'est faux, mais ce n'est pas nouveau. Barry Boehm a été traitée par Barry Boehm qui est l'un de nos grands écrivains de logiciels qui proposent un modèle de gestion qu'il décrit comme la théorie W.
http://csse.usc.edu/csse/techrpt/1989/usccse89-500/usccse89-500.pdf
Souvent, les développeurs de logiciels sont martelés pour produire en vertu de l'approche de gestion de la théorie-x qui dit que les travailleurs sont essentiellement paresseux et ne seront pas effectués à moins que la soumission ne soit pilée. Boehm résume et contraste son modèle proposé comme suit:
"Plutôt que de caractériser un gestionnaire comme autocrate (théorie X), un entraîneur (théorie Y) ou un facilitateur (théorie z), la théorie w caractérise le rôle principal d'un gestionnaire de négociateur entre ses différentes circonscriptions et un emballager de solutions de projet Avec des conditions de victoire pour toutes les parties. Au-delà de cela, le gestionnaire est également un ensemble d'objectifs, un moniteur de progrès vers des objectifs et une militante pour rechercher des conflits de projets de perdants quotidiens ou perdant - perdant des conflits de projets, les confrontées à des conflits. et les changer dans des situations gagnant-gagnant. "
rapide et sale est souvent juste sale
Boehm continue à souligner la raison pour laquelle les choses sont si malheureuses pour les développeurs de l'équipe de maintenance.
"Construire un produit rapide et bâclé peut être une" victoire "à court terme pour le développeur de logiciels et le client, mais ce sera une" perdre "pour l'utilisateur et le mainteneur". Veuillez noter que dans le modèle de Boehm, le client est davantage d'un administrateur de contrat au lieu d'un utilisateur final. Dans la plupart des entreprises, pensez au gestionnaire de produits en tant que client de substitution client, ou peut-être la personne qui achète le produit pour sa liste de fonctions.
Ma solution ne serait de ne pas publier l'équipe de développement d'origine (ou au moins la tête d'origine) jusqu'à ce que le code soit refoulé au moins répondre aux normes de codage.
Pour le client, je pense qu'il est raisonnable de compter le gestionnaire de produits comme substitut client, et le groupe de personnes récompensé pour la livraison rapide et sale peut certainement être élargi, il y a donc une grande circonscription pour faire des choses dans le mauvais sens.
Le refactoring n'est pas négociable
S'il vous plaît ne revenez pas de votre rôle de gestionnaire de logiciels. Vous devriez avoir l'autorité et la discrétion d'utiliser le temps de votre équipe dans des améliorations de processus et de produits. 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 dans mon expérience, c'est un jeu perdant. Négocier avec la gestion de l'ingénierie. Cela montre que vous avez une vision. Construire une équipe de logiciels professionnels est une extension de leur rôle et est beaucoup plus susceptible d'être considérée comme une victoire gagnant-gagnant.
Vous pouvez toujours simplement attendre. Finalement, l'équipe manquera suffisamment de délais et produira des logiciels suffisants de la buggy, cette direction jettera ses mains et dire que par Dieu quelque chose Avait de mieux changer!
D'accord, c'est une proposition risquée. Mais c'est en fait ce qui s'est passé dans notre magasin il y a plusieurs années (une partie de la difficulté consistait à communiquer avec la direction environ Dates limites, mais c'est une autre histoire), et c'est une grande partie de la raison pour laquelle nous avons maintenant des dizaines de milliers de Tests automatisés, propriété du code partagé, la liberté du refacteur, la volonté de supprimer le code mort et des versions de la plus haute qualité que nous ayons jamais eues.
Peut-être surprenant surprenant, personne n'a perdu son emploi dans le processus - quelque chose que j'ai crédité à notre patron qui vient à la batte pour nous et un consultant qui a fait valoir l'affaire de refactorisation et d'intégration continue en notre nom. Cela semble toujours plus convaincant quand c'est quelqu'un de l'extérieur en disant.
Le code a été de cette manière lentement sur de nombreux petits changements. Il aura besoin de résoudre de cette façon aussi.
Vous pouvez le faire comme vous le suivez, 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-leur s'il préférable de vérifier l'huile dans un moteur de voiture chaque semaine ou d'attendre que le moteur se bloque complètement.
Avoir une réunion et déterminer des normes de codage consistantes.
Introduisez des règles de base à utiliser comme vous suivez:
Chaque fois que un nouveau code est introduit dans une classe, des tests automatisés doivent être écrits pour prouver les travaux de classe (pas seulement le nouveau code).
Chaque fois qu'un bogue est corrigé, des tests automatisés doivent être écrits pour prouver les travaux de classe (pas seulement le code fixe).
Chaque fois qu'un programmeur modifie un fichier, il doit corriger tous les avertissements du compilateur dans ce fichier et le code de mise à jour afin qu'il réponde aux nouvelles normes de codage.
Après un certain temps, le code le plus utilisé sera à jour et être couvert par des tests automatisés. Le code ancien sera mis à jour lors de son changement, s'il n'est jamais changé, vous n'avez jamais besoin de vous en soucier.
L'important est de construire ces habbits dans les tâches de codage standard afin qu'aucun d'entre eux ne prenne beaucoup de temps loin du travail "réel", mais ils offrent tous de vrais avantages. N'essayez pas de faire un projet de refactoring vieux code, c'est une douleur horrible, ennuyeuse et folle qui ressemblera à beaucoup de temps à gaspiller des non-techniques!
J'ai ri un peu à la façon dont vous avez décrit des choses comme ça sonne assez semblable à la base de code que je travaille, donc je pense que nos situations sont assez similaires. Heureusement, dans ma situation, j'ai un responsable prospectif qui a décidé que la meilleure façon de rendre le codebase mieux consiste à améliorer la modularisation à l'aide d'un cadre de développement Web moderne plutôt que de simplement refacturer l'intégralité du codeBase. De cette façon, les taches gênantes de l'application principale peuvent être réécrites comme des modules distincts, puis être intégrés à l'application principale (mais toujours être essentiellement indépendants). Cela peut être une approche que vous souhaitez élever car elle ne nécessiterait pas de refactoriser l'intégralité de la base de code (Présumable de grande taille?) Avec laquelle vous travaillez.
Bien sûr, je peux être un peu désactivé de ce que vous dites que votre base de code n'est peut-être pas aussi mauvaise que celle que je travaille, dans ce cas, je dirais pourquoi ne pas faire de petites optimisations comme vous le suivez? Les devations de mon équipe n'ont aucun problème à supprimer des commentaires stupides ou obsolètes et des choses de cette nature et je ne pense pas que c'est quelque chose qui devrait nécessiter une contribution de la direction, car les développeurs habituellement reçoivent une certaine autonomisation pour optimiser les choses nécessaires.
Si la base de code est vraiment fragile, vous devez faire attention et cela peut être la raison pour laquelle ils peuvent ne pas vouloir poursuivre des refacters majeurs, car cela pourrait finir par se transformer en un projet de long mois et nécessiterait probablement une ramification d'un projet et de mettre des devations à ce sujet. projet et enlever d'autres tâches de développement, comme des corrections de bugs immédiats pouvant les amener à perdre des clients, etc.
Toutes les choses considérées, en ce qui concerne les autres personnes qui disent que vous devriez quitter, etc., je pense que cela dépend de la manière dont la direction voit les choses, s'ils comprennent la situation et se rendent compte pourquoi certaines choses peuvent prendre plus de temps qu'elles ne devraient plus de temps, alors les choses pourraient être bien comme En ce qui concerne l'environnement de travail, mais s'ils vous engagent constamment sur un arriéré de travail, cela pourrait devenir préjudiciable au fil du temps. J'ai la chance d'avoir une gestion qui réalise essentiellement que l'application est un morceau de merde, mais il a beaucoup de clients et apporte de l'argent, donc sa valeur toujours précieuse et valable de faire des corrections de bugs, même si juste pour le court terme .
Votre problème principal est que les codes ne reçoivent pas assez de visibilité.
Je suggère à l'aide d'un outil d'intégration continue comme Jenkins et un outil analisys de code statique est intégré à celui qui mesure la complexité cyclomatique, les normes de dénomination, la longueur du code, etc.
Lorsqu'un programmeur commet une modification, Jenkins exécutera les tests d'unités, exécutez l'outil analisys de code statique et générera un rapport Web que tout le monde peut voir, avec un état de couleur de type circulation.
Lorsque la qualité du code est visible pour tout le monde (spécialement, le contrôle de l'équipe et le patron) et le contrôle de la version et des tests unitaires sont là pour avoir votre dos ... Les gens se sentent encouragés à refacteur.
Étrangement personne ne mentionne ceci:
Pour rendre les choses une priorité, les rendre faciles: obtenir un bon outil de refactoring.
Il existe d'excellents outils de refactorisation (au moins pour .net afaik). Oh, et N'oubliez pas d'écrire des tests d'unité à l'avance (comme d'autres déjà signalés).
Bonne chance!
Le moyen d'obtenir les ressources (heure) dont vous avez besoin est de vous concentrer sur l'alignement des capacités et du désir. Votre patron est motivé par des cibles (généralement des bénéfices ou des délais de livraison pour de nouvelles fonctionnalités), et il voit refactoring en tant qu'ingongeurs qui gaspillent du temps et de manger dans ces objectifs. Vous devez trouver un moyen de le convaincre que les objectifs seront respectés et dépassés si vous passez du temps à refactoriser.
Donc, la première étape est de savoir quelle douleur vous ressentez. Identifier ce que sont ses plus gros problèmes. Ensuite, déterminez comment ce que vous voulez faire aligner avec la correction de ses problèmes et présenter une analyse de rentabilisation forte pour le faire. Utilisez vos systèmes de suivi des défauts et de planification de projet (dépassements de temps) pour fournir la preuve des problèmes qui mentent. Vous avez besoin de faits, pas de sentiments. Sans métriques (nombre de bogues/module, coût pour les corriger), le refactoring n'est qu'un programmeur ayant une pièce de jeu à la charge de quelqu'un. Votre patron ne vous donnera que les ressources nécessaires si vous pouvez montrer une analyse de rentabilisation forte pour le faire.
Le code de la merde est plus souvent plus coûteux à réparer. S'agissant des tests de régression automatisés, le coût du test du code refoulé est extrêmement élevé.
La plupart des temps, j'ai constaté un mauvais code dans le besoin réel de refactoring, il y a eu un grand nombre de caractéristiques et de complexité sans papiers dans les exigences qui ne peuvent pas être comprises depuis le début. Ce n'est pas une entreprise mineure et mon expérience est une ordonnance de grandeur plus difficile d'estimer le coût d'un emploi de refactorisation que d'ajouter une nouvelle fonctionnalité.
Je m'abstiendrais d'aller de l'avant et de le faire derrière vos patrons de retour (si ce n'était pas cassé, et que vous vous avez cassé, comment cela semble-t-il) - corriger le code qui a besoin de changer de toute façon, mais si ce n'est pas cassé, Don ' t réparer ça.