Comment gérer le refactoring qui prend plus de plus qu'un sprint?
Je travaille avec une base de code supérieure à 500 000 lignes de code. C'est de grave besoin de refactoring. Il y a eu des efforts de refactorisation identifiés qui prendront plus de temps que le sprint normal de deux semaines. Celles-ci ne peuvent pas être divisées en tâches plus petites que je l'ai vue suggérée dans d'autres réponses sur ce site. Le produit doit fonctionner à la fin de l'itération et le refactoring partiel laissera le système dans un état inutilisable car la dépendance entre les articles est horrible. Alors, quel serait le meilleur moyen d'aborder cet obstacle? Encore une fois, je mentionne, la rompre en pièces plus petites n'est pas une option, qui a déjà été faite.
MISE À JOUR: Les gens semblent avoir besoin d'une explication de la raison pour laquelle cela ne peut pas être adapté à un sprint de 2 semaines. Il y a plus de personnes impliquées dans un sprint que de simplement écrire du code. Nous avons une politique d'aucun code sans tests. Cette politique n'a pas toujours existé et une grande partie du codeBase ne les a pas. De plus, certains de nos tests d'intégration sont toujours des tests manuels. La question n'est pas que le refactoring lui-même est si grand. C'est avec le fait que de petites changements ont un effet sur de nombreuses parties du système et nous devons nous assurer que ces pièces fonctionnent toujours correctement.
Nous ne pouvons pas mettre ou étendre un sprint parce que nous avons des correctifs mensuels. Donc, ce changement s'étendant au-delà d'un sprint ne peut pas arrêter l'autre œuvre ajoutée au correctif.
Refactoring VS Redesign: Juste parce que notre processus de développement n'est pas suffisamment efficace pour gérer que ce refactoring dans un cycle de deux semaines ne justifie pas la renommer à une refonte. J'aimerais croire que, à l'avenir, nous pourrions accomplir exactement la même tâche dans un cycle de deux semaines que notre processus s'améliore. Le code en question ici n'a pas dû changer de très longtemps et est assez stable. Maintenant, comme la direction de la société devient de plus en plus adaptable pour changer, nous voulons que cette partie de la base de code soit aussi adaptable que le reste. Ce qui nécessite de le refléter. Basé sur les réponses ici, il devient évident qu'il manque un échafaudage manquant nécessaire pour rendre ce travail de refactorisation dans la période de sprints normaux.
Réponse:
Je vais faire l'approche de la branche et de la fusion que Corbin March a suggéré la première fois afin que nous puissions en apprendre davantage sur ces problèmes et comment identifier les tests manquants. Je pense aller à l'avance, nous devrions adopter l'approche que BUHB a suggéré d'identifier les domaines qui manquent des tests manquants et de mettre en œuvre ces premiers, puis faire le refactoring. Cela nous permettra de garder notre cycle de sprint de deux semaines normal, tout comme beaucoup ici ont dit qu'il devrait toujours être le cas de refactoring.
Si vous avez le luxe de retarder le refactoring, je suggère de vous concentrer sur les itérations de l'ajout de tests d'unité et de tests d'intégration automatisés au point où vous pouvez refroidir confortablement le codeBase, puis refracteur dans un seul sprint.
Ma suggestion:
- Créer une branche
- Fusionner quotidiennement du coffre à votre succursale et résoudre les conflits.
- Travailler jusqu'à ce que ce soit fait. Votre branche peut être extérieure au développement de base pour plusieurs sprints.
- Fusionner à la coffre.
Il n'y a pas de contourner le fait que cela va probablement devenir laid. Je ne t'envie pas. Dans mon expérience, lorsque vous modifiez radicalement un projet, il est plus facile de fusionner le développement continu dans le nouveau paradigme par rapport à la fusion du nouveau paradigme dans un coffre désormais changé après que tout soit terminé. Pourtant, ça va faire mal.
Toutes les tâches ne peuvent pas être faites dans un sprint (artificiel) de 2 semaines, le bon sens est appelé. Si cela ne peut plus être divisé, et cela doit être fait, il suffit de continuer et de le faire. Le processus n'est pas plus important que le résultat final et devrait être considéré comme une directive plutôt qu'une loi sans danger.
Il suffit de faire un sprint de 3, 4 ou 5 semaines. On s'en fout? Vous êtes évidemment convaincu que rien ne peut être fait dans un délai plus court, alors arrêtez de le combattre.
Il suffit de ne pas dire à vos semblables à la Société royale de l'adhésion agile aveugle.
Je recommande de commencer par le livre fonctionnant efficacement avec le code hérité , par Michael Plumes. Il couvre une variété de techniques pour réduire la portée des changements de style de refactoring.
Dans notre magasin, lorsque nous avons de grandes tâches de refactorisation ou de réécriture qui ne peuvent pas être complétées dans une fenêtre de libération, nous laissons la fonctionnalité comme dans le système. Mais, nous commençons sur les nouvelles fonctions Lego-Block refactored au fil du temps. Finalement, nous arrivons à un état où nous avons suffisamment de blocs dego-blocs, qu'un sprint offre suffisamment de temps pour brancher les blocs LEGO dans l'application et l'allumer pour les utilisateurs.
Plus concis, nous rompons ou retournons de grandes fonctions à l'aide de nouveaux noms. Ensuite, à la fin, nous utilisons notre travail refoulé renommé au lieu du Nasty Old Code.
+1 sur la réponse de Corbin Mars, c'est exactement ce que je pensais. On dirait que votre base de code est un peu laide et cela prendra plus qu'un seul cycle de sprint pour la nettoyer.
Donc, comme le dit Corbin,
- branchez-le dans un "projet de refactoring"
- testez votre changement de branche
- promouvoir votre environnement de test pour les tests d'assurance qualité
- la fusionne progressivement dans le coffre jusqu'à ce que le refactoring soit terminé.
Je suis sûr que vous n'auriez aucun problème à vendre ceci à votre responsable de Dev, si votre PM a eu du mal à le voir, il leur explique alors que Rome n'a pas été construite en une journée et de nettoyer toutes les ordures jetées dans Rome's Les rues ne vont pas être faites dans une journée non plus. Le refactoring prendra un certain temps, mais cela en dirigera bien en termes de maintenance plus facile, de rejets d'amélioration plus rapides, de billets de production moins élevés et d'une SLA plus remplie.
Bien que la refonte que vous souhaitez vraiment faire est une tâche importante, serait-elle possible de refroidir des pièces plus petites pour casser/découpler des dépendances individuelles? Vous savez - en cas de doute, ajoutez l'indirection. Chacune de ces découplages devrait être une tâche plus petite que celle du mammouth que vous ne pouvez pas terminer.
Une fois que les dépendances sont supprimées, vous devriez être capable de rompre les tâches de refactorisation restantes pour pouvoir être obtenues dans les sprints.
Dans le projet, je travaille pour le moment, nous utilisons des sprints de 4 semaines. Et parfois, nous ne pouvons pas terminer une histoire d'utilisateur et nous le redémarrons tout simplement lors du sprint suivant.
Cependant, l'OMHO devrait être possible de rompre un refactoring dans des histoires plus petites qui correspondent à un sprint de 4 semaines. Si vous ne pouvez pas apporter le code dans un état cohérent dans les 4 semaines, j'ai le sentiment que vous réécrivez votre demande plutôt que de le refléter.
Ayant récemment traversé le même problème avec une partie de notre codebase (qui est également un peu plus grand), j'espère pouvoir partager quelques idées avec vous. Dans ma situation, le codebase avait été développé par une autre équipe, à personne n'a été impliqué dans ce refactoring. Mon expérience avec le codeBase était d'environ 1 an, et un autre développeur chargé de 2 ans.
Permettez-moi deux petites notes concernant les autres réponses ici:
- La ramification vous aidera à établir une aire de jeux pour vous-même, mais ne fusionnera jamais vos modifications au coffre dans un grand changement de change. Vous aurez des problèmes graves avec le reste de l'équipe.
- Vous devez le faire progressivement et cela peut être fait. Pas d'excuses. Lire fonctionnant efficacement avec le code hérité Couvercle pour couvrir. Lisez-le à nouveau.
- Pensant que vous pouvez le faire une grosse étape est une erreur. Bien que cela semble plus de travail, le faire progressivement est beaucoup plus facile à gérer.
Aller apparemment "hors réservation" pendant deux semaines ou plus ne passera pas inaperçu. Vous devez vous assurer que vous êtes soutenu par la gestion de projet, et encore plus surtout l'équipe. Si l'équipe n'est pas engagée dans ce refactoring (et cela signifie, faites-le maintenant, pas dans l'avenir lointain), vous aurez des problèmes.
Ne le faites pas seul, utilisez la programmation par paire. Cela ne signifie pas strictement que vous devez vous asseoir devant le même clavier tout le temps, mais peut gérer des tâches petites et étroites (par exemple, des tests d'écriture qui capturent le comportement de cette classe) individuellement.
Faites un refactoring de rayures et traitez-le comme tel. (Une sorte de prototype "à deux pas" refactère, le bit "à deux pas" est important!) Honnêtement, il est peu probable que vous sachiez toutes les implications que votre refactoring aura. Un refactoring des rayures vous aidera à certaines salutations:
- Vous découvrirez des morceaux du système que vous n'avez jamais su qu'ils existaient.
- Vous aurez une bien meilleure vue sur la manière dont les modules interconnectent
- Vous découvrirez une nouvelle façon de regrouper votre système dans des modules, probablement très différent de votre compréhension actuelle. Discutez des idées avec votre partenaire. Essayez de distiller votre nouvelle vue. Écrivez un journal blanc d'architecture courte (ou dessinez un diagramme) qui dit où les choses sont actuellement et où elles doivent appartenir logiquement.
Lorsque vous avez fait votre refactoring de rayures, j'espère que vous découvrirez que vous ne pouvez pas simplement aller et tout changer de partout. Vous vous sentirez mauvais, c'est juste un gros gâchis et vous ne pouvez pas simplement retourner un commutateur et le faire fonctionner. C'est ce qui m'est arrivé, cela pourrait être différent dans votre situation.
Cependant, mon partenaire et moi avons eu une bien meilleure compréhension de notre système. Maintenant, nous avons pu identifier des refacteurs individuels, plus petits (mais toujours importants)/repousses. Nous avons capturé notre vision du système dans un diagramme et nous l'avons partagé avec l'équipe, ainsi que les articles d'arriéré que nous avons proposés pour mettre en œuvre cette vision. Hupéré par un consensus commun, nous avons décidé des éléments que nous allions mettre en œuvre au cours de la prochaine itération.
Une dernière chose qui nous a aidée à utiliser un grand tableau blanc. Il y a trop de choses à garder dans votre tête. C'est tout à fait important que vous gardez des notes. Ecrivez-vous une note de briefing à la fin de la journée, capturant ce que vous avez fait aujourd'hui et que vous voulez faire demain. Cela aide à se détendre de gros fois et vous avez besoin d'un temps détendu si vous voulez suivre la tâche. Bonne chance!
Je recommande que lorsque certaines tâches prennent plus de temps que le cycle de sprint de 2 semaines, la tâche soit pisée pendant une autre fois. Votre équipe a identifié la nécessité de refactoring et qui est importante. Parfois, il n'y a pas d'autre option ... et oui, qui suce.
Lorsque le moment vient à commencer le refactoring, vous allez simplement suspendre les sprints normaux. Vous n'avez pas de choix. Utilisez le contrôle de la version intelligente - Branche, refacteur, test, fusionner. Il y a toujours un point dans le temps où refactore certains grands projets prennent la priorité sur les fonctionnalités. Si possible, j'essaie également de séparer les préoccupations pour une meilleure flexibilité.
Démarrer une fenêtre de maintenance pendant laquelle aucun autre développement n'est effectué. Effectuez la refonte, puis reprenez les sprints de développement.
Une suggestion qui peut aider: si vous avez un code non testé tel que vous n'avez pas suffisamment de temps pour refacteur et le réessayez dans les deux semaines Sprint, envisagez d'abord de faire d'autres petits changements non liés à Le code afin que vous puissiez vous concentrer sur des tests d'écriture pour le premier sprint ou deux. Peut-être que vous pouvez identifier plusieurs clients non testés du code que vous souhaitez refracteur; Choisissez un client et apportez d'autres modifications d'une certaine utilisation pour l'entreprise qui vous obligera à rédiger des tests pour ce client. Une fois que vous êtes plus familier avec le code, de travailler avec elle et que vous avez plus de tests, et vous avez éventuellement accompli quelques réfacteurs contributifs mineurs, vous serez dans une bien meilleure position pour accomplir le refactoring et le (maintenant plus facile ) Testez les deux dans une seule itération.
Une autre approche consiste à effectuer une copie du code fautif, le refacteur, puis déplacez les clients une à la fois du nouveau code. Ce travail peut être divisé à travers les itérations.
Et n'abandonnez pas: n'acceptez pas simplement qu'un important refactoring ne peut pas être décomposé en petites étapes. L'approche la plus facile/la plus rapide/la meilleure pourrait prendre plus de temps qu'une itération. Mais cela ne signifie pas qu'il n'y a aucun moyen de faire des morceaux de taille d'itération.
Nous avons deux types d'œuvres à notre main:
- Works de l'heure de l'homme
- Genius fonctionne
Le refactoring consiste généralement au premier type de travail, car de nombreuses méthodes sont déjà connues pour les développeurs, comme [~ # ~ # ~ ~] , SRP , [~ # ~] OCP [~ # ~ ~] , [~ # ~] di [~ # ~ ~] , etc. Ainsi Lorsqu'un projet prend deux mois à refacter, , il prend simplement deux mois , il n'y en a aucun moyen. Ainsi, ma suggestion serait de ne pas refroidir le projet d'origine et de le laisser travailler sur sa situation actuelle. Arrêtez de recevoir de nouvelles demandes et exigences des parties prenantes et du propriétaire du produit . Ensuite, laissez l'équipe travailler sur le projet jusqu'à ce qu'il soit refactored et prêt à partir.