Quelqu'un d'autre a-t-il un problème de refactoring? [fermé]

Il semble qu'après avoir écrit une quantité importante de code, j'ai le sentiment anxieux de ne pas l'avoir fait de la meilleure façon possible, et je finis par refactoriser et passer beaucoup trop de temps sur le projet, ou ne jamais obtenir ça se faisait parfois. Cela arrive-t-il à quelqu'un d'autre et comment gérez-vous cela?

J'apprécie ces moments où ils m'arrivent.

La raison: si je ne repensais pas à mon travail et ne pensais pas qu'il y aurait quelque chose que j'aurais pu faire mieux que je n'avancerais pas en tant que développeur. Par conséquent, lorsque ces moments d'illumination se produisent, embrassez-les et prenez note de ce que vous avez appris. Tenez compte de votre calendrier pour le projet en cours et, si possible, remaniez le code, sinon, prenez la leçon et utilisez-le dans les futures implémentations de projets.

Quoi qu'il en soit, apprendre de ses propres erreurs est une bonne chose!

Voici quelques règles pour contraindre cette activité et la rendre plus productive:

• le chronométrer, par exemple régler la minuterie sur 25 minutes
• ne le faites que lorsque vous avez une couverture de test décente.
• essayez de rendre votre refactoring utile au développement des prochaines fonctionnalités

Il semble que vous puissiez toujours refaçonner, n'est-ce pas? J'essaie de limiter la refactorisation uniquement lorsque j'essaie de résoudre d'autres problèmes. Par exemple, refactorisez lorsque vous avez un problème de performances et refactoring avec de l'aide pour le résoudre - refactorisez lorsque vous devez ajouter de nouvelles fonctionnalités et refactoring vous aidera à le résoudre

Pour être honnête, je m'inquiéterais davantage si vous montiez d'énormes quantités de code et pensiez que tout était parfait et n'avait besoin d'aucune refactorisation ...

Quand j'étais plus jeune et inexpérimenté, j'étais très arrogant au sujet de ma capacité de programmation, et j'ai toujours eu tendance à imaginer qu'il était possible de concevoir et de planifier très bien - et qu'une fois que j'arriverais à l'étape de la mise en œuvre, je le ferais et je le ferai '' Tous seront parfaits.

La réalité est presque le contraire. Certains disent même que dès que vous commencez à coder, vous devriez être en mode Maintenance. L'idée ici est que l'étape "Implémentation" du SDLC n'existe pas vraiment en tant que telle, car vous ne devriez jamais mettre de côté la correction de bogues ou la refactorisation et prétendre que le code que vous produisez est "frais" et parfait.

Cela dit, je suppose qu'il est possible de devenir trop obsédé par le refactoring. Je ne l'ai pas encore vu. Et plus j'ai d'expérience, plus je pense que ce serait une bonne chose si plus d'équipes de logiciels refusaient manifestement de travailler dans des délais serrés et de s'endetter sur le plan technique. Après tout, c'est la raison la plus courante pour laquelle le refactoring est mis de côté dans le monde réel.

Je suggérerais de ne pas dépendre uniquement de la sensation ou de l'odeur du code.

Énumérer clairement ce qui ne va pas avec le code et quelles sont les solutions. Sérieusement, écrivez-le, car vous allez vouloir examiner l'efficacité de votre refactoriste contre cela.

Identifiez les moyens de décomposer le refactoriste en morceaux réalisables et hiérarchisez-les. Ayez la discipline de vous concentrer uniquement sur la portée de chaque morceau, en évitant les tangentes qui peuvent nuire à votre tâche.

Identifiez également les tests unitaires que vous pouvez écrire par rapport au code existant avant de continuer. S'il existe déjà des tests approfondis, c'est une bonne chose. Le manque de tests unitaires représente une excellente occasion d'en faire.

Il ne fait aucun doute que je tombe dans ce piège mais une refactorisation est importante pour le futur support / débogage.

Lors de l'écriture d'un morceau de code majeur, il devient très facile de parcourir les lignes de code dans la méthode en cours d'écriture. Lorsque j'ai terminé un morceau de code majeur, je place un commentaire todo: code review . Puis, quelques jours plus tard, je ferai la révision du code et le refactoriser en conséquence. Si j'ai du mal à le lire quelques jours plus tard, que se passera-t-il dans quelques mois, voire des années.

Je tombe dans ce piège lorsque j'apprends une langue ou une technologie. Par exemple, lorsque vous apprenez Java pour la première fois, imaginez que vous écrivez une application Web avec un servlet, pensant que c'est la bonne façon. Ensuite, vous réalisez qu'il y a jsp et vous pensez que oh c'est plus récent c'est probablement vrai. Ensuite, une fois à mi-chemin, vous trouverez Struts et peut-être des trucs EJB, après quoi vous trouverez le printemps (basé sur xml), après quoi vous trouverez les annotations cool de @MVC, après quoi vous le trouverez trop verbeux et vous êtes gâté pour choix entre groovy / grails et scala / lift! Cela convient parfaitement aux projets personnels, car il s'agit généralement d'apprendre et pas nécessairement de respecter un certain délai.

J'étais uber-refactorisateur au travail aussi. Mais à mesure que j'ai acquis plus d'expérience, je suis devenu plus sélectif sur ce que je vais refactoriser. Il s'avère que lorsque vous quittez une entreprise, vous ne prenez pas le code avec vous, et généralement d'autres ingénieurs peuvent détruire le code presque plus rapidement que vous ne pouvez le réparer.

La règle d'or que je suis est la suivante: je refactorise jusqu'à ce qu'il soit aussi optimisé qu'il peut l'être à ce moment-là , puis je ne le refaçonne pas à moins que les situations ne changent, ou plus rarement si j'ai une inspiration pour une nouvelle et meilleure façon de faire des choses (par exemple en utilisant une nouvelle fonction de langue).

Par exemple, j'ai dû écrire un nouveau module de code pour une application existante. Je l'ai écrit d'une certaine manière, et le lendemain, je lui ai donné plus de réflexion et j'ai pensé que je pouvais le refactoriser et le rendre plus abstrait, car nous étions assez certains qu'il faudrait l'étendre sur la route pour d'autres utilisations. J'ai donc refactorisé le code. Ensuite, j'ai décidé que c'était un peu trop générique et j'ai consolidé certaines classes et interfaces qui faisaient essentiellement la même chose, en utilisant Generics (C #) pour obtenir la même fonctionnalité. À ce stade, je pourrais probablementrefactoriser davantage pour le rendre encore meilleur, mais c'est "assez bien" - le code est bien écrit, suit les modèles de conception et les concepts d'ingénierie appropriés, et est extensible. Je ne le refaçonnerais que si les exigences m'obligeaient à réévaluer le code, ou s'il y avait une fonctionnalité de langue qui pourrait rendre le code plus clair et / ou plus lisible.