Quand est-il acceptable de NE PAS réparer les fenêtres cassées?

En ce qui concerne les fenêtres cassées , y a-t-il des moments où le refactoring est préférable pour une activité future?

Par exemple, si un projet visant à ajouter de nouvelles fonctionnalités à un système interne existant est affecté à une équipe qui n'a pas travaillé avec le système jusqu'à présent, et reçoit un bref délai dans lequel travailler - peut-il jamais être justifié de reporter les remaniements majeurs au code existant afin de respecter la date limite dans ce scénario?

La refactorisation est - et devrait être - un processus continu. Il ne suffit pas de simplement répondre aux exigences avec une implémentation fonctionnelle et testée qui est encore un peu incomplète.

"Faites-le fonctionner, puis faites-le mieux" .

Je ne me souviens pas où j'ai lu cette citation, mais c'est la clé pour bien appliquer la refactorisation, et je considère qu'il n'est pas professionnel de faire autrement.

La refactorisation continue, c'est comme essuyer les déversements pendant que vous cuisinez et nettoyer vos plats après avoir mangé votre repas. La refactorisation ciblée, c'est comme trouver une cuisine sale, mais avoir seulement le temps de laver un verre sale ou deux. Préférez-vous vivre avec une cuisine continuellement sale, ou préférez-vous garder les choses propres au fur et à mesure?

Vous obtenez le code pour fonctionner, puis vous refactorisez votre code pour vous assurer que vous avez la meilleure implémentation que vous pouvez éventuellement utiliser. Si vous faites quelque chose de familier, il se peut que vous implémentiez le meilleur code la première fois, mais il faut prendre un moment pour revérifier votre travail pour en être sûr. S'il semble que vous pourriez améliorer votre code, vous essayez de refactoriser pour vous assurer que votre code est au moins aussi simple et propre que possible. Cela signifie que vous réduisez le montant de la dette technique que vous laissez derrière vous et que vous facilitez la lecture et la refonte la prochaine fois que le code doit être traité. Il s'agit de la valeur fondamentale derrière le mantra TDD "Red-Green-Refactor", sauf que là où dans TDD vous refactorisez principalement pour supprimer la duplication, il est également utile de revoir d'autres éléments qui pourraient être refactorisés, tels que les grandes classes, les méthodes longues,

Si vous vous retrouvez confronté à une refonte majeure, vous pouvez peut-être le reporter pendant un certain temps, en particulier si vous manquez de temps dans votre horaire. Ceci est toutefois fourni à condition que la fonctionnalité de votre code ne soit pas compromise, et à condition que l'implémentation continue de répondre aux exigences. Ce genre de situation devrait être rare, et vous pouvez vous assurer qu'il est encore plus rare si vous refactorisez continuellement au fur et à mesure. Plus important encore, cependant, vous ne pouvez pas risquer de laisser vos modifications majeures trop longtemps, sinon vous finirez par créer une charge de travail encore plus importante plus tard, ce qui pourrait être beaucoup plus coûteux à corriger ou finir par entraîner une charge encore plus coûteuse. échec du projet.

J'ai l'impression que beaucoup de gens ont tendance à confondre les définitions de Refactoring et Re-engineering . Les deux termes décrivent des stratégies pour gérer des situations très différentes. Si vous souhaitez réorganiser, vous vous engagez à effectuer un changement radical qui modifiera le comportement d'un système. Cela invalidera certains tests et nécessitera également de nouveaux tests. Lorsque vous refactorisez, vous vous assurez que votre système continue de se comporter exactementla même chose qu'avant le changement, mais vous vous assurez également que votre code aura une longévité et qu'il sera plus facile à maintenir au fil du temps. Vous n'êtes pas "proxénète" votre code pour le pire, vous vous engagez à une norme professionnelle de code propre qui réduira le risque d'échec et garantira que votre code reste un plaisir de travailler avec, et d'une norme professionnelle .

Pour revenir à l'analogie des fenêtres cassées, si vous cassez la fenêtre, vous devez la réparer immédiatement. Si vous n'avez pas remarqué qu'une fenêtre est cassée, vous devez décider du coût pour vous si vous laissez la fenêtre cassée. Maintenant, répétez les deux phrases précédentes, mais remplacez Bug par la fenêtre. Vous finissez par avoir besoin d'une stratégie différente. Si vous avez créé un bogue pendant que vous codez, vous le corrigez immédiatement, ou vous voyez si les modifications nécessiteront un effort de réingénierie, et vous décidez commercialement quand il sera préférable de régler le problème. Donc, vous ne refactorisez pas pour résoudre un problème, vous refactorisez pour vous assurer qu'il est plus facile de trouver et de résoudre les problèmes. Peu importe à quel point vous pensez que votre code est étonnant, les systèmes complexes auront toujours des problèmes qui devront être résolus au fil du temps. C'est à cela que sert la dette technique, et pourquoi le refactoring doit être un processus continu lorsque vous implémentez votre code , et non pas laissé pour un temps futur arbitraire.

Donc, en bref, la réponse selon laquelle il peut parfois être acceptable de différer des modifications majeures du code afin de fixer un délai, mais il ne devrait pas être considéré comme une pratique normale de traiter le refactoring comme un exercice indépendant de votre travail quotidien de mise en œuvre, et certainement jamais utilisé comme excuse par des équipes qui ne connaissent pas la base de code comme une option pour éviter de s'assurer que leur mise en œuvre est aussi simple et propre que possible dans les circonstances.

Certains développeurs disent qu'ils "réparent les fenêtres cassées" alors qu'en réalité ils "réorganisent les chaises longues sur le Titanic". La refactorisation de code qui fonctionne mais qui heurte votre odorat est relativement facile. Si vous constatez que vous continuez à revenir à ce type de tâche au lieu d'ajouter de nouvelles fonctionnalités à vos utilisateurs ou de rendre l'application plus utilisable pour eux (l'optimisation signifie que l'application s'exécute plus rapidement est bonne ici, l'optimisation signifie que le code est plus lisible est différent) alors peut-être que vous rangez trop. Non pas parce que le rangement est mauvais, mais parce que l'entreprise paie pour le développement afin de développer quelque chose. Ils ne veulent pas une solution cassante, difficile à lire et mal architecturée, bien sûr, mais ils ne veulent pas non plus d'une demi-solution polie et belle.

Faites le ménage lorsque vous avez besoin de faire quelque chose de simple "pour commencer", ou lorsque vous attendez qu'une autre équipe vous dise si votre problème est en fait de sa faute, ou lorsque vous attendez une décision. Il y aura de nombreuses opportunités. Si vous avez la possibilité de faire avancer l'application entière, prenez-la, à moins que vous ne commenciez à sentir que tout est devenu fragile. Ce n'est probablement pas le cas. Vous aurez la possibilité de refactoriser - vous n'avez pas à vous en préoccuper.

Pour revenir à la deuxième moitié de votre question, un sprint pour ajouter des fonctionnalités face à une courte chronologie, il serait faux de dire "et nous ne ferons aucune refactorisation, il n'y a pas de temps". Il serait également faux de dire "Je sais que cela fait 6 semaines et cela ressemble exactement aux utilisateurs, mais ces fenêtres cassées devaient vraiment être réparées." Ajustez la refactorisation dans les lacunes qui se produisent dans tout projet. Ne vous réfugiez pas dans le rangement au détriment de la réalisation de l'objectif du projet.

D'un point de vue commercial, le refactoring est un investissement spéculatif - investir du temps et des efforts (argent) maintenant, dans l'espoir qu'il économisera plus de temps et d'efforts (argent) à l'avenir.

Sans entrer dans le débat sur la façon dont l'effort de refactoriser permettra d'économiser dans le futur (cela dépend de trop de variables pour que ce soit une discussion significative ici), il est clair que le temps de refactoriser est lorsque la "valeur actuelle nette" du coût le laissant dépasse le coût de le faire maintenant.

C'est facile, sauf que vous ne savez pas combien coûtera le futur. Vous devez également prendre en compte toutes les idées de planification financière normales telles que le retour sur investissement, la gestion des risques (valeur de la marque, la responsabilité juridique, le risque assurable vs non assurable), le coût d'opportunité, etc.

Dans la plupart des cas, il est préférable de laisser le soin de refactoriser les personnes qui dirigent l'entreprise. Malgré ce que beaucoup d'affiches sur ce forum vocalisent, les gestionnaires en savent généralement plus sur la gestion d'une entreprise que les programmeurs. Ils ont une vision plus large à l'esprit qui comprend la maximisation du rendement pour l'actionnaire. Il est rare que réparer des choses qui ne sont pas cassées y contribue, le code ne fait pas exception.

Edit: J'ai lu un article intéressant sur les calendriers de maintenance sur les infrastructures critiques. L'essentiel est que le mouvement est loin de la maintenance de routine (refactoriser) pour réparer en cas de besoin (corriger les bugs). La principale différence réside dans les niveaux de surveillance - par exemple, une centrale nucléaire surveille en détail et se corrige lorsqu'elle est «cassée» mais bien avant la panne. Ce qui a été constaté, c'est que la fixation à un schéma de maintenance coûte non seulement plus cher, mais est moins fiable en raison des pannes causées par le programme de maintenance. Une idée similaire est requise pour le logiciel - refactoriser les bits qui sont sur le point de casser - que vous ne pouvez connaître que par mesure.

Il est acceptable lorsque les dommages causés à l'entreprise en les réparant sont plus importants qu'en ne les réparant pas.

Les situations où cela se produit peuvent être:

• où une échéance ou une opportunité commerciale pourrait être manquée en raison du temps nécessaire pour corriger
• où un morceau de code est (véritablement) programmé pour être retiré dans un laps de temps très court donc il n'y a presque aucun avantage à le refactoriser.

Et ces situations se produisent - les situations commerciales imposent souvent des délais artificiels qui doivent être respectés lorsque la possibilité de les négocier est passée et des exigences qui ont une composante temporelle - par exemple un changement de législation ou de règles fiscales qui entrent en vigueur une date précise - existe.

L'astuce consiste à identifier ces situations et à les évaluer correctement. Le code qui doit être retiré sera souvent conservé pendant des années. Il peut être nécessaire de respecter des délais artificiels, mais ils peuvent souvent être respectés de différentes manières (par exemple, un logiciel peut être présenté, démo et "lancé" à une date donnée sans que la version finale ne soit nécessairement terminée plus tard).

Lorsqu'on vous présente ce genre de chose, vous devez l'aborder avec un esprit ouvert, mais demandez toujours si c'est ce qu'il apparaît? Les hypothèses impliquées sont-elles réalistes? Existe-t-il un autre moyen d'atteindre l'objectif sans envoyer de code de qualité inférieure? S'il n'y a pas comment utiliser au mieux le temps dont je dispose?

Et s'il n'y a pas d'alternative toujours bien, mais quand allons-nous résoudre ce problème?

Parce que cela devrait presque, presque, presque toujours être quand , pas si .

Si les gestionnaires décident qu'ils veulent accumuler une dette technique . C'est une décision équitable à prendre si l'on veut, par exemple, simplement qu'un premier prototype soit distribué à certains clients initiaux pour obtenir des commentaires précoces.

Vous pouvez y penser de la même manière que demander un crédit. Est-il acceptable d'emprunter de l'argent pour investir dans X à court terme et de le payer à long terme? Il n'y a pas de réponse définitive, cela peut être dans le meilleur intérêt de l'organisation (par exemple pour répondre aux attentes actuelles des clients), ou cela peut être un désastre s'il est fait de manière irresponsable.

Tout dépend des priorités, et la direction doit être consciente que bien que la priorité numéro un soit de faire fonctionner le "code", de mettre en œuvre de nouvelles fonctionnalités et de répondre aux attentes des clients, chaque fois que vous quittez des fenêtres cassées, vous rendez cette priorité numéro un plus lente. , plus difficile, et nécessitant plus d'investissement dans les ressources. De plus, 99% du temps, il n'est pas possible d'arrêter de développer de nouvelles fonctionnalités et de concentrer tous les efforts sur la "correction de la base de code".

En conclusion, oui, il est parfois acceptable de laisser des fenêtres cassées, tout comme il est acceptable de demander un prêt ... rappelez-vous simplement que vous devez vraiment, vraiment payer pour cela à l'avenir. Et à l'avenir, le temps pour le faire ne sera probablement pas beaucoup plus grand que le temps dont vous disposez actuellement.

Normalement, lorsque vous en êtes capable, vous devez le réparer, cela évitera le temps potentiel passé pour la maintenance. Cependant, certaines pratiques barbares non agiles ont tendance à laisser le statu quo tel qu'il dure tant qu'il fonctionne. Certains managers ont peur des "effets imprévus" du changement.

Mon avis est de ne le laisser que s'il fonctionne comme il se doit (cassé uniquement par l'optimisation mais pas par la fonctionnalité) et que vous manquez de temps pour le tester, si vous faites du refactoring. Cependant, vous devez noter qu'il devrait être corrigé le plus tôt possible.

Si sa fonctionnalité est interrompue et que vous en dépendez, il serait préférable de le réparer aussi vite que possible.

La plupart des programmeurs font de l'argent pour leur employeur. Alors, quand le refactoring devrait-il avoir lieu: Quand cela fait de l'argent pour votre entreprise. Le refactoring est le temps passé non consacré à d'autres projets et le temps économisé à l'avenir sur ce projet.

Que cela en vaille la peine dépend principalement de votre manager.

Les programmeurs doivent informer le côté commercial de l'étendue de la dette technique, afin qu'ils puissent prendre une décision éclairée. Si la nécessité d'accéder au marché plus tôt l'emporte sur le risque de votre code, vous n'avez pas beaucoup de choix. Le manque de liquidités l'emportera sur de nombreuses décisions techniques.

Pour mettre certains des problèmes dans une perspective non technique, signalez le délai prolongé pour corriger les bogues et ajouter de nouvelles fonctionnalités. Si la direction a une formation en vente et en marketing, elle peut le comprendre. Ils détestent devoir dire aux clients que ces choses prendront plus de temps.

Si vous songez à élargir votre équipe, cela peut être le bon moment pour embaucher un développeur junior. La couverture des tests sera un énorme sauveur dans ce cas. Ils apprendront plus en faisant qu'en lisant la documentation.

peut-il jamais être justifié de reporter des remaniements majeurs au code existant dans le but de respecter la date limite dans ce scénario?

• Si quelque chose est cassé, alors très probablement pas. Vous ne conduirez pas une voiture avec des freins qui fonctionnent partiellement, n'est-ce pas? (À moins que le risque de ne pas arriver quelque part à l'heure soit supérieur au risque de s'écraser à cause des freins défectueux.) Loin de la solution idéale, mais malheureusement, cela arrive.

Cependant, si vous parlez de refactoriser le code de travail, alors je considérerais ce qui suit:

• Si cela dépendait de nos développeurs principaux ou de notre directeur technique, nous ne publierions jamais aucun logiciel. Nous re-factorisons toujours et recherchons le perfectionnisme.

• Si la refacturation a un impact négatif sur la rentabilité de l'entreprise, elle doit être reprogrammée.

• Si votre entreprise a promis de fournir certaines fonctionnalités à une date donnée, vous devrez refactoriser plus tard. Pensez à la charité Red Nose Day - chaque année, ils peuvent recueillir des dons pour une période de 24 ou 48 heures. Il n'y a aucun moyen qu'ils remodèlent leur base de code s'ils pensaient que cela pourrait les empêcher de faire des dons dans cet intervalle de temps. De plus, s'il y a une fenêtre cassée, mais cela n'affectera pas leur capacité à recevoir des dons, il est fort probable qu'ils choisissent de ne pas refacturer.

• Vous trouverez toujours une meilleure façon de faire quelque chose. C'est un processus naturel et il est très important de pouvoir tracer une ligne.

En réponse à votre question concernant la refactorisation, je dirais «oui». Comme quelqu'un l'a souligné dans les réponses ci-dessus, la refactorisation est un processus continu et, parfois, il y a des décisions tactiques et commerciales qui remplacent la nécessité de réécrire le code qui fonctionne déjà (bien que peut-être de manière klugey).

Concernant les "fenêtres cassées": J'ai entendu ce terme pour la première fois dans le contexte du développement logiciel, il y a environ 10 ans. Mais à cette époque, il était utilisé pour décrire l'autorisation de tests unitaires brisés . Cela décrivait le scénario où les gens ont la tentation de ne pas réparer les tests unitaires cassés, car il semble plus judicieux de se rappeler simplement quels tests sont "corrects d'échouer", au lieu de réparer les tests cassés (qui étaient valablement cassés en raison de l'interface ou des exigences). changements, par exemple).

Je pense que l'application de la métaphore de la fenêtre cassée à des tests unitaires cassés est plus appropriée et plus descriptive du danger d'autoriser des "fenêtres cassées" dans le voisinage logiciel. À mon avis, si vous parliez de tests unitaires brisés (comme des fenêtres brisées), la réponse serait que ce n'est jamais correct. (Dans la mesure où nous pouvons jamais dire jamais ...)

Si c'est vraiment cassé, alors il devrait être réparé.

Mais est-ce vraiment cassé? Êtes-vous sûr que vous n'assimilez pas simplement "pas joli" avec cassé.

Vous devez appliquer un calcul de "valeur irrécupérable" avant de recalculer le code de travail parce que vous n'aimez pas le style ou parce que vous pensez qu'il causera des problèmes à l'avenir.

Pour refactoriser le code que vous avez écrit la semaine dernière, vous avez perdu le coût, c'est le temps que vous avez passé à le coder la semaine dernière, cela ne vaut pas vraiment la peine de s'inquiéter si le code est considérablement amélioré.

Re-factorisation du code ayant fait l'objet d'un test unitaire. Maintenant, vous n'avez pas seulement besoin de réécrire, vous devez redéfinir et réexécuter tous les tests effectués jusqu'à présent, cela commence à paraître cher.

Re-factorisation du code en production. Encore plus de tests à faire, plus un déploiement aux utilisateurs, et, le risque de livrer quelque chose qui ne fonctionne pas aussi bien que l'ancienne version. Vous devez justifier cela et le clarifier avec le grand patron avant d'aller de l'avant.

Code de re-factorisation qui est en production depuis un certain temps et a subi plusieurs versions et corrections de bugs. À moins que vous ne sachiez que le logiciel va cesser de fonctionner, n'y allez même pas!

D'après mon expérience, la date limite est la chose la plus importante pour l'entreprise. Cela dépend vraiment de qui va utiliser votre application. Dans mon cas, c'était pour le logiciel OS de téléphone portable ... des délais manqués signifiaient des objectifs de vente manqués et des résultats boursiers.

Nous avons rencontré beaucoup de moments WTF lorsque nous avons examiné le code dont nous avons hérité et que nous devions clairement changer. Cependant, parce que ce code fonctionnait `` à peu près '' (l'asynchronicité est mal comprise), la direction n'était pas incitée à autoriser le refactoring alors qu'il y avait des engagements en suspens à respecter. Ce n'est que lorsqu'un bug a été vu `` dans la nature '' que nous serions autorisés à changer quoi que ce soit, même si nous pouvions le casser nous-mêmes facilement grâce à des cas obscurs. Une fois, j'ai refactorisé environ 10 000 lignes de code en mon temps et j'ai finalement dû le jeter. Le temps nécessaire pour les tests et autres révisions, etc. ne pouvait être justifié.