Comment réviser mon propre code?
Je travaille sur un projet solo et je dois maintenir mon propre code. Habituellement, la révision du code n'est pas effectuée par l'auteur du code, de sorte que le réviseur peut regarder le code avec des yeux neufs - cependant, je n'ai pas un tel luxe. Quelles pratiques puis-je utiliser pour réviser plus efficacement mon propre code?
Tout d'abord, utilisez des outils pour vérifier autant que possible. Les tests (sauvegardés avec une couverture de code raisonnable) vous donneront une certaine assurance de l'exactitude du code. Les outils d'analyse statique peuvent détecter de nombreuses bonnes pratiques. Il y aura toujours des problèmes sur lesquels vous aurez besoin des yeux humains pour déterminer et vous ne ferez jamais un aussi bon travail en examinant vos propres trucs que quelqu'un d'autre, il y a certaines choses que vous pouvez faire pour aider cependant
- vérifiez que les tests existent et réussissent (possiblement une couverture de test cible, bien que vous deviez peut-être la casser dans certains cas, mais vous devriez pouvoir en justifier la raison)
- vérifier l'analyse statique réussit (il y aura également de faux négatifs ici mais c'est bien tant que vous pouvez justifier pourquoi alors c'est bien de les supprimer)
- maintenir une liste de contrôle des autres éléments à vérifier dans la revue (ajoutez idéalement cela comme de nouvelles règles d'analyse statique si possible) assurez-vous de vérifier tout ce que le SA ne peut pas vérifier, par exemple, les commentaires sont-ils toujours valides) , les choses sont-elles nommées correctement (nommer les choses est bien sûr l'un des 2 problèmes difficiles connus de l'informatique)
- si un défaut est identifié, vérifiez si la cause est systémique et cherchez pourquoi il n'a pas été trouvé dans des tests ou des examens antérieurs
Bien sûr, cela est utile lorsque vous examinez d'autres codes
Jetez un œil sur le site Revue de code Stack Exchange. C'est pour partager le code des projets sur lesquels vous travaillez peer review :
Échange de pile de révision de code est un site de questions et réponses pour rechercher la révision par les pairs de votre code. Nous travaillons ensemble pour améliorer les compétences des programmeurs du monde entier en prenant le code de travail et en l'améliorant.
Si vous recherchez des commentaires sur un morceau de code de travail spécifique de votre projet dans les domaines suivants…
- Meilleures pratiques et utilisation des modèles de conception
- Problèmes de sécurité
- Performance
- Exactitude dans les cas imprévus
Vous pouvez également utiliser des outils d'analyse statique du code pour détecter certains types de problèmes, mais ils vont produire des fausses alarmes dans certains cas, et ne peuvent pas suggérer comment améliorer la conception.
J'ai développé plusieurs personnes totalement différentes dans ma tête. L'un d'eux n'est même pas programmeur! Nous discutons, discutons des dernières nouvelles et examinons le code de chacun.
Je recommande fortement mon approche.
ps Il ne plaisante pas.
Je suis d'accord avec l'opinion de JK-S selon laquelle l'examen par une seule personne n'est pas aussi efficace qu'un examen par deux personnes. mais vous pouvez essayer d'en tirer le meilleur parti:
revue à court terme (peu de temps après la production du code)
J'utilise git comme référentiel local. Chaque fois que j'ai terminé une fonctionnalité ou corrigé un bug, je transfère les modifications dans le référentiel.
Avant de m'enregistrer, je compare ce que j'ai changé dans mon code et repense:
- les noms de variable/méthode/classe reflètent-ils toujours leur utilisation?
revue à long terme (6 mois après la production du code)
Je me demande:
- puis-je décrire en un sens ce que fait une classe/méthode/variable?
- dans quelle mesure est-il facile d'utiliser une classe de façon isolée (sans les autres classes) ou d'écrire un plus simple?
Tout d'abord, mettez votre code de côté aussi longtemps que possible. Travaillez sur autre chose, un autre morceau de code. Même après une journée, vous serez étonné de ce que vous trouverez.
Deuxièmement, documentez votre code. De nombreux programmeurs détestent documenter leur code, mais assurez-vous de vous asseoir et d'écrire de la documentation, comment utiliser le code et comment il fonctionne. En regardant votre code d'une manière différente, vous trouverez des erreurs.
Il a été dit que la véritable maîtrise d'un sujet est la capacité de l'enseigner à quelqu'un d'autre. Avec la documentation, vous essayez d'enseigner votre code à quelqu'un d'autre.
Transformez cette technique de débogage en une technique de révision de code: http://en.wikipedia.org/wiki/Rubber_duck_debugging
Le concept fait des merveilles pour vous mettre dans un état d'esprit approprié pour travailler à travers le code comme s'il était nouveau.
En plus des outils utiles mentionnés dans d'autres réponses, je pense que la modification de votre état d'esprit est utile lors d'une révision de code. C'est idiot, mais je me dis: "Je mets mon chapeau de révision de code". Je fais de même avec QA.
Ensuite, il est important de limiter vous-même à cet état d'esprit. Vous êtes soit le réviseur, soit le critique, vous ne pouvez pas être les deux à la fois. Donc, en tant que critique, je prends des notes objectives à partager avec le critique. Je ne change pas le code pendant que je le revois, ce n'est pas quelque chose qu'un critique devrait faire.
La formalité semble parfois un peu absurde, mais je trouve que lorsque je travaille en solo, je suis souvent entraîné dans de nombreuses directions. Donc, je ne ferme pas nécessairement la boucle de révision avant que quelque chose d'autre ne survienne - cette formalité (et vraiment, je parle de notes brutes dans un outil wiki), est utile pour s'assurer que la révision est effectuée. De même avec mon chapeau QA, j'ajoute des tickets pour les bugs avant de les corriger.
Il semble que le sentiment commun est que l'auto-évaluation n'est pas efficace. Je ne suis pas d'accord et je pense que l'auto-examen peut attraper beaucoup de problèmes s'il est fait à fond.
Voici quelques conseils de mes quelques années d'expérience:
- Ayez une liste de contrôle à portée de main. Ce sont des choses que vous souhaitez signaler lorsque vous lisez votre code.
- Mettez votre examen de code hors ligne. Cela peut sembler inutile, mais prenez des impressions que vous pouvez annoter et inverser, ou l'équivalent numérique de fichiers PDF bien mis en évidence synchronisés avec un iPad qui est ensuite mis hors ligne. Éloignez-vous de votre bureau, de sorte que tout ce que vous faites est d'examiner votre code sans distraction.
- Faites-le tôt le matin plutôt qu'à la fin d'une journée de travail. Une nouvelle paire d'yeux est meilleure. En fait, il pourrait être utile d'avoir été loin du code un jour avant de le relire.
Juste une info - ces lignes directrices faisaient partie des recommandations d'Oracle il y a quelques années lorsque j'y travaillais, où le but était de détecter les bogues "en amont" avant que le code ne passe en test. Cela a beaucoup aidé, même si beaucoup de développeurs le considéraient comme un travail ennuyeux.
La technique du processus logiciel personnel pour les révisions peut être utile, même si elle repose sur des données historiques sur votre travail et la qualité des produits.
Vous commencez avec des données historiques sur vos produits de travail, en particulier le nombre et les types de défauts. Il existe différentes méthodes de classification des défauts, comme celle-ci celle d'un cours PSP . Vous pouvez développer les vôtres, mais l'idée est que vous devez être en mesure de dire quelles erreurs vous faites en cours de route.
Une fois que vous savez quelles erreurs vous faites, vous pouvez développer une liste de contrôle que vous pouvez utiliser lors d'un examen. Cette liste de contrôle couvrirait les principales erreurs que vous faites et qui, selon vous, peuvent être détectées dans une revue (par opposition à l'utilisation d'un autre outil). Chaque fois que vous examinez un produit de travail, utilisez la liste de contrôle et recherchez ces erreurs ou erreurs, documentez-les et corrigez-les. Révisez périodiquement cette liste de contrôle de temps en temps pour vous assurer que vous vous concentrez sur des problèmes réels et pertinents dans votre code.
Je recommanderais également d'utiliser le support d'outils lorsque cela est logique. Les outils d'analyse statique peuvent aider à trouver certains défauts, et certains prennent même en charge la vérification du style pour appliquer la cohérence et un bon style de code. L'utilisation d'un IDE avec complétion de code et mise en évidence de la syntaxe peut également vous aider à prévenir ou à détecter certains problèmes avant de cliquer sur "construire". Les tests unitaires peuvent couvrir des problèmes de logique. Et si votre projet est suffisamment grand ou complexe , l'intégration continue peut combiner tous ces éléments dans un processus régulièrement exécuté et produire des rapports Nice pour vous.
Travailler en solo signifie qu'à moins que vous ne fassiez confiance à des inconnus pour examiner le code en votre nom, vous devrez examiner la façon dont vous écrivez votre logiciel afin de maintenir la qualité du code.
Tout d'abord, vous devez avoir un moyen de vous assurer que votre code correspond aux exigences, et deuxièmement que votre code sera relativement facile à modifier si vous décidez plus tard que vous vous êtes trompé. Ma suggestion serait d'appliquer une approche Behaviour Driven Development pour les raisons suivantes:
- BDD signifie d'abord écrire un test de code. Cela garantit que tout votre code est couvert par des tests.
- BDD est essentiellement TDD, mais avec un accent et un "langage" légèrement différents. Cela implique que vous refactorisez continuellement votre code pendant que vous travaillez dessus et que vous utilisez vos tests pour vous assurer que vos efforts de refactoring continuent de garantir que votre code satisfait les spécifications de votre produit.
- Le langage BDD encourage les tests à être écrits sous la forme d'instructions qui codent essentiellement les exigences en tant que tests unitaires.
Donc, l'idée ici, c'est que votre refactorisation continue de code même après avoir réussi vos tests, signifie que vous examinez efficacement votre propre code et utilisez vos tests unitaires comme la "paire supplémentaire d'yeux" qui garantit que votre code ne fonctionne pas. t s'écarter des exigences qui sont encodées dans les tests. En outre, une couverture de test élevée basée sur les exigences garantit que vous pourrez modifier votre code à l'avenir sans manquer aux exigences.
Le vrai problème pour vous sera de savoir si vous pouvez ou non repérer des problèmes potentiels dans votre code qui indiqueront un besoin de refactoriser. Il existe plusieurs outils de profilage sur le marché qui peuvent vous aider à cet égard, ainsi que plusieurs autres outils qui concernent les mesures de qualité du code. Ceux-ci peuvent souvent vous dire beaucoup de choses que les revues de code peuvent manquer, et sont un must lorsque vous développez des projets par vous-même. En réalité cependant, l'expérience est la clé, et une fois que vous aurez l'habitude d'être impitoyable dans votre refactoring, vous deviendrez probablement beaucoup plus critique envers votre propre code. Si vous ne l'avez pas déjà fait, je vous suggère de lire le livre de Martin Fowler Refactoring comme point de départ et de rechercher une bonne API BDD qui, selon vous, fonctionnera pour vous dans la langue que vous aurez choisie. avec.
Chaque fois que je me suis retrouvé dans la même situation que vous, j'ai essayé de résoudre le problème "d'être trop près du code pour l'examiner objectivement" en utilisant des outils de révision/métrique du code. Il va sans dire qu'un outil ne peut pas donner la même valeur qu'un réviseur expérimenté, mais vous pouvez toujours les utiliser pour identifier des zones de mauvaise conception.
Un outil que j'ai trouvé assez utile à cet égard était SourceMonitor . C'est un peu simpliste, mais cela donne une bonne opinion de niveau intermédiaire de votre code, comme le nombre de méthodes dans une classe et la complexité de chaque méthode. J'ai toujours pensé que ce type d'information était aussi important (sinon plus important que) l'application des styles de codage via des outils comme StyleCop, etc. (qui sont importants, mais ne sont souvent pas la source des plus gros problèmes). Utilisez ces outils avec les avertissements habituels: sachez quand enfreindre une règle empirique, et quelque chose qui est tout vert dans un outil de mesure de code n'est pas automatiquement de bonne qualité.
Je ne peux pas vous dire le nombre de fois où j'ai expliqué quelque chose à un réviseur de code et l'ampoule dans ma tête s'allume et dit: "Hé, attendez une minute." Donc, je trouve souvent mes propres erreurs dans la revue de code que l'autre personne n'a pas vues. Vous pouvez donc essayer cela, commencez simplement à expliquer le code comme s'il y avait une personne assise à côté de vous qui essayait de comprendre ce que vous avez fait et pourquoi.
Une autre chose que je trouve fréquemment dans les revues de code est que le développeur n'a pas réellement suivi l'exigence. Donc, comparer votre code et ce qu'il fait l'exigence réelle est une bonne vérification.
Nous faisons souvent des choses comme les packages SSIS qui ont des besoins structurels similaires - pour les revues de code, j'ai développé une liste de contrôle des choses à vérifier (la configuration est-elle correcte, la journalisation est-elle configurée, utilise-t-elle la base de données de métadonnées, les fichiers se trouvent-ils à l'emplacement standard, etc.). Vous pourriez également avoir des choses à vérifier à chaque fois dans une révision de code. Asseyez-vous et pensez à ce que vous mettriez sur une liste de contrôle des choses que vous voulez vous assurer de vérifier dans votre examen du code (premier élément, assurez-vous que l'exigence est remplie, l'élément suivant pourrait avoir quelque chose à voir avec les erreurs de piégeage et de journalisation). Au fur et à mesure que vous faites des erreurs et que vous les corrigez, vous pouvez ajouter d'autres éléments à la liste (dites quelque chose comme: dois-je passer au prochain enregistrement dans une boucle ou vais-je répéter sans cesse le même premier élément - cela ne prend qu'une boucle sans fin pour vous apprendre à chercher cela!). C'est principalement pour vous empêcher d'oublier de faire certaines choses qui devraient être faites.
J'imprime habituellement tout mon code et m'assois dans un environnement calme et le lis, je trouve beaucoup de fautes de frappe, de problèmes, de choses à refactoriser, de nettoyage en faisant cela. C'est une bonne auto-vérification que je pense que tout le monde devrait faire.
Donnez-lui 3 mois, puis revenez en arrière et regardez votre code. Je vous le promets, si vous ne trouvez rien de mal à cela (ou si vous vous demandez qui a écrit cette ordure!), Vous êtes un homme meilleur que moi!
De retour au collège, j'étais professeur d'écriture. Cela m'a certainement donné des perspectives de codage auxquelles je pense que de nombreux développeurs n'auraient jamais pensé. L'un des plus importants est de lire votre code à haute voix. Cela ne semble pas beaucoup, mais je vais donner un exemple parfait auquel je pense que tout le monde peut s'identifier.
Avez-vous déjà écrit un e-mail ou un article, relu plusieurs fois pour vous assurer qu'il est correct, puis envoyé, pour constater que vous avez une erreur d'orthographe flagrante, une faute de frappe ou une erreur grammaticale? Je viens de le faire hier lorsque j'ai demandé à un client d'appuyer sur la touche merde au lieu de la touche Maj. Lorsque vous lisez dans votre tête - vous voyez ce que vous voulez voir.
Il s'agit d'un raccourci pour les suggestions des "autres, attendez un jour, une semaine ou un mois". Si vous le lisez à haute voix, vous attrapez les mêmes choses. Je ne sais pas pourquoi il est si efficace, mais après s'être assis avec des centaines d'étudiants et les avoir lus à haute voix, tout ce que je peux dire, c'est que cela fonctionne.
La plupart des gens ont tendance à considérer leur code comme leur propre bébé et à le nourrir d'ego plutôt que de réalité. Comme tout autre examen de code, examinez-le lorsque vous voyez le code de quelqu'un d'autre. Oubliez complètement que vous avez écrit quelque chose. Vérifiez chaque ligne du code. Une liste de contrôle serait utile pour être esthétique sur la révision de son propre code. Des outils automatisés de révision de code peuvent aider dans une certaine mesure. J'ai utilisé des outils comme klocwork (logiciel commercial), c'est très utile lorsque vous travaillez sur de grands projets et que plusieurs développeurs y travaillent. Concentrez-vous toujours sur la détection des défauts plutôt que sur la correction.
Mais une meilleure pratique serait de vous revoir et d'impliquer plus tard au moins deux autres personnes pour un examen avec des rôles distingués.
Pensez à faire une inspection Fagan par vous-même - vous devrez adapter le processus parce que vous êtes seul, mais vous devriez pouvoir en tirer un peu de valeur. L'astuce sera de trouver le bon "ensemble de règles" pour évaluer votre code en tant que développeur solo, puis d'avoir la discipline pour poser ces questions dans un état d'esprit critique, analytique et impitoyable à chaque fois. Je pense que vous voudrez peut-être commencer par réfléchir à vos propres 4-5 questions cruciales, puis les faire évoluer au fil du temps. Certaines personnes sont contre les inspections formelles, car elles semblent prendre beaucoup de temps ... avant de décider qu'elles sont trop chères, gardez à l'esprit toutes les preuves statistiques selon lesquelles une inspection correcte réduit réellement le temps du projet. Voici un lien Wikipédia avec lequel vous pouvez commencer des recherches supplémentaires:
http://en.wikipedia.org/wiki/Software_inspection
Il y a eu aussi quelques livres, par exemple Google pour "Software Inspection Process" par Strauss et Ebenau.
Une autre option est de payer quelqu'un pour inspecter un projet important - ou peut-être de le payer occasionnellement pour faire des inspections de tout votre code. Ce gars est plutôt bon, nous l'avons envoyé plusieurs fois pour former nos nouveaux développeurs:
Outre toutes les recommandations pour la révision du code, vous pouvez utiliser les outils tels que PMD et findBug pour effectuer le premier niveau de cohérence pour votre code.
Cela n'a pas encore été placé dans une réponse (mais a été ajouté en tant que commentaire à une réponse existante)
Vérifiez votre code après une bonne nuit de sommeil, par exemple commencez la journée en examinant le code que vous avez écrit la veille.
Bien sûr, cela ne vous donnera pas l'expérience collective d'une équipe, mais cela vous permettra de revoir le code dans une nouvelle perspective.
Par exemple, si vous avez laissé un morceau de code avec un méchant hack, vous pourriez ne pas être trop enclin à le corriger, si vous passez en revue votre code immédiatement après. Après tout, lorsque vous commencez à réviser votre code, vous savez déjà et avez accepté la présence de ce hack. Mais si vous avez bien dormi, vous êtes probablement plus motivé pour trouver une meilleure solution.
Lorsque nous dormons, le cerveau n'arrête pas de travailler sur les problèmes que nous avons, vous pouvez donc trouver une solution là-bas, bien que ces solutions peuvent parfois se présenter de manière étrange .