Est-il une bonne idée de programmer un temps régulier pour nettoyer le code?
Je gère une petite équipe de développeurs. De plus, nous décidons que nous allons passer une journée ou deux pour nettoyer notre code.
Serait-ce une bonne idée de planifier une heure régulière, par exemple une semaine tous les 2 mois, pour nettoyer notre codebase?
Non.
Réparez-le pendant que vous travaillez dessus:
- Si vous attendez de refacturer le bit que vous travaillez, vous n'oublierez pas beaucoup de choses à ce sujet et de passer du temps à vous familiariser à nouveau.
- Vous ne finirez pas le code "Gold-Playing" qui finit jamais être utilisé car les exigences ont changé
Mon opinion personnelle: c'est absolument nécessaire pour 90% des projets.
En particulier pour les projets qui sont fortement motivés par les ventes, il y a généralement une grosse pression pour y compris de nouvelles fonctionnalités dans chaque libération, et vous finissez inévitablement à faire de compromettre votre meilleur instinct et à introduire quelques kilomètres/hacks ici et là-bas.
Finalement, vous avez accumulé suffisamment de "dettes techniques" à travers ces petits compromis que vous finissez par dépenser une juste quantité de temps de travail autour des défauts de la base de code et que vous ne pouvez pas utiliser à son plein potentiel.
Habituellement, il existe deux types de problèmes générés de cette manière:
- Petits qui peuvent facilement fixer mais peuvent être systémiques, par ex. De manière incorrecte des paramètres nommés, une manipulation des erreurs incomplètes, etc. Ils auront généralement peu d'impact en dehors du bloc de code où ils apparaissent. La meilleure façon de faire face à ceux-ci est des critiques de code et de vérifier le code car il est écrit/modifié. Comme d'autres l'ont dit, il n'est pas nécessaire de mettre de côté un cycle de refacteur spécial pour résoudre ces erreurs.
- Les grands qui ont peut-être produit des spécifications incomplètes ou des décisions de conception médiocres tôt, ou deux développeurs/équipes créant deux solutions différentes au même problème. Celles-ci sont généralement beaucoup plus difficiles à résoudre et nécessitent un effort concerté pour résoudre. En conséquence, ils sont généralement différés, jusqu'à ce que la nuisance perpétuelle. Ces types de problèmes nécessitent une période de temps dédiée à réparer.
J'essaie généralement de réserver du temps pour un cycle pur refactorring/bogue tous les 3 à 4 cycles. Je demande toujours à mes développeurs de me dire quand ils se sentent frustrés par la base de code. Tous les développeurs ne doivent pas travailler sur l'effort de nettoyage - vous pouvez généralement (mais pas toujours) surcharger les équipes un peu, alors qu'une seule équipe travaille sur le nettoyage à tout moment.
Mes développeurs rangerent leur code avant la vérification (subversion) ou la fusion avec la principale branche de développement (GIT).
Je les ai les suivantes:
- Supprimer les commentaires non pertinents
- Assurez-vous que leurs méthodes, arguments et variables sont correctement nommées
- Assurez-vous qu'il y a une structure à leurs classes et que les articles sont encapsulés car ils devraient être
- Refacteur pour améliorer la lisibilité et réduire toutes odeurs de code
Pour les projets plus importants, le code est examiné formellement avant la fusion de la branche de développement à la branche principale.
Je pense que "le temps consacré" signifiera que c'est quelque chose qui pourrait être différé ou reporté en raison de la quantité de travail impliquée. En présentant des développeurs, le faire sur un Per-Checkin (ce qui équivaut à une demande de changement/problème dans la JIRA), il est beaucoup plus gérable.
Pas à mon avis. Si vous laissez trop de temps aller entre lorsque vous rencontrez de la dette technique et lorsque vous le réparez, vous perdez le contexte de ce que le problème est. Il faut plus de temps à réparer et il a tendance à être réparé. Plus important encore, les gens quittent les fenêtres cassées car ce n'est pas "Nettoyer la semaine".
Personnellement, je négocie pour le nettoyage de la dette technique chaque sprint si je sais que nous avons créé certains dans le sprint avant. Il garde la dette fraîche dans l'esprit des gens. Il limite la quantité de code à l'aide du code de problème afin que le refactoring soit plus facile. Il empêche la dette technique d'accumuler. Et cela aide à pousser les développeurs de simplement gifler quelque chose ensemble, car je vais juste faire leur faire le faire juste à côté du sprint (alors pourrait aussi bien le faire en premier lieu).
Je dirais définitivement oui, avec une réserve: cela devrait être fait souvent, de préférence sur une base hebdomadaire. Je crois qu'un examen régulier régulier est associé à une action en réalité sur les articles qui sortaient de la révision du code revient très rapidement. Voir la réponse de P.S.W.G.
1 semaine tous les 2 mois ne suffit certainement pas assez souvent. Cela parle de la plupart des autres réponses qui ont répondu avec "non" à votre question. Le gist de la plupart de ces réponses est que si vous attendez trop longtemps, vous ne serez plus en contact avec le code et il faut généralement beaucoup plus de temps pour fixer/nettoyer/refacteur.
Je pense que les deux réponses "non" "non" "non populaires" sont deux aspects de la même vérité. Rappelez-vous que l'OP parle d'un groupe qu'il gère, pas seulement lui-même en tant qu'individu. Nous ne pouvons pas supposer que tous les développeurs du groupe sont suffisamment disciplinés pour écrire un code propre et facilement lisible; Et il y a la question de la pression externe et des méthodologies de style agile. De plus, même avec les meilleurs efforts des gens, leurs différences de style voudraient signifier qu'ils pourraient écrire du code qui serait considéré comme propre quand séparément, mais impur, quand on considère ensemble avec d'autres personnes (sans parler des interfaces craquantes).
D'autre part, le "réparez-le en travaillant dessus" est à mon avis un idéal pour aspirer. Vous pouvez faire venir votre code encore plus "fixe" par
- selon des pairs prudents
- tests d'unité d'écriture avec le code lui-même
- adopter des directives de codage
- utiliser des formateurs et des prêteurs automatiques (mais YMMV)
- etc.
Maintenant, si l'équipe de l'OP adopte ce qui précède, et s'il encourage ses subordonnés - par ex. Pendant les revues de code et lors de sessions de nettoyage de code périodiques - essayer d'anticiper les pièges et d'éviter à l'avance la laideur, au fil du temps, il aura besoin d'un temps de nettoyage moins de nettoyage. (Et puis ils pourraient consacrer ce temps à la documentation, au refactoring plus profond et au partage des connaissances de ce qu'ils ont écrit et consolidé.)
Je pense que la planification régulière est très bonne, qu'il s'agisse d'une tâche dans un projet de style de cascade régulier ou des histoires d'une agile. Avoir un moment déterminé peut ne pas être aussi précieux que de le faire simplement dans votre horaire. Cela vous permet de le faire faire dans le cadre de la journée d'annulation par rapport à l'annulation du nettoyage, car vous êtes en retard sur le projet.
Après avoir géré un projet qui avait une quantité énorme de dette de code, les travaillant régulièrement étaient essentiels pour que les choses fonctionnent en douceur. Certaines de nos choses étaient grandes, certaines étaient petites.
Après quelques mois de ce type de travail, notre équipe d'opérations m'a dit que tout était lisse.
Chaque article peut ne pas sembler beaucoup, mais comme toute la dette, elle annonce.
La réponse idéale est non, car vous prenez les mesures nécessaires pour éviter de faire une nécessité (nettoyer comme vous allez pour plusieurs raisons déjà indiquées).
Cela peut être le but à la fin, mais vous pouvez avoir une équipe qui est loin de la mettre en pratique.
Les gestionnaires doivent prendre des responsabilités, ce n'est pas toujours la faute du développeur. Les gestionnaires peuvent dire une chose, mais ils commencent à pousser des projets pour se terminer et faire des suggestions qui favorisent les mauvaises pratiques. Ils peuvent littéralement dire: "Nous le nettoierons plus tard" ou si cela fonctionne, c'est assez bon.
Vous devrez peut-être commencer par consacrer une période donnée pour montrer que cela est important. Une fois que vous savez que votre équipe est capable de nettoyer leur code (pas une donnée), vous pouvez essayer de l'intégrer plus fréquemment.
Finalement, vous ne devriez pas avoir à régler un temps.
Personnellement, j'ai du mal à résoudre un nouveau problème et à le faire travailler tout en essayant de garder les choses bien rangées. Je m'améliore mieux, mais prenez souvent une pause délibérée et des choses propres. C'est un exemple différent pour moi. Finalement, les pratiques solides deviennent une habitude.
Ce n'est pas si clair si vous vouliez dire un exercice d'un code de code propre supplémentaire de temps en temps. En ce sens, oui. Quelles pratiques que nous suivons, une certaine dégradation se produit toujours.
Vous ne devez pas l'utiliser comme excuse pour ne pas faire la bonne chose [appliquer SOLID Principes, tests d'unités pertinentes, inspections, etc.] en premier lieu.