Maintenance du code: Garder un mauvais modèle lors de la prolongation du nouveau code pour être cohérent ou non?
Je dois étendre un module existant d'un projet. Je n'aime pas la façon dont cela a été fait (beaucoup d'anti-modèle impliqué, comme le code de copie/colle). Je ne veux pas effectuer un refacteur complet pour de nombreuses raisons.
Devrais-je:
- créer de nouvelles méthodes utilisant la convention existante, même si je me sens mal, d'éviter la confusion pour le prochain mainteneur et d'être cohérent avec la base de code?
ou
- essayez d'utiliser ce que je me sens mieux même s'il introduit un autre modèle dans le code?
Présison édité après les premières réponses:
Le code existant n'est pas un gâchis. Il est facile de suivre et de comprendre. Mais il introduit beaucoup de code de la chaudière qui peut être évité avec une bonne conception (le code résultant peut devenir plus difficile à suivre). Dans mon cas en cours, c'est un bon vieux module JDBC (modèle de printemps) DAO, mais j'ai déjà rencontré ce dilemme et je cherche d'autres commentaires sur Dev.
Je ne veux pas refroidir parce que je n'ai pas le temps. Et même avec le temps, il sera difficile de justifier qu'un module de travail parfait a besoin de refactoring. Le coût du refactoring sera plus lourd que ses avantages. Rappelez-vous: le code n'est pas en désordre ou trop complexe. Je ne peux pas extraire quelques méthodes là-bas et introduire une classe abstraite ici. C'est plus une faille dans la conception (le résultat d'Extreme 'Gardez-le stupide Simple', je pense)
La question peut donc être posée comme ça:
Vous, en tant que développeur, préférez-vous maintenir facilement un code ennuyeux stupide OR pour avoir des aides qui feront le code ennuyeux stupide à votre place?
Inversement de la dernière possibilité d'être que vous devrez apprendre des trucs et que vous devrez peut-être maintenir le code ennuyeux facile aussi stupide jusqu'à ce qu'un refactoring complet soit effectué)
Le refactoring est le mieux fait en petites étapes et de préférence uniquement si vous avez des tests d'unités pour couvrir le code. (Donc, si vous n'avez pas encore de tests, recherchez-les d'abord de les écrire, et jusque-là coller sur les refacteurs les plus simples, les plus infaillibles, de préférence automatisés. Une bonne aide à cet égard est fonctionnant efficacement avec Code hérité par Michael Plumes.)
En général, visez à améliorer le code un peu chaque fois que vous le touchez. Suivez la GOY SCOUT RÈGLE ( inventé par Robert C. Martin ) en laissant le code nettoyeur de code que celui trouvé. Lorsque vous ajoutez un nouveau code, essayez de le garder séparé du mauvais code existant. Par exemple. Ne l'enterez pas au milieu d'une méthode longue, ajoutez plutôt un appel à une méthode distincte et placez votre nouveau code. De cette façon, vous cultivez des îles des îles Nettères (ER) progressivement plus grandes dans la base de code existante.
Mettre à jour
Les coûts de refactoring seront plus lourds que ses avantages. [...] vous, en tant que développeur, préférez-vous maintenir un code ennuyeux facile et plus stupide OR avoir des aides qui feront le code ennuyeux stupide chez vous?
J'ai souligné lequel je crois que le point clé ici. Il vaut toujours la peine d'évaluer les coûts et les avantages du refactoring avant nous y saurons. Comme dans votre cas, la plupart d'entre nous ont des ressources limitées pour le refactoring, nous devons donc les utiliser judicieusement. Dépensez ce peu de temps précieux sur refactoring où il apporte le plus d'avantages avec le moins d'effort.
Comme un esprit créatif, je préférerais bien sûr produire un code parfait, beau et élégant et réécrire tout ce qui ne ressemble pas à mes idéaux :-) En réalité, je suis payé pour produire des logiciels qui résoutent de vrais problèmes pour ses utilisateurs, donc je devrait penser à produire le plus de valeur pour leur argent à long terme.
L'avantage du refactoring n'apparaît que s'il y a suffisamment d'économies dans le temps et les efforts pour comprendre, maintenir, résoudre et étendre le code à long terme . Donc, si un morceau de code - même laide, c'est - est rarement ou jamais touché, il n'y a pas de bugs connus et je ne connais aucune fonctionnalité à venir dans un avenir prévisible qui vous obligerait à le toucher, je préfère partir c'est en paix.
Puisque vous n'avez pas le temps de refracteur et que le code est maintenu, gardez-le cohérent. La prochaine fois, assurez-vous d'inclure le refactoring dans l'estimation.
cohérence a une priorité élevée. Évidemment, tout le monde dans son esprit de droite préférerait une élégante DRY au lieu de la chaudière collée de copie partout, mais Vous préférez vraiment deux approches différentes du même codebase pour avoir une application de manière systématique? Et si quelqu'un invente une solution encore plus intelligente et l'applique également de manière incohérente? Ensuite, vous avez trois façons différentes de faire la même chose.
J'ai vu beaucoup de code désordonné résultant de développeurs trouvant une "meilleure façon" de faire quelque chose, mais de ne pas l'appliquer de manière cohérente sur une base de code. S'il fait partie d'une stratégie planifiée et coordonnée visant à appliquer un nouveau schéma progressivement au fil du temps, cela peut fonctionner, mais chaque modèle mis en œuvre de manière incohérente risque de rendre le système global pire.
Peut-être que vous pourriez envisager de refactoriser des étapes plus petites, de sorte que chaque étape puisse être appliquée sur toute la base de code en une seule fois. Par exemple. extraire une partie inférieure de la chaudière à une fonction d'assistance dans chaque itération. Au fil du temps, vous vous retrouvez avec tous les chaudières dans une classe d'assistance. Il peut sembler vraiment moche car il n'a pas été conçu mais grandi, mais vous pouvez résoudre ce problème maintenant parce que vous avez tout le code au même endroit.
Être cohérent uniquement au sida Le prochain développeur lorsque le code environnant est en bonne forme. Pensez à combien de temps cela vous a fallu pour comprendre le code à la main et trouver le bon "points d'extension" pour ajouter vos modifications. Si vous suivez la tendance actuelle, le prochain gars doit comprendre le code existant ainsi que votre nouveau code lorsqu'il doit apporter des modifications.
Si vous refactorisez le code dans des fonctions significatives, le gars suivant aura une période plus facile à comprendre ce qui se passe et devra prendre moins d'efforts pour ajouter ses changements. Pense-y de cette façon. Supposons que le prochain gars est toi. Que préféreriez-vous voir lorsque vous revisitez ce bloc de code, le même désordre que vous regardez maintenant, ou quelque chose de plus logiquement construit?
Tout refactoring qui élimine le code dupliqué est un bon refactoring et ne devrait pas être reporté à moins que la date limite ne soit imminente. Le temps passé à refactoriser une fois, est facilement décidé par temps gagné dans les futures implémentations. Grâce au refactoring, les travaux intérieurs ne sont plus visibles, il devrait donc être plus facile de comprendre, pas plus difficile à suivre.
À mon avis, il s'agit d'une idée fausse commune que le code refactored est plus difficile à suivre. C'est généralement un argument des personnes qui ne sont que familiarisées avec ce qui est refacturé et non le résultat refoulé. Pour les nouveaux arrivants, le résultat refoulé sera plus clair.
Tous les bugs/fonctionnalités peuvent être fixes/implémentés dans un endroit central ultérieurement et sont automatiquement disponibles partout dans votre application. C'est un gain énorme qui est généralement très sous-estimé. En général, une refactorisation totale d'un composant ne prend pas aussi longtemps. (Jours au lieu de mois) Lorsque vous les comparez au temps perdu en raison de bugs, il faut comprendre le code qui aurait pu être refacturé, le coût du refactoring devient minimal.
Mise à jour relative à la réponse de Péter Török: N'est-ce pas en reportant le refactoring "car il faut du temps", le temps de le refroidir à une augmentation ultérieure augmente? Le refactoring ne devrait pas prendre longtemps, quand fait plus souvent.
Comment expliquer à votre patron que vous passerez quelques jours à écrire un code qui n'ajoute rien au produit, est difficile et est une question totalement différente. :)
Pouvez-vous ne pas créer une nouvelle interface/classes qui fonctionne comme une façade sur l'ancien code, tout en introduisant votre nouveau code dans votre propre style pouvant être facilement étendu?
En tant que développeur, préférez-vous maintenir un code ennuyeux facile et facile OR pour avoir des aides qui feront le code ennuyeux stupide chez vous?
Je ne comprends pas la question révisée. Je pense que la plupart des gens, comme moi, préféreraient ne pas maintenir le "code ennuyeux stupide". Je ne sais pas ce que tu veux dire par assistant, désolé.
L'affiche a répondu à sa propre question en ne faisant pas de gros changements en ce moment. Bon choix. J'ai des problèmes avec l'arrogance d'un développeur qu'ils savent ce qui est le meilleur pour l'entreprise. Un grand refactoring sur le Sly ... Parce que vous savez mieux que votre patron? Tout gestionnaire capable peut peser des avantages.
Si refactoring n'est pas une option, la question devient plus une discussion sur la bonne heure, la place, etc ... pour le faire. La cohérence est très importante. Pourtant, le code vécu depuis longtemps bénéficie souvent de "renouvellement". D'autres ont discuté de cela ...
Faites-le de l'avant. Utilisez des fonctions au lieu de couper et coller. Cela ne nécessite pas de refactoring, mais cela vous donne le début d'une base pour le refactoring futur.