Comment prendre du recul et regarder le code avec des yeux neufs? [fermé]

J'ai passé une année en tant qu'équipe individuelle à développer une application pour client riche (plus de 35 000 LdC, pour ce qu'elle vaut). Il est actuellement stable et en production. Cependant, je sais que mes compétences étaient rouillées au début du projet. Il ne fait donc aucun doute que le code pose de gros problèmes. À ce stade, la plupart des problèmes concernent l'architecture, la structure et les interactions - les problèmes simples, même les problèmes d'architecture / de conception, ont déjà été éliminés.

Malheureusement, j'ai passé tellement de temps avec ce projet que j'ai du mal à penser en dehors de celui-ci - je l'aborde dans une nouvelle perspective pour voir les défauts profondément enfouis ou inhérents à la conception.

Comment sortir de ma tête et de mon code pour obtenir un nouveau look et l'améliorer?

Façons d'aborder ceci:

• Trouvez une personne familière avec le problème technologique et commercial et discutez-en. Cela peut être difficile dans une équipe composée d'une seule personne, mais c'est généralement la meilleure option.
• Travailler sur un projet différent pendant un moment. Cela peut aussi être difficile, mais même prendre une semaine de congé peut vous donner une nouvelle perspective.
• Examinez des projets ou produits similaires, tels que des produits open source, s’il en existe. Veillez à ne pas copier le code, mais ils ont peut-être abordé l'idée de manière complètement différente.
• Apprenez une nouvelle langue, une nouvelle bibliothèque ou un nouveau framework. Les techniques impliquées peuvent vous aider à comprendre comment aborder les mêmes problèmes différemment.
• Lisez un bon livre / blog / magazine sur le design ou le langage / framework. Je ne suis pas sûr de votre niveau de compétence, mais il existe de nombreuses alternatives dans les autres réponses de ce site.

Si vous avez des exemples spécifiques que vous souhaitez aborder, peut-être les poster ici.

Débogage de canard en caoutchouc : Assoyez-vous avec un morceau de code, un module ou une fonctionnalité et expliquez-le à voix haute. Lorsque vous vous trouvez en train de dire quelque chose qui semble faux, stupide ou tout simplement pas bien, écrivez-le comme un problème à examiner.

Continuez à apprendre et à développer vos compétences. Il est difficile de savoir ce que vous ne savez pas, mais quand vous le verrez, ce "aha" vous frappera. Cela pourrait provenir de l'apprentissage d'une autre langue ou d'un modèle de conception.

On vous demandera de faire un changement. Vous trouverez peut-être des parties de votre code qui ne sont pas si flexibles et qui nécessiteront de nombreuses retouches. Ce n'est pas nécessairement un échec car vous ne pouvez pas tout penser au début.

Les utilisateurs vont commencer à se plaindre. Juste quand vous pensez que tout va bien ...

Une mémoire courte aide. Je suis connu pour me plaindre de "l'idiot" qui a changé quelque chose il y a une semaine, seulement pour découvrir que c'est du contrôle de code source que c'était moi.

Une bonne première étape consiste à identifier le code qui pourrait être amélioré. Recherchez dans votre contrôle de code source les fichiers qui changent le plus souvent. Quel est le code le plus difficile à utiliser? Quel code produit le plus de bugs? Quels types de modifications entraînent un effet d'entraînement dans le code? A ce stade, vous ne devez pas savoir pourquoi le code est gênant, juste que c'est gênant.

Une fois que vous avez identifié les domaines sur lesquels travailler, essayez de déterminer quel est le problème. Certains livres adoptent une approche systématique pour classer les problèmes de conception. Regardez le refactoring de Martin Fowler , les normes de codage C ++ de Herb Sutter , le code propre de Robert Martin , etc.

Une fois que vous avez identifié le problème probable, essayez différentes manières de le résoudre. Par exemple, si la règle que vous avez enfreinte est "préférez la composition à l'héritage", changez-la en composition et voyez comment elle se sent.

Évidemment, il peut être utile que quelqu'un d'autre examine le code, mais ce n'est pas toujours aussi utile qu'on pourrait le penser, car vous êtes beaucoup plus familiarisé avec le type de problèmes causés par le code que quiconque, et avec les raisons qui ont motivé sa conception. . Apprendre à évaluer objectivement votre propre conception rapportera de gros bénéfices.

Demandez à une autre personne de regarder votre code. Si vous ne trouvez pas une autre personne pour la regarder, écrivez une description complète de l'interaction, comme si vous alliez la montrer à une autre personne. Essayer d’expliquer vos décisions à une autre personne (même si c’est juste pour la pratique) peut vous aider à vraiment réfléchir POURQUOI vous faites les choses d’une certaine manière et vous aider à voir les failles de votre logique.

Je connais très bien cette situation. Lorsque je suis bloqué de cette façon, j'essaie d'adopter différents points de vue sur le projet.

1.) Point de vue de l'utilisateur / client - utiliser les commentaires

Malheureusement, nous sommes pris dans notre code de manière à ne pas voir nos propres défauts car nous utilisons nos applications de la manière dont nous les avons codées. Observez comment les gens l'utilisent et essayez de déterminer quel serait le guide d'utilisateur le plus intuitif. Jouez avec les prototypes d'interface utilisateur. Cela semble amusant, mais si vous découvrez que vous seriez obligé de recoder d’énormes parties de votre code simplement en modifiant la logique d’utilisation, il est temps de commencer un cycle de refonte.

2.) Faites une analyse fonctionnelle de votre code et visualisez-le

Certains IDE et frameworks vous poussent à mélanger par exemple du code d'interface utilisateur et du code de base. Si vous laissez cela se produire, vous serez un jour confronté à la situation selon laquelle votre base de code peut difficilement être maintenue à cause de dépendances nébuleuses et difficiles à rompre. Le mélange de code d'interface utilisateur avec un autre code peut conduire à un code spaghetti et à des fonctionnalités redondantes. Divisez votre code en blocs fonctionnels, tels que des classes de base de données, des classes de communication, des classes d'interface utilisateur, des classes de base, etc., et attribuez aux noms des noms fonctionnels. Puis visualisez la fonctionnalité avec un outil graphique (j’utilise un outil de cartographie conceptuelle) afin de déterminer si votre structure est suffisamment logique et modulaire pour pouvoir réutiliser d’énormes blocs de code pour différents projets et les remplacer par des versions plus récentes. grosse douleur.

D'après mon expérience, la meilleure façon de procéder consiste à créer un document qui visualise toutes les dépendances entre vos classes et leurs appels à partir de votre code. Le résultat est une visualisation de la conception de votre interface. Si cette carte de code ressemble à un cluster complet, il est temps d'agir. Si ce n'est pas encore le cas, vous devriez penser à une convention de nommage appropriée qui représente votre structure de code de manière à ce que vous n'ayez pas à réfléchir à la façon de l'appeler et à ce qu'elle fait.

3.) Utiliser des approches communes pour l'assurance de la qualité

Mon préféré est la FMEA. En termes de codage, cela signifie non seulement analyser ce qui a mal tourné dans le passé, mais aussi penser à ce qui pourrait mal tourner. Un exemple assez courant est une connexion réseau soudainement interrompue. Ceci fait, vous pouvez classer les conditions d'erreur en fonction de conséquences telles que la perte de données, un crash, un calcul erroné et en évaluer l'impact sur l'utilisateur. Si ce n’est pas encore fait, définir des classes et des routines d’erreurs et d’exceptions simplifiées peut vous aider à garder votre code propre et net. Le meilleur moyen est de les implémenter dans chaque nouvelle paix de code avant même de commencer à écrire autre chose. (Et bien, je ne suis pas coupable de suivre moi-même ce conseil.)

En outre, cela m'a aidé à générer et à mettre à jour fréquemment une "liste de propositions d'amélioration" pour mon propre code. (Pour être honnête, il y a encore beaucoup de code dans mes projets dont je ne suis absolument pas fier.) J'essaie également de prendre le temps de rassembler et de jeter un coup d'œil sur le code des meilleures pratiques dans les documentations API, les conférences de développeurs ou les magazines de développeurs.

Jusqu'à ce point, vous n'avez pas besoin de toucher votre code. Il s'agit simplement de savoir ce qui ne va pas et de trouver un moyen de définir comment améliorer votre code.

Enfin, quelques astuces pour le travail quotidien d'un vieux fou. Essayez d'éviter de mordre plus que vous ne pouvez manger. Cela conduit à trop de pression pour un codage propre. Vous avez rarement le temps de bien faire les choses, mais vous devrez prendre le temps de corriger les imperfections par la suite.

Rien n’est aussi durable que la solution provisoire, mais lorsqu’elle se casse, il est souvent trop tard pour la réparer à temps. Les exemples sont des hacks méchants ou des exceptions étranges que j'avais l'habitude de faire fonctionner, malgré par exemple une faille dans le framework ou le système d'exploitation sous-jacent. Et puis la faille se corrige ou la nouvelle version supprime simplement l'API…

Si vous êtes coincé et que vous êtes obligé de trouver une solution de contournement, faites des commentaires et prenez des notes qui devraient être révisées de temps à autre. Normalement, nous obtenons de mieux en mieux parce que nous apprenons quelque chose de nouveau. Si vous trouvez un meilleur moyen, mettez-le en œuvre le plus rapidement possible. Sinon, vous pourriez vous retrouver en train de coder la solution de contournement pour la solution de contournement et l'exception de l'exception un jour. (Celui qui est sans péché parmi vous, qu'il me jette le premier octet.)

Ne pas transpirer les petites choses.

Tout le monde pourrait mieux coder. Nous faisons les choses rapidement et nous réalisons quelques semaines après que cela aurait pu être fait plus efficacement. Le fait est que 90% de votre code est probablement suffisant.

Examinez vos journaux de bogues et recherchez les routines pouvant être à l'origine de problèmes. Lorsque vous trouvez les bogues, vous pouvez également examiner le code et réfléchir à ce qui pourrait le rendre plus efficace. La plupart du temps, vous vous rendrez compte qu'au-delà de la résolution du bogue lui-même, vous ne pourrez pas apporter d'amélioration notable, mais parfois, vous réaliserez qu'il existe un meilleur moyen de faire quelque chose.

Parlez aux utilisateurs et voyez où ils remarquent des problèmes, qu'il s'agisse de problèmes UX ou de vitesse. Résolvez ces problèmes, avec un oeil pour essayer d'améliorer votre code.

À un moment donné, vous découvrirez que votre code est devenu trop fragile et qu'il est tout simplement impossible de procéder aux modifications nécessaires. Ensuite, réfléchissez à la manière dont vous auriez pu rendre le système plus flexible, via des API ou un développement piloté par des tests. Dans de nombreux cas, vous découvrirez que vous pouvez simplement commencer à insérer ces API dans le code sans trop de modifications. Dans d'autres cas, vous vous rendrez compte que l'effort d'amélioration du code n'en vaut pas la peine.

Les changements progressifs peuvent être difficiles. L'objectif est de ne pas réécrire entièrement la base de code si vous n'en avez pas besoin. Bien sûr, vous êtes un meilleur programmeur maintenant que vous ne l’étiez il ya un an, mais ce que vous avez doit fonctionner maintenant. Dans 5 ans, lorsqu'un jeune programmeur se plaint de l'ancien code qu'il doit essayer de corriger, il suffit de sourire et d'acquiescer, et de ne pas admettre que vous l'avez écrit.

Avez-vous envisagé de partir et de trouver une entreprise où vous pourriez faire partie d'une équipe? Je suis persuadé que, dans le cas d’une équipe isolée ou stagnante, les développeurs passent à côté de tout ce que la profession a à offrir.

Les examens par les pairs permettent à quelqu'un qui est déjà en dehors de votre tête de vous donner des conseils. Stack Exchange Code Review peut être un bon endroit pour mettre en examen un code qui n'est pas propre à votre entreprise. Il ne peut probablement pas gérer d'énormes blocs, mais de nombreux programmes sont constitués de beaucoup de code simple et d'un autre code qui n'est pas simple et qui crée beaucoup de problèmes. Si vous avez un exemple de code typique, mais répété et modifié de nombreux endroits, il pourrait également être un bon candidat à la révision. Par exemple, si vous formatez des messages, ne demandez pas à ce que tous les messages qui passent soient revus, mais simplement un exemple de message assez complexe.

Si vous voulez être plus objectif à propos de votre propre code, vous pouvez le comparer à une norme de codage, y exécuter des vérificateurs de code statiques ou dynamiques ou, si vous êtes très peu documenté, l'ajout de commentaires peut aider.

Il existe une psychologie des tests qui rend difficile le test de votre propre code, mais nous faisons de notre mieux pour le faire pendant les tests unitaires. La lecture de votre propre code peut être un problème similaire ou pire. De nombreux domaines utilisent des mentors, des juges compétitifs, des entraîneurs, etc. Le nôtre en fait autant si vous comptez les architectes, les ingénieurs système et les testeurs. Les clients ayant accès à un outil de rapport de bogue ou à un service d'assistance clientèle vous donneront des informations de l'extérieur de votre tête une fois le produit mis sur le marché. C’est une autre bonne raison pour l’approche agile de publication anticipée et fréquente. Vous êtes peut-être le seul développeur de votre entreprise, mais certaines personnes concernées par votre code peuvent vous donner des informations à ce sujet.

"Est-ce un problème moins important que je ne le pense, ou est-ce un problème rencontré également par d'autres?"

Sheesh. Déjà assez. Si le code est en production, sans bug et en faisant ce qu'il est censé faire, l'architecture est sans importance. Au moins pour l'instant.

Espérons que nous apprenons tous au fur et à mesure. J'ai écrit beaucoup de code dont j'étais fier au moment où je l'ai écrit, pour décider que c'était affreux un an ou deux plus tard. Je travaille actuellement sur un projet pluriannuel qui contient un code incroyablement cruel, mais le code fonctionne. J'adopte une approche très conservatrice.

Et vous devriez donc. Si vous ne voyez pas de problèmes architecturaux majeurs pour le moment, après une année de travail, je pense que vous pouvez supposer, pour le moment, qu'il n'y en a pas. Ce n'est pas un mauvais travail. Ça avance.

En plus d'autres réponses, je vous conseillerais de participer à une conférence de développeurs.

Cela vous exposera à de nombreux sujets et à des personnes qui vous feront penser à votre propre application et à votre lieu de travail. D'autant plus qu'ils vont parler de ce qui fonctionne et non pour cette fois, et des problèmes qui se posent Il y a de fortes chances qu'il y ait un chevauchement avec votre application.

Prenez de préférence 3 jours pour cela. J'ai trouvé que c'était assez long pour obtenir la distance mentale nécessaire à mon propre travail et le regarder à travers les yeux d'une communauté plus large (pour ainsi dire), plutôt que le mien.

Incidemment, cela s'applique également aux équipes de personnes, car la pensée de groupe peut se produire n'importe où.

Enfin, si vous n’obtenez pas l’approbation nécessaire, changez d’emploi une fois par an.

• Pratique des modèles de conception et des meilleures pratiques
• Choisissez un cadre, des outils, des packages, etc. en fonction des exigences et des besoins de votre application. Pour ce faire, vous devez lire de nombreux blogs sur Etch et trouver des solutions à chaque problème technique.
• Créez un brouillon de conception / architecture et discutez avec quelqu'un de doué en technique / architecture. Améliorez ce projet en utilisant les commentaires et les commentaires. continuez ainsi jusqu'à ce que vous obteniez un état stable.

• Implémentez un code tel que tout ce dont l'application a besoin soit configurable et maintenable

  Réorganiser et réimplémenter votre projet aura certainement pour résultat que l'application aura une meilleure cohérence, performance, etc.

Je crois que cela aide à résoudre les problèmes avec quelques personnes intelligentes. Il doit y avoir des informations spécifiques. Est-ce un site Web 24x7x365? App LoB? Où est-il en cours d'exécution ou hébergé?

Une fois que vous entrez dans les objectifs principaux et les résultats souhaités, les autres peuvent vous aider à vous concentrer et à diriger votre attention. Votre code pourrait être le meilleur code jamais écrit pour une tâche spécifique - ou le pire. Cela n'a pas vraiment d'importance - comment cela affecte-t-il l'objectif souhaité?