Comment surmontez-vous vos propres biais de codage lors de la remise du code hérité? [fermé]

En tant que programmeurs, nous sommes souvent extrêmement fiers de nos compétences et avons des opinions très fortes sur ce qu'est un «bon» code et un «mauvais» code.

À un moment donné de notre carrière, nous avons probablement eu un système hérité abandonné dans nos tours, et nous avons pensé: "Mon dieu, ce code est nul!" parce que cela ne correspondait pas à notre notion de ce que devrait être un bon code, malgré le fait qu'il pourrait bien être un code parfaitement fonctionnel et maintenable.

Comment vous préparez-vous mentalement lorsque vous essayez de vous familiariser avec le travail d'un autre programmeur?

Pour toute base de code héritée, la bonne façon de vous préparer mentalement à y faire face est de commencer par lui écrire des tests unitaires .

Qu'il suce ou non, vous devez d'abord avoir la confiance de pouvoir le changer sans casser des trucs!

Je ne peux pas vous dire combien de fois j'ai dit "Oh, c'est totalement faux", je l'ai réécrit, puis j'ai découvert à la dure pourquoi ce code a été écrit de cette façon. Habituellement, il s'agit d'une exigence non écrite / non documentée non évidente. Du moins, c'est vrai dans le code hérité sur lequel je travaille actuellement.

Vous attendez d'avoir été assez longtemps pour rencontrer votre propre code hérité. C'est une expérience humiliante et une partie du processus d'apprentissage. J'aspire au temps où je savais tout.

Je pense que Fosco avait un grand intérêt à pouvoir le mettre dans le contexte de restrictions potentielles de temps et de fonctionnalité. Parfois, vous êtes obligé de faire fonctionner quelque chose.

Et enfin, comprenez que c'est pourquoi vous avez un emploi.

Riez-le, essayez de ne pas trop le juger et passez-le. Ce n'est pas bon d'être un vrai code-nazi ... Il y a certainement quelque chose comme «assez bon» ou même «assez bon à l'époque». Il y a de nombreuses fois où quelque chose est développé ou bandé pour résoudre une crise, puis jamais revisité.

Si c'est vraiment mauvais, voyez si vous pouvez faire un cas pour le réécrire .. si ce n'est pas important, entrez et sortez.

Choisissez vos batailles. Connaître la différence entre «je ne l'écrirais pas de cette façon» et «cela crée un sérieux problème de maintenance ou de soutien»

Souvent, je trouve utile d'avoir une idée de ce que les développeurs originaux pensaient être bon.

Recherchez des modèles et des thèmes pour ce qu'ils ont fait et, souvent, vous trouvez qu'il y avait des raisons pour certaines des décisions étranges en premier lieu.

Parfois, vous trouvez que le développeur d'origine était en fait mauvais, mais vous avez une idée du type de mal qu'ils vendaient à l'époque.

Quoi qu'il en soit, après avoir fait cela, vous devriez avoir une meilleure idée de l'endroit où vous pouvez commencer une réécriture ou à quoi ressemblerait une solution rapide sans avoir à tout refactoriser.

Plus important encore, ne présumez pas immédiatement que, simplement parce que c'est moche, c'est mauvais. Rien ne vous fait paraître plus stupide que de passer du temps à moderniser quelque chose pour découvrir qu'il est moins capable que l'original.

Si j'ai le temps, je l'attaque et je tue le code mal écrit.

C'est la guerre.

Je raisonne toujours que le code laid est un code qui a vu de nombreux débogages, avec de nombreuses subtilités qui ne sont pas apparentes avec une inspection superficielle. Si je le remplace ou le remodèle en profondeur, je dois m'assurer de bien comprendre tous les aspects de ce que fait le code. Si je n'ai pas le temps d'aller au fond des choses, je dois adopter une approche de risque minimal, en effectuant le plus petit changement possible pour atteindre mes objectifs.

Habituellement, je ferai un petit correctif / changement, et proposerai une fonctionnalité pour un développement ultérieur qui excuserait d'aller au fond des choses et de refactoriser le tout. Ensuite, je fais de mon mieux pour ignorer le code jusqu'à ce que la fonctionnalité se retrouve sur la feuille de route.

Lorsque le code hérité a plus de deux ans, il peut avoir été écrit de cette façon en raison des limitations de la langue ou des systèmes d'exploitation, etc. qui existaient au moment où le code a été écrit. Hé, ça a l'air mal maintenant mais était-ce mauvais alors? J'essaie de supposer que le développeur avait une raison pour ce qu'il ou elle a fait. Cette raison peut ne plus s'appliquer, mais en supposant qu'il y en ait une au lieu d'une simple incompétence générale (les jeunes programmeurs penseront la même chose à propos de votre code dans 5 ans peut-être encore moins) vous rend moins en colère à ce sujet. Si cela fonctionne et qu'aucun problème ne lui est associé, chérissez ce code hérité, aussi laid soit-il, car il vous permettra de résoudre des problèmes plus excitants.

Dans le passé, quand je n'avais pas eu le temps de pisser sur le code de quelqu'un d'autre et de le transposer dans "mon" style, j'ai dû recourir à une approche très axée sur les tâches:

Qu'est-ce que j'essaye d'ajouter à ce code / corriger / faire fonctionner?

Est-ce que je fais pour atteindre cet objectif? Sinon, arrêtez de le faire et revenez à la dernière fois que je faisais des changements axés sur les tâches.

Ai-je terminé cette tâche? Si c'est le cas, arrêtez de bricoler le code, même s'il semble qu'il a été écrit par un moule martien non sensible.

À moins que vous ne soyez prêt à posséder le code et les correctifs nécessaires à l'avenir, ne le touchez pas. Vous surmonterez la tendance à vouloir réparer quelque chose lorsque vous cassez quelque chose que vous n'avez pas écrit parce que vous ne l'avez pas étudié suffisamment bien avant de plonger, et cela vous prend 2 jours et un exercice d'incendie pour le faire fonctionner à nouveau .

Ne vous méprenez pas ... il existe des raisons légitimes de refactoriser le code, mais si une entreprise exige que le code fonctionne, et que vous le "corrigez" sans en connaître les conséquences avant de vous lancer, vous demandez un monde de souffrance .

La refactorisation un peu à la fois peut être utile, mais soyez très prudent lorsque vous modifiez un petit aspect de la façon dont le code se comporte réellement, à moins que vous ne compreniez pourquoi ce comportement existe et ce qu'il affecte. Malheureusement, le code qui en a le plus besoin est parfois le plus difficile à modifier sans toucher au comportement, bien que vous puissiez généralement en redresser certaines parties, ou du moins le commenter.

Je travaille presque exclusivement sur le code hérité ces jours-ci et je pense toujours "Oh sh% t, à quoi pensaient-ils?" . Ensuite, je commence à écrire des tests unitaires pour le code et c'est le point où je dois vraiment analyser le flux de contrôle et les dépendances.

Parfois, il n'est pas possible d'écrire facilement des tests unitaires. Mais pendant que j'essaye, j'obtiens des informations sur le code et je comprendrai pourquoi il a été écrit tel quel. Parfois, cela prouvera que le code est vraiment un gâchis, parfois je comprends le processus de réflexion des développeurs originaux et je peux ajouter une documentation utile ou réécrire un morceau de code lorsque je veux ajouter une nouvelle fonctionnalité.

Pour moi, il est utile de penser que mon code se ressemblera quand je reviendrai dans 12 mois .

Avec l'expérience vient le jugement de savoir quand le code est vraiment mauvais et quand il est simplement écrit dans un style différent. S'il est parfaitement fonctionnel et maintenable et qu'il existe une bonne couverture de test automatisée , alors ce n'est pas mauvais et il vous suffit d'ouvrir votre esprit. Vous apprendrez probablement quelque chose. Un mauvais code n'est ni fonctionnel ni maintenable.

Voici quelques marqueurs de code vraiment mauvais:

• De gros blocs de logique ont été dupliqués au lieu d'être refactorisés.
• Dépendances circulaires entre classes ou packages
• Couplage élevé; faible cohésion
• Variables inutilisées, écriture dans des variables qui ne sont jamais lues, code inaccessible.
• Réimplémentation des fonctions de bibliothèque standard, par exemple formatage de la date.
• Logique inutilement complexe; c'est-à-dire 50 lignes de code où 10 feraient bien.
• Aucun commentaire décrivant le but des classes ou des méthodes.
• Commentaires trompeurs.

Un manque de tests automatisés ne signifie pas que le code est mauvais, mais cela signifie que le projet est mauvais.

Ce n'est pas une question de goût; ces pratiques rendent la maintenance des programmes beaucoup plus coûteuse.

Comment vous préparez-vous?

Acceptez le fait qu'il faut un certain temps pour réussir à travailler sur une nouvelle base de code. S'il est «parfaitement maintenable» et qu'il y a une couverture de test élevée, cela prend moins de temps mais cela ne se produira toujours pas immédiatement. Si le code est mauvais, la première chose que je fais est d'avertir les parties prenantes qu'il est en mauvais état et que les progrès initiaux seront lents. S'ils sont sceptiques, je soutiens ma revendication en leur montrant un échantillon de problèmes dans le code réel et en expliquant comment il diffère des meilleures pratiques de l'industrie.