Pourquoi écrire un code propre et refactored?
D'après mon expérience de travailler sur plusieurs Java=== ", j'ai vu des tonnes de codes que nous appelons" sale ". La classe/méthode non conventionnelle/nommage de champ, mauvaise manière de manipuler des exceptions, Des boucles et une récursives inutilement lourdes, etc. Mais le code donne les résultats escomptés.
Bien que je déteste voir du code sale, il est temps de les nettoyer et de la question de "vaut-il la question de" ça vaut la peine? Il donne les résultats souhaités alors quel est le point de nettoyage? "
Dans les projets d'équipe, il y aurait une personne spécifiquement au refacteur et à vérifier le code de nettoyage? Ou y a-t-il des situations où les codes "sale" ne parviennent pas à donner des résultats escomptés ou à rendre les clients malheureux?
Ce que je veux dire par pourquoi n'est pas les raisons techniques, je pose des questions sur le motif. ** Nous connaissons tous pourquoi nous devrions écrire un code de nettoyage au point de vue technique. Mais imaginez au collège si j'écris du mauvais code, je reçois de mauvaises marques. Donc, dans votre environnement industriel, ce qui vous motive et votre équipe pour écrire un code de nettoyage? Et ce qui vous motive et vous équipe de rédiger un mauvais code?
Il est si facile d'écrire une méthode dans une classe pour obtenir les informations dont vous avez besoin sans regarder autour de vous et vérifier s'il y a une méthode similaire! Résultat? 5000 + lignes de code avec peu de méthodes faisant des tâches presque similaires.
Cela en vaut la peine et cela devrait être fait par toute l'équipe. "Quand il pue, changez-le" fonctionne pour les bébés et le code (merci, Kent Beck).
Certains ont dit que pour un petit projet à court terme, cela ne vaut pas la peine de faire. Je ne suis pas d'accord. En premier lieu, nous savons rarement à quel point un projet à court terme sera à court terme, mais à la deuxième place - quand il pue, changez-le. Si cela pue, c'est parce que vous l'avez écrit sous la première place - et votre équipe devrait travailler sur ses compétences de codage générales et que le refactoring est une bonne formation pour cela - ou (plus fréquemment), il a été correctement corrigé et réutilisé au fil du temps. Dans ce cas - évidemment Ce n'est pas un projet très court terme. Si vous aviez le temps de le piquer, prenez le temps de le changer.
Refactoring - Garder votre code de STINKING - N'est-il pas de la responsabilité d'une personne désignée de votre équipe, et ce n'est pas la responsabilité de la personne qui l'a fait pueillir. C'est votre responsabilité et la responsabilité de tous les membres de votre équipe. Quand ça pue, changez-le.
La question est similaire à la raison pour laquelle nous devrions manger des aliments propres. Points simples Vous pouvez grep le Net sur:
- Maintenabilité
- Lisibilité
- Facile à prolonger plus tard.
- Montre le caractère du développeur :)
Mais le "est-ce la peine d'être" question est peu délicat. Tout en décidant de cela, vous devriez considérer:
- Combien de temps à l'avenir ce projet pourrait courir
- Comment des nouvelles fonctionnalités de mmore devraient être ajoutées à long terme.
- Facteur de risque; Si c'est dans le produit, à quel point cela risque-t-il de changer (effrayant)
- Avez-vous assez de ressources pour "déchets" (?) Dessus.
Je dis à mes étudiants que c'est l'ordre dans lequel je m'attends à ce que le code soit écrit sur (ce que je me soucie le plus au moins):
- Documentation - Si je ne sais pas ce que c'est censé faire comment je saurai si cela le fait correctement ou pas?
- Formatage et conventions - Si je ne peux pas la lire, comment saurai-je ce que cela tente de faire? Comment puis-je pouvoir le modifier si j'en ai besoin et c'est un gâchis?
- Correct - aucun point d'avoir un programme qui produit le mauvais résultat
- Rapide (un quart lointain) - pas beaucoup à dire ici
Mettez simplement, le code est écrit beaucoup moins qu'il est lu. Ne suivez pas les conventions (style) et écrire un code rapide et sale le rend beaucoup plus difficile à lire. Étant donné que la lecture est la principale activité qu'elle enregistre dans l'ensemble du temps si le code est clair.
Vous posez en réalité plusieurs questions différentes ici.
Pourquoi écrire un code propre et refactored?
On devrait le faire car il facilitera la maintenance et la vérification de vos résultats. Si personne mais que vous pouvez comprendre comment votre code fonctionne sans dissipateur de temps massif, ils ne peuvent que prendre votre parole que cela fait en réalité ce qu'il devrait. Si vous êtes indisponible lorsqu'un problème critique est trouvé, il est aussi susceptible d'être aggravé comme corrigé.
Viser maintenabilité a été l'un des commandements de l'ingénierie logicielle depuis la nuit des temps.
il donne les résultats souhaités alors quel est le point de nettoyage?
Selon le calendrier attendu de votre projet, ce n'est peut-être pas. Si votre projet ne va que six mois de moins de six mois sur un délai très précis, vous pouvez probablement vous échapper avec des choses comme un gâchis. Les clients ne se soucient généralement pas de ce qui se passe sous la cagoule, ils veulent simplement pouvoir bip et tweet aux heures de droite.
Cependant, si vous êtes sur quelque chose de plus long terme, la maintenabilité va devenir un facteur important. En moyenne, vous pouvez vous attendre et devrait prévoir de perdre du personnel clé si vous êtes sur un calendrier de plus de six mois.
Dans les projets d'équipe, il y aurait une personne spécifiquement au refacteur et à vérifier le code de nettoyage?
Non, je dirais pas. La personne "refactoring" Le code devrait être la personne qui l'a écrit à l'origine, ou il y aura des malentendus. Autant que les règles de la normalisation de la base de données, si vous passez un peu de temps à penser et à refacteur au fur et à mesure que vous allez (les opportunités de faire devraient être évidentes lorsque vous travaillez sur le code), il ne devrait pas y avoir beaucoup de code désordonné couché pour tu.
Certes, Ne laissez-la pas avant que le code soit fonctionnel complet, comme à partir du point de vue des développeurs, leur travail est effectué, la fonctionnalité a été faite et elle peut fermer le ticket.
Réduire la qualité interne vous ralentit.
Si vous réduisez la qualité interne, produisant des résultats souhaités dans l'avenir prendra plus de temps et plus, avec un risque croissant.
Si vous choisissez soigneusement la bonne chose d'abord - Obtenez la plus grande valeur d'abord - alors à mon avis, il vaut presque toujours la peine de faire la chose.
En outre, jetez un coup d'œil à l'excellent article de Martin Fowler: http://martinfowler.com/bliki/tradablequalityhypothesis.html
(Citation paraphrasée: dès que la qualité interne est encadrée comme étant négativable, les développeurs, la gestion et leurs clients ont déjà perdu.)
Le code sale fait mal quand vous devez travailler avec elle. Travailler avec cela signifie la correction d'un bogue qui concerne le code ou l'ajout d'une fonctionnalité autour du code sale. Je ne pense pas qu'il y ait beaucoup de valeur dans l'entrée et le refactorisation du code arbitrairement; Le code doit être refacturé lorsque vous le touchez pour corriger un bogue ou ajouter une fonctionnalité. En général, j'adore le Livre de code propre idée de se rapporter à ce que disent les scouts: laissez le nettoyeur de camp que vous l'avez trouvé!
Si cela est suivi, votre propreté globale (et votre qualité) améliorera les heures supplémentaires, alors que les risques de (pour une autre raison que la propreté), la modification du code qui fonctionne actuellement sera minimisé.
Je ne pense pas que les critiques postérieures à l'égard de s'assurer que le code est propre fonctionnera et que la personne que les refacteurs exclusivement ne fonctionneront pas non plus. En tant que développeur, je pense que nous devrions tous manger notre propre nourriture. Nous devrions donc être en charge pour faire de la bonne nourriture.
Si quelqu'un continue à apporter des pommes pourries au potluck, les autres sont tenus de lui faire changer ou de le faire ... Personne ne veut manger des pommes pourries. Nous devrions tous porter de la nourriture impressionnante à la chance.
Tout le monde a déjà répondu à la question bien. Mais le point de décision pour moi sur la question de savoir si cela vaut la peine ou non de la question de savoir si l'application va changer plus au fil du temps. Comme tout le monde l'a dit, si cela fonctionne et n'a pas besoin de changer, passez à des choses prioritaires plus élevées. Mais si vous allez devoir continuer à changer, il ne vous limitera pas que la propreté et l'efficacité entraîneront des problèmes sur la route.
J'ai travaillé sur une application vraiment pourrie une fois que lorsqu'il est écrit à l'origine était petit et assez facile à traiter. Au fur et à mesure des années de fonctionnalités supplémentaires et de hacks et de corrections bâclées, l'analyste de l'équipe a commenté une fois, "Ce que je trouve le plus difficile à propos de l'application, c'est combien de temps il faut le changer." Même faire une analyse d'impact pour un nouveau changement pourrait être coûteux.
Cependant, la réponse à votre question, en particulier lorsque vous envisagez la partie motivation, sera différente selon laquelle vous demandez. Pour une application informatique interne, où le coût est payé par des heures supplémentaires gratuites, les développeurs voudraient améliorer les internes tandis que peu de gestionnaires seraient intéressés à les modifier. Pour un magasin où la vitesse de l'évolution est importante à temps pour commercialiser, la qualité pourrait offrir un avantage stratégique, si vous aviez une gestion qui croyait que la vitesse de changement d'une application bien construite a dépassé la vitesse de piratage d'une nouvelle fonctionnalité. Et malheureusement, même Dans certains vrais magasins de logiciels, j'ai le sentiment que beaucoup de gestionnaires décident que les hacks sont plus rapides. Peut-être qu'ils sont, mais encore une fois, la douleur persistante est généralement ressentie par les développeurs et non les autres dans l'organisation.
Je pense que cela dépend très de votre projet. S'il s'agit d'un projet de prix fixe effectué par une personne pendant 1 semaine de code d'écriture comme vous le souhaitez.
Mais si l'équipe est plus importante et que le développement du projet prend plus de temps, il nécessitera certainement une sorte de ré-factorisation et de coopération entre les membres de l'équipe pendant le développement. Ce sont les points où vous commencerez à profiter d'un meilleur code de conception et de nettoyage.
Mon avis:
Ça dépend! - Si le code est signifié comme un développement unique dans le style de feu une fois et oublier ... alors je dirais ... Non, ça ne vaut pas la peine de le refroidir. - Si le code est censé être longtemps vivant et être réutilisé, alors je dirais: Écriture des tests d'unité et du refacteur Étape étape par étape, dès que vous devez modifier/améliorer le code dans ou qui utilise la partie sale des codes.
Vous devez trouver le bon équilibre entre le risque de rupture du code de travail et des avantages en termes de coûts de maintenance et de performance causés par le nettoyage.
Votre code sera utilisé par d'autres développeurs. Encore plus, vous utiliserez votre code à l'avenir. Ainsi, si vous investirez un peu de temps en écrivant du code de nettoyage au début, d'autres (et vous) économiseront beaucoup plus de temps à l'avenir pendant le débogage ou la modification de votre code.
Je mettrais les bons points soulevés par d'autres réponses de manière légèrement différente.
il donne les résultats souhaités alors quel est le point de nettoyage?
En d'autres termes "Si ce n'est pas cassé, ne le répare pas". Ce qui semble correct, mais il ne prend pas en compte que Code peut être brisé de plusieurs manières différentes - Cela peut être:
- fonctionnellement cassé (le plus évident): il ne fait pas ce qu'il est censé faire,
- incompréhensible: il est difficile de lire et de comprendre, il n'est donc même pas clair ce qu'il est supposé à faire,
- non utilisable: il est difficile ou impossible à tester un appareil,
- Minatinaine: Il est difficile de maintenir et de l'étendre - il s'agit généralement d'une conséquence étroite de son test de lecture et/ou d'unité.
N'importe lequel d'entre eux peut entraver ou même tuer un projet à long terme.
Du point de vue des affaires, je n'ai pas de gros objections pour un code sale unique si cela fonctionne. Il y a beaucoup de logiciels de merde gagnant de l'argent pour les entreprises.
Cependant, les bonnes habitudes et les compétences de programmation ne viennent pas de nulle part, elles doivent être développées. Ecrire un bon code est un excellent exercice pour écrire un bon code. Plus de bons développeurs de code écrit, plus il devient plus facile à faire. Il est tout à fait naturel d'écrire un bon code, ce n'est pas plus difficile ou plus lent que d'écrire du code sale, ce n'est qu'une expérience + de bonnes habitudes et cette expérience et ces habitudes ne peuvent être obtenues en écrivant du code sale ou en lisant des livres. Donc, n'écrivez pas à Dirty Code et ne laissez pas votre équipe le faire et vous serez un meilleur développeur avec une meilleure équipe dans un certain temps. Les tâches commerciales et les délais vont, reste des compétences.
Considérez les implications des exemples de Fizzbuzz dans cet article . Les deux versions et leurs modifications, donnent les mêmes sorties respectives, mais que souhaiteriez-vous maintenir, en particulier dans un environnement avec des exigences en constante évolution?
Mon conseil: lorsqu'il est sous contraintes de planification serrée, si le code n'est pas cassé, ne le répare pas. Lorsque les horaires deviennent des lâches et des délais ne sont plus imminents, prenez le temps de réparer le code le plus problématique ou le moins modulaire, mais toujours dans les directives de l'architecture globale du système.
Réécriture du code pour le faire "propre" ou "NEAT" ne devrait pas être entrepris à la légère. À moins que vous ayez le temps de faire le temps de connaître le code d'abord, vous risquez de faire des erreurs qui peuvent être très difficiles à attraper pourtant faire des parties d'un système qui ont travaillé de manière fiable pendant des années de manière mystérieuse.
Je travaille sur une telle tâche moi-même, où les choses s'étaient trop éloignées (Anti-motif de la classe de Dieu, quiconque, programmation massive-coller, etc.). Là-bas, j'avais eu le temps, et je n'ai toujours fait qu'une petite partie de ce que j'aurais vraiment aimé faire parce que je ne suis pas confiant de tout faire, les changements nécessaires pour rendre vraiment le code de qualité serait trop grand et serait effectivement signifie une réécriture qui est une voie à façonner de ce projet (ce que j'ai fait, rend le code un peu plus facile à lire afin que je puisse trouver des endroits où je devais apporter des changements destinés au projet et centraliser ces changements plutôt que de saupoudrer tous sur la place). Et même un tel changement limité (limité, comme dans la réduction de la classe de ligne 9500 existante à 8100 lignes, un réel refactoring le scinderait en plusieurs douzaines d'autres classes et introduirait probablement un cadre d'accès à la base de données complet comme Ibatis) a des risques qui leur sont attachés dans qu'il nécessite un test complet de l'ensemble de la demande susceptible de générer des problèmes introduits par le changement. Je ne l'ai fait que parce qu'un réessais complet était déjà appelé à cause de l'impact des modifications très mineures que j'ai fini par faire à la fonctionnalité (plutôt que la mise en œuvre technique) du système.
Je vois deux motivations principales:
maintenabilité
Parce que la personne qui devra conserver le code peut être un psychopathe qui sait où vous vivez. Ou pire , vous êtes peut-être celui qui le maintient et, d'ici là, vous aurez tout oublié sur la structure en interne.
plus facile à déboguer
Cela aide à avoir des fondations solides à construire lorsque vous devez ajouter plus de fonctionnalités, de cette façon, il est plus rapide d'identifier où vient des bugs.
C'est essentiellement une question d'argent.
Le meilleur code, plus facile (et moins cher) il est à maintenir. À la fois pour d'autres mais aussi pour ceux qui l'ont écrit à l'origine.
Malheureusement, cette expérience ne peut pas être correctement communiquée sans l'essayer, ce qui signifie qu'il peut y avoir une très grande base de code qui nécessite beaucoup de travail pour entrer dans un état raisonnable, ce qui signifie que ce n'est plus le moins cher de le faire parce que Vous devrez peut-être reconstruire trop. c'est le décès de nombreuses expériences.
Si vous avez besoin d'expliquer cela aux personnes non techniques, comparez-la avec une maison. Si les impressions bleues de base ne sont pas saines, vous devrez alors faire beaucoup de travail supplémentaire et vous avez encore une maison inférieure.
Vous commencez sur un projet avec un ensemble initial d'exigences. Le projet passe sur l'exigence continue de changer et qu'il est nécessaire d'étendre votre code.
Lorsque nous commençons à écrire le code, nous essayons de le faire travailler aux exigences que nous avons actuellement et celles que nous devinons qui pourraient apparaître.
Si vous ne refactez pas votre code, il existe un risque élevé qu'il ne soit pas facile de l'étendre ou d'être lisible par d'autres.
Plus de refactoring Le code montre à quel point vous êtes clair sur ce que vous avez fait et vous permet de corriger les bugs potentiels.
Pour moi dans la pratique, cette question se traduit par "Pourquoi écrire de plus petit code?", Car dans la pratique plus petite, des blocs de code plus importants supplémentaires invitent la possibilité d'une conception plus agréable et plus propre. Manipuler ces thèses Les blocs plus petits deviennent beaucoup plus faciles que les gros, et ils sont plus invitants à être refactorisés au besoin.
Maintenant, ma réponse:
après avoir brioté un refactoring de base de code hérité de manière significativement décent, cela a été mon expérience, que de grands blocs de code (classes, fonctions, etc.), invitent davantage de code. Plus de code appliqué indifférent sans discernement les choses comme le principe de la responsabilité et d'autres meilleures pratiques.
Donc, ma réponse sur laquelle écrire un code plus petit?
cela vous oblige à penser à votre structure de code et à votre mise en page plus, tout en prévenant la mentalité (et parfois la nécessité) de "trucs plus de choses dans ce bloc de code". Je dis une nécessité, parce que lorsqu'on rencontre un immense bloc, il peut être nécessaire de faire fonctionner les choses maintenant, plutôt que de prendre du temps au refacteur, en raison de pressions de temps.
Il est plus facile de refactoriser les travaux sur un ensemble de pièces de code autonomes plus petites, même s'ils sont laids que de travailler pour briser d'énormes méthodes laides enchevêtrées.
il aide les futurs programmeurs qui travailleront sur votre base de code pour déterminer ce que vous faisiez. Bien que cela ne soit pas toujours vrai, des unités de code plus petites qui ont leur but et qui sont raisonnablement autonomes, vous aideront à construire un modèle mental plus rapidement que de longs espions de code ambigu.
il empêche les futurs programmeurs de moments de ce que ce code était censé faire? Et pourquoi ou cette pièce de code fait ces choses de cette manière particulière et particulière?, alors que les blocs de code importants ont tendance à masquer les mauvaises pratiques et à divers bugs et erreurs de logique.