Avons-nous la responsabilité d'améliorer le code ancien?
Je regardais un vieux code que j'ai écrit. Cela fonctionne, mais ce n'est pas un excellent code. Je sais plus maintenant que je fais à l'époque, je pourrais donc l'améliorer. Ce n'est pas un projet en cours, mais c'est courant, travaillant, code de production. Avons-nous la responsabilité de revenir en arrière et d'améliorer le code que nous avons écrit dans le passé ou est la bonne attitude "si ce n'est pas cassé, ne le répare pas"? Ma société a parrainé une classe de critiques de code il y a quelques années et l'un des principaux plats à emporter était que parfois c'est juste assez bon; passez.
Ainsi, à un moment donné, vous devez simplement l'appeler suffisamment bon et passer à autre chose, ou devriez-vous essayer de pousser des projets pour améliorer le code ancien lorsque vous pensez que cela pourrait être meilleur?
Sauf si vous apportez des modifications à ce "ancien code" pour corriger des bugs ou ajouter des fonctionnalités, je ne me soucierais pas à l'améliorer juste pour le plaisir de celui-ci. Si vous souhaitez éventuellement l'améliorer, assurez-vous d'avoir des tests d'unités en place qui testeront le code avant de commencer à le refléter.
Vous pouvez utiliser le "vieux code" pour apprendre de meilleures pratiques. Si vous faites cela, c'est une expérience d'apprentissage à temps partiel et vous ne devriez pas vous attendre à ce que le code remplace ce qui est actuellement publié ou déployé par des clients/clients.
Refactor des zones de code que vous devez modifier le plus souvent. Depuis que vous visitez souvent ces zones, le refactoring améliorera votre compréhension du code et de la lisibilité lorsque vous devez les visiter à nouveau, alors qu'il ne fait aucun point que le code de refacteurs que personne ne va jamais regarder à nouveau.
De plus, si vous ne refactez que les zones de code lorsque vous devez les modifier, il vous donne une excuse valide si votre refactoring provoque une régression. Bien sûr, essayez de couvrir vos refacteurs avec des tests unitaires, mais cela n'est pas toujours possible, en particulier avec le code hérité et vous devez vous attendre à ce que de grands refactorings pour créer des régressions de temps en temps.
Si vous devez ajouter des fonctionnalités et que votre la conception vous ralentit ou provoque une duplication, puis le refacteur. Lorsque je conçois du code, je ne prédisez presque jamais exactement ce que les changements seront nécessaires à l'avenir. Cependant, lorsque j'ajoute de nouvelles fonctionnalités, je finis généralement par refactore le code partagé. À l'heure, j'ai ajouté un troisième cycle de caractéristiques/refactoring, mon refactoring est déjà payé pour lui-même et mon code partagé est assez stable.
TLDR: refacteur au besoin, il n'y a aucune obligation.
Tout ce que vous faites a un coût. Vous avez peu de temps à programmer. Tout ce que vous faites dans la programmation devrait être examiné: "Quel est l'avantage de le faire?" et "quel est le profit de faire autre chose?"
Si vous ne prenez pas compte du coût d'opportunité (quel est le coût de faire autre chose?) Puis la qualité est gratuite. Il vaut mieux améliorer votre code. Vous apprendrez quelque chose. Ça va courir mieux. Ça va vendre plus.
La vraie question est la prochaine meilleure chose à faire avec votre temps? Et puis vous avez des compromis.
Vendra-t-il plus de logiciels?
Cela causera-t-il moins de maux de tête soutenir?
Qu'allez-vous apprendre?
Est-ce que cela deviendra plus esthétiquement agréable?
Va-t-il améliorer votre réputation?
Posez ces questions (et d'autres personnes pertinentes pour vous) pour que cela et d'autres activités dans votre file d'attente, et cela vous aidera à répondre si cela vaut la peine d'être fixé. Ces compromis sont la raison pour laquelle l'économie est importante pour les programmeurs. Joel l'a dit avant que je le faisais et qu'un vieux mentor m'a dit cela avant de Joel.
Ou si vous voulez une réponse plus simple, arrêtez simplement de regarder la télévision jusqu'à ce que vous ayez corrigé le code. :-)
Je pense que vous devriez commencer par vous demander la question qui semble avoir été manquée. De quelle manière le code est-il mauvais? Et par là, vous vous demandez vraiment ce qui suit:
- Le code ne fait-il pas ce qu'il est censé faire?
- Le code vous cause-t-il des problèmes lorsque vous maintenez le logiciel?
- Le code est-il complètement autonome?
- Avez-vous des projets pour mettre à jour ou remplacer le code à tout moment dans un avenir prévisible?
- Existe-t-il un cas de rentricité sonore que vous pouvez faire pour mettre à jour le code qui vous concernait?
S'il y a une chose que j'ai apprise au fil des ans, c'est que vous ne pouvez pas vous permettre de deviner vous-même après le fait. Chaque fois que vous résolvez un problème dans le code, vous apprenez quelque chose et verra probablement comment votre solution - ou quelque chose de similaire - aurait pu être une meilleure solution à un problème que vous avez résolu il y a différemment des années. C'est une bonne chose, car cela vous montre que vous avez appris de vos expériences. La vraie question est toutefois de savoir si le code que vous avez écrit auparavant est susceptible de devenir un problème hérité qui devient plus difficile à traiter avec le temps.
Ce que nous parlons vraiment ici, c'est si le code qui vous dérange est facile ou difficile à maintenir et à quel point la maintenance est-elle coûteuse d'être autant de temps. C'est essentiellement une question sur la dette technique et s'il convient de payer cette dette à l'aide d'un peu de maintenance chirurgicale maintenant, ou si la dette est suffisamment petite que vous pouvez le laisser glisser un peu de temps.
Ce sont des questions que vous avez vraiment besoin de peser de votre charge de travail actuelle et future et devriez être discutée longuement avec votre gestion et votre équipe afin de mieux comprendre l'endroit où investir vos ressources et si votre ancien code vaut Le temps que vous devrez peut-être passer dessus - si du tout. Si vous pouvez faire une bonne affaire de renseignement pour introduire des changements, alors par tous les moyens, mais si vous faites face à l'envie de bricoler avec le code, car vous vous sentez gêné de la manière dont vous l'avez écrite, alors je suggère qu'il n'y a pas de chambre pour la fierté personnelle en matière de maintien de l'ancien code. Il fonctionne soit, c'est que cela ne soit pas facile à entretenir, soit coûteux de maintenir, et ce n'est jamais bon ou mauvais simplement parce que l'expérience d'aujourd'hui n'était pas disponible hier.
Certainement, n'améliorez pas juste pour le plaisir de l'améliorer. Comme d'autres l'ont dit (et est un bon sens), nous nous améliorons tous (pour une certaine valeur de "mieux") au fil du temps. Cela étant dit, examiner le code (formellement ou informel) éclaire souvent ces morceaux que nous souhaitons probablement jamais voir à nouveau la lumière de la journée.
Bien que je ne crois pas que nous ayons une responsabilité Pour revenir en arrière et améliorer le code qui n'est pas fondamentalement brisé, non sécurisé ou dépend des caractéristiques d'une liste obsolète/EOL, voici certaines choses que j'ai fait dans le passé dans cette situation:
Identifiez les personnes de l'équipe qui creusent vraiment de retourner et d'améliorer le code, comme une sorte de nettoyage du cerveau ou une tâche de taille d'un cerveau qui donne un sentiment d'accomplissement et de trouver du temps dans le calendrier pour eux de le faire régulièrement. J'ai toujours eu au moins une de ces sortes de personnes dans une équipe et cette approche peut également stimuler le moral (ou au moins l'ambiance) si nous sommes tous dans une période de ballon ou de baisse.
Utilisez-le comme base d'un exercice d'apprentissage. Pour des stagiaires, des étudiants ou des membres nouveaux/juniors de l'équipe, refactoring le code ancien avec des conseils de membres de l'équipe donne la possibilité de communiquer avec de nouveaux membres de l'équipe, de comprendre davantage sur le système et d'obtenir l'habitude d'écrire/Mise à jour des tests d'unité et fonctionnement avec une intégration continue. Il est important de noter que cet exercice est effectué avec des orientations et clairement encadré comme un exercice pour rendre le code mieux car il ne se conforme pas aux normes/normes actuelles.
Ainsi, aucune responsabilité de le réparer, mais que ce vieil truc peut être vraiment utile. Et des tests unitaires et CI sont vos amis!
Microsoft doit-il mettre à jour Windows? Est-ce que toutes les distros * Nix doivent continuer à évoluer? Ou un exemple plus pratique que tout le monde conduit toujours les voitures de 1970?
Pas nécessairement. Toutefois, si vous effectuez une maintenance de code et que vous changez sur quelque chose qui pourrait être meilleur, vous pouvez le modifier à condition que vous disposiez des tests d'unité appropriés pour vous assurer de ne pas créer de régression.
Si aucun test de ce type n'existe et que vous ne pouvez pas être sûr, il se comportera exactement comment cela devrait, vous ferez mieux de le laisser seul.
Du point de vue d'un ingénieur, je voudrais très bien travailler sur le code ancien jusqu'à ce qu'il ne puisse plus être améliorer. Mais y a-t-il une affaire de rentabilisation? À la fin de la journée, le code est là pour contribuer à la ligne d'essentiel, la rentabilité de votre lieu de travail. Si ce n'est pas le cas, laissez-le simplement.
Il y a une grande mise en garde, si, en améliorant le code, vous allez éviter un bug de se produire (en pensant aux grandes balles Y2K ici ..) Je voudrais certainement l'amener avec quelqu'un plus haut, peut-être que votre gestionnaire d'unité commerciale, et discuter des conséquences de l'amélioration du code.
Quant à moi, la question peut être reformulée et généralisée: " Pourquoi quelqu'un dépenser des ressources supplémentaires (temps, argent, mental, etc.) si cette pièce de béton de code fonctionne bien maintenant est-ce pas un gaspillage de ressources (s) ? "
Chaque fois que je trouve un code hérité, je pense à plusieurs choses qui semblent être importants.
- Qu'est-ce que je vais faire des changements?
- Ai-je besoin de soutenir ce code? Combien de temps peut-il arriver (près/futur lointain)?
- Est-ce code assez confortable pour travailler? (À l'heure actuelle)
- Puis-je être sûr que tous les changements que je fais sont en sécurité? Différents tests aident habituellement à répondre à cette question.
- Quelles conséquences puis-je rencontrer si je vais faire des erreurs (s) lors de la modification de code? Est-il possible de revenir mes changements rapidement? Sera-ce une perte de temps?
- ...
En fait, vous devriez vous poser beaucoup de questions. Il n'y a pas une liste complète et définitive d'entre eux. Seuls vous et probablement vos coéquipiers pouvez trouver la réponse.
P.s. Je l'ai remarqué que je tends à réécrire le code très souvent, alors que mon ami et coéquipier ont tendance à laisser intacte. C'est parce que nous répondons différemment les questions mentionnées. Et je dois dire que nous leur répondons mal souvent ... parce que nous ne pouvons pas prédire l'avenir.
Je sens que refactoring/Améliorer l'ancien code définit le programmateur lui-même. Voulant améliorer le code que vous avez écrit il y a un an seulement indique vos progrès, et s'il rend la demande mieux et que vous avez la capacité, le temps et l'approbation pour l'améliorer, le faire.
Meilleur/amélioré est une comparaison multi-axe. Pensez-vous que vous pouvez le rendre plus rapide, plus petit et plus efficace de ressources, plus lisible, des informations plus utiles, des résultats plus précis, plus flexibles, plus généraux, capables d'exécuter plus de systèmes, éliminez une dépendance sur un produit séparé?
Pourquoi votre entreprise devrait-elle vous payer de passer du temps à réécrire ce code, au lieu d'écrire un nouveau code ou de réécrire une autre pièce de code?
Vous devez apporter des améliorations lorsque l'opportunité se présente, mais une opportunité signifie que vous travaillez déjà sur le code, ou vous avez identifié une raison d'une entreprise pour faire le changement.
Pousser une modification de la production introduit une chance non nulle de casse (unité et des tests fonctionnels ne réduisent que cette chance, ils ne l'éliminent pas) et ne devraient être effectués que lorsque l'avantage attendu l'emporte sur le risque.
Quel est un autre point à considérer - avez-vous l'intention de pousser ce changement à la production ou simplement à la branche de développement? La barre des deux scénarios est complètement différente. Si cela ne va pas dans la branche de développement et ne peut jamais entrer dans la production, alors une opportunité signifie essentiellement que vous examinez le code pour une raison quelconque et qu'il ne fasse pas beaucoup de temps à faire. Il peut être examiné comme requis si une poussée devait jamais se produire, et laissée de côté s'il est considéré comme injustifié à que heure. Si d'autre part, cela va à la production maintenant, comme je l'ai dit ci-dessus, vous devez envisager si ce changement vaut le coût: en termes de temps consacré à faire la pression et aux avantages de l'utilisation du nouveau code.
C'est une question à poser à la direction dans votre entreprise.
Avez-vous le temps et les ressources nécessaires pour revenir en arrière et apporter des modifications à l'ancien code?
Avez-vous le temps et les ressources nécessaires pour avoir un test d'équipe QA ce que vous avez changé pour vous assurer qu'il n'est pas cassé?
Je suis tombé dans ce piège avant d'où je serais dans un module de correction d'un bug et de voir le code I ou quelqu'un d'autre écrivait que c'était inefficace ou inélégant, le change et finit avec plus de problèmes pour traiter que si je viens de corriger le bug que j'ai été chargé de réparer.
Vous pouvez normalement écrire le code mieux la deuxième fois, vous avez appris davantage sur le domaine en l'écrivant initialement.
Il n'y a pas une réponse simple pour que ce soit de réfracter. En règle générale, vous ne devriez généralement pas si un) c'est une bonne exercice d'apprentissage pour vous ou B) Vous gagneriez du temps à long terme avec un meilleur code. Rappelez-vous que chaque changement risque de bugs.
En tant que note latérale, je préconiserais fortement les tests unitaires. Il est très facile de refroidir en particulier si vous n'avez pas de comportement actuel clairement marqué avec des repos automatisés.
Je crois que nous avons la responsabilité d'écrire le meilleur code possible que nous pouvons aujourd'hui. Cela signifie que tout ce que nous avons appris dans le passé et refuse de prendre de courtes coupes dans notre conception. Si les pressions de la planification provoquent que quelque chose soit coupé, je ne crois pas que la qualité de notre logiciel devrait même être prise en compte, ce petit clip papier animé, d'autre part ...
Maintenant, si vous travaillez et que vous trouvez ce code, vous devez interagir avec ne pas être écrit au niveau que vous êtes actuellement capable d'écrire, il est raisonnable de le réparer si vous êtes capable de le faire de manière méthodique contrôlée. J'ai personnellement une expérience très minime avec ce genre de refactoring, comme tout le monde (presque tout le monde?) J'ai essayé tout le tout "permet de changer tout et de la prier ça marche" et de la mordre par ce mauvais. Je suggère de regarder dans les discussions de Martin Fowler (soit - son livre ou n des nombreux articles ) sur la question. Il semble avoir inspiré la majeure partie de la pensée actuelle sur le processus.
Bien sûr, parfois, vous ne pourrez peut-être pas nettoyer le code comme vous le souhaitez. Joel Spolsky a écrit un article sur la raison pour laquelle vous voudrez peut-être consacrer quelques semaines pour simplement refroidir votre code. Lisez-le ici et oui c'est un peu vieux, mais je pense que l'information est toujours pertinente.
J'espère que cela aide
Ça dépend.
Si le code en question est vraiment brisé, de telle sorte qu'il contienne des bogues qui superviennent inévitablement un point (par exemple, un compteur qui surplombra à un certain point et causer des problèmes méchants), puis la fixation de ceux-ci peut valoir l'effort - mais si vous Fais, mettez toutes les garanties possibles en place pour éviter d'introduire de nouveaux bugs: assurez-vous d'avoir des tests d'unité significatifs couvrant tout ce que vous touchez, avez toutes vos modifications examinées par une personne compétente, insistez sur les tests de manière approfondie, assurez-vous de pouvoir revenir à l'ancien Version à tout moment, sauvegarder toutes les données avant d'entrer dans la production, déployer d'abord dans un environnement d'acceptation et le faire tester par les utilisateurs réels, etc. Vous voudrez également obtenir l'approbation avant d'aller de l'avant: si le bogue est vraiment une bombe de temps et votre responsable est un peu compétent, vous pourrez le convaincre de vous laisser réparer (et si vous n'obtenez pas l'approbation, alors peut-être que c'est un signe que vous avez tort).
OTOH, si votre plainte n'est pas un simple manque d'élégance de code, alors n'osez-vous pas le toucher. Cela fait du service fidèle de la production depuis un certain temps maintenant, changeait que le code ne vous satisferait, mais ne pas ajouter de valeur, et comme chaque changement, vous risquez de casser quelque chose. Même si vous ne le faites pas, votre temps est précieux (littéralement: vous êtes payé pour ce que vous faites, chaque minute de votre temps coûte de l'argent) et que vous n'ajoutez aucune valeur réelle, un tel changement serait une perte nette pour la société et le projet.