À quoi ressemble une critique de code?
J'écris un document de processus de revue de code pour notre équipe; Nous n'avons jamais eu de processus formel en place, même si nous faisons une critique de code.
J'ai trouvé de nombreux articles en train de parler de l'importance de la revue de code importante, mais j'ai une question en particulier que je n'ai pas trouvé la réponse à sur le Web ... est la partie programmeuse de l'examen du code? En d'autres termes, un examen de code devrait-il être 2 personnes assises ensemble, aller sur ce qui est dans le code, ou devrait-il être 1 personne en regardant le code d'une autre personne?
Le plus souvent, nos projets sont effectués par une équipe de 2 personnes. Donc, avant d'être envoyé à QA, ces 2 personnes sont-elles simplement assis ensemble et survolent tout le projet, y compris ce que chacun d'entre eux a écrit? Ou, devraient-ils simplement regarder le code de chacun? Je peux voir des avantages à chacun.
Enfin, que se passe-t-il avec les problèmes trouvés lors de l'examen du code? Sont-ils notés, puis renvoyés au programmeur? Ou si le relecteur doit-il notter-les, puis juste les réparer? Ou est-ce que ça va de faire un changement et de ne pas même dire au programmeur spécifiquement ce que vous avez trouvé?
Un examen de code formel pourrait aller comme ceci:
- Le programmeur envoie le matériel à l'examinateur
- Le critique passe sur le matériel
- Programmeur et critique s'assoient à travers le matériel. Le programmateur prend des notes. La discussion design est reportée.
- Le programmeur corrige tout ce qui est sorti de l'examen.
Le programmeur doit toujours parler aux examinateurs, sinon, trop d'informations seront perdues.
Notez que puisque vous n'êtes que deux personnes de l'équipe, vous pouvez probablement obtenir quelque chose de très informel, comme la procédure à suivre du code sur l'écran Programmers.
Notez également que la programmation paire est une excellente alternative à l'examen.
Ce que vous semblez parler, c'est ce que les gens appellent "la programmation par paire", assise ensemble et discutant de votre code pour vous assurer que cela n'est pas exempt de défauts. C'est toujours une bonne idée et une personne qui est normalement encouragée. Cependant, cela n'exclut pas la nécessité d'une revue officielle. Revues formelles Obtenez tout le monde sur votre équipe familiarisez-vous avec le code, plus d'autres yeux sont toujours un plus!
Un examen officiel devrait toujours, Toujours inclure l'auteur afin qu'ils soient libres de clarifier des commentaires au besoin. Cependant, ils ne devraient jamais être la tête de l'examen. Cela les empêche de devoir avoir beaucoup de contrôle sur le processus et éventuellement sauter des aspects importants de leur code.
Beaucoup d'autres réponses couvrent comment suivre les défauts rencontrés lors d'une revue de code, donc je ne les repousserai pas ici, mais il est toujours important de prendre des notes lors de ces réunions et de les rapporter à l'auteur. L'auteur devrait presque toujours être responsable de la mise en œuvre des modifications constatées lors de l'inspection.
À mon école, mes professeurs ont créé une vidéo de ce qu'une inspection de code devrait ressembler et ce que les rôles majeurs devraient être. Nous le trouvons tous assez fringés, mais cela couvre de bons points. Vous pouvez le regarder ici: http://www.se.rit.edu/~kurt/videotest/
Dans mon expérience, faire un examen de code une réunion physique formelle entraîne généralement trop peu de code à être examiné, ou les examens étant sous-par. Je préfère de loin un outil comme - CODE Collaborator , Gerrit , ou les caractéristiques de révision intégrées d'une certaine version de contrôle d'hébergement comme Github ou Four. Cela vous permet d'informer autant de personnes que vous avez besoin ou de vouloir, puis ils peuvent revoir à leur époque (je me réserve la dernière heure de la journée). L'auteur d'origine fait ensuite teste, teste et télécharge des corrections et celui qui a trouvé le défaut des signes sur la correction. Cela vous permet d'avoir une approche itérative plus agile pour faire des critiques, plutôt que d'être un grand événement à la "fin".
Dans la société que je travaille, le processus est assez simple: la personne responsable demande le soutien d'un collègue (de manière informelle). La collègue devrait être une personne qui connaît la fonctionnalité de revenante (mais ce n'est pas indispensable).
Nous faisons des critiques "Solution conceptuelle" et "Mise en œuvre".
Dans l'examen "Mise en œuvre", le responsable explique le problème (s'il n'est pas encore connu) et la solution (si elle n'est pas encore connue), puis passe le code et la documentation interne. Cela se produit sur la machine du développeur (avant que tout code ne soit engagé). Au cours de cette phase, le critique peut faire des suggestions pour améliorer le code ou la documentation. Il est également courant que le responsable de poser des commentaires sur des problèmes de mise en œuvre spécifiques (c'est-à-dire montrant deux implémentations de la même fonction et discutez de la "meilleure").
Idéalement, les responsables doivent montrer que certains tests sont effectués avec le nouveau code (et le critique peut également suggérer d'autres cas de test).
C'est un processus simple, mais il trouve souvent de petits problèmes.
Parfois, il existe deux demandes/critiques de révision (mais cela est dû à l'organisation de la société: le code est divisé par des équipes spécialisées et parfois, vous devez changer le code de quelqu'un d'autre).
Je suis d'accord avec à peu près tout @karl Bielefeldt, mais j'ajouterai un point que je pense est important:
L'examen du code est (ou devrait être) programmation des paires asynchrones.
La partie asynchrone n'est évidemment vraie que si le codeur et l'examinateur ne sont pas dans la même pièce en même temps. Pour moi, cela est mieux activé par un outil tel que la demande de traction de Github. Il existe certainement d'autres moyens d'automatiser le processus et j'ai vu une variété d'entre eux travaillant à travers les domaines des dispositifs médicaux à ouvrir la source; Cependant, ce qui les sépare, c'est la variance large d'efficacité. Je ne connais personne qui n'est pas préoccupé par l'engagement de temps impliqué ces jours-ci; Par conséquent, je pense qu'il est préférable d'automatiser le processus dès le départ.
La demande de traction de GitHub obtient mon vote car il est découvertable et facilement accessible par les débutants via l'interface Web, et pourtant gère également les utilisateurs plus avancés qui préfèrent la ligne de commande.
L'autre chose que j'aime à propos de ce système est que cela fait un bon travail de séparation des métadonnées de revue (commentaires sur le code) du code lui-même et concentre le relecteur sur la fourniture de correctifs qui augmentent le taux d'acceptation.
Si vous y réfléchissez, les aspects économiques de la vérification du code sont comme: la qualité dérivée de l'examen est une fonction d'itération: l'attitude du critique et l'aptitude et la réactivité du codeur plus. Tout ce que vous pouvez faire pour accroître la facilité et le tarif auquel ces itérations d'examen ont lieu produisent une meilleure qualité et une expérience plus cohérente pour l'équipe.
Je verrais aussi Comment devriez-je effectuer des évaluations?
Le processus de révision que je connais bien se passe comme suit:
- Le code source est géré à l'aide d'un système de contrôle de version (E.G. SVN).
- Toute modification du logiciel est suivie par un système de demande de changement (E.G. BugZilla).
- Lorsqu'un développeur vérifie certaines modifications, ceux-ci sont attachés à la demande de changement.
- Avant que la demande de changement puisse être fermée, le changement doit être examiné par un autre développeur. Cela peut arriver soit directement (un développeur explique les modifications apportées à l'examinateur), soit via un outil (par exemple http://www.revisward.org/ ) après que cela a déjà été vérifié Dans les deux cas, le critique peut approuver les modifications ou suggérer d'autres modifications.
Dans les deux cas (examen direct ou via un outil), si l'examinateur approuve les modifications, la demande de modification peut être définie sur "fixe". Si le relecteur nécessite d'autres changements, le développeur les implémente et une nouvelle revue est nécessaire. C'est le développeur original qui implémente ces modifications supplémentaires.
Pour les changements plus importants (par exemple, la mise en œuvre de nouvelles fonctionnalités), le développeur n'explique pas le changement au plus petit détail: les idées principales et les techniques de mise en œuvre sont illustrées sur le code. Pour des changements plus petits (par exemple, des corrections de bugs), il est temps d'avoir une discussion plus détaillée.
Le moyen le plus simple de faire une critique de code est d'obtenir un outil (j'ai utilisé CodeTriker ). Ensuite, le processus est:
- le programmateur choisit le code de l'examen et des examinateurs
- les critiques commencent le code
- le programmeur passe par les commentaires et accepte ce qui est approprié
De cette façon, les examinateurs peuvent le faire quand ils trouveront du temps pour cela. Et le programmeur n'a pas besoin de prendre des notes.
Une alternative à la révision du code est la programmation par paires. Certaines personnes l'appellent Revue de code sur les stéroïdes , mais c'est beaucoup plus que cela.
Vous posez essentiellement deux questions:
- L'auteur des travaux étant-elle inspectée doit-elle faire partie de l'examen?
- Devez-vous suivre les commentaires?
Dans mon expérience, y compris l'auteur du travail est essentiel.
- L'auteur aura l'occasion de participer à et apprendre de toute discussion qui se produit.
- L'auteur est probablement le mieux adapté pour répondre à tous les défauts trouvés dans le travail; S'ils ne reçoivent qu'une liste d'actions sans être présents pour l'examen, ils manquent le contexte de toute discussion.
- L'auteur peut être appelé à défendre la manière dont un artefact a été écrit.
En ce qui concerne le suivi des commentaires de la révision: oui, il devrait être suivi.
- Des articles trouvés, qui sont des problèmes de formation?
- Quelles sont les meilleures pratiques qui devraient être suivies pour tous les travaux futurs?
- Quels défauts étaient des défauts parce que le code est difficile à lire, mal documenté, etc.?
- Quels défauts parlent à des problèmes plus importants nécessitant plus de travail qu'une réponse à l'inspection - si elles devraient-elles être suivies comme des billets de bugs distincts à fonctionner car les ressources le permettent?
Avez-vous des projets pour atteindre la conformité du CMMI de toute sorte?
- Vous voudrez suivre tous les défauts trouvés et le fait que chacun ait été résolu.
Votre client ou votre contrat nécessite-t-il que tout code soit examiné?
- Vous voudrez suivre les problèmes et les matériaux d'inspection afin que vous puissiez répondre à "oui" et démontrer que si nécessaire.
Le processus de base devrait impliquer le développeur assis avec ses pairs et traverser son code de manière approfondie. Dans quelle mesure dépend de la taille du projet, de la manière dont il est important, etc. Les réviseurs devraient avoir accès au code avant la réunion afin de pouvoir se concentrer sur la discussion des défauts plutôt que de lire le code.
Chaque réunion ne devrait pas être trop longue - une heure environ, alors s'il y a beaucoup de code divisé dans des morceaux plus gérables. Il est également parfaitement acceptable de simplement examiner une proportion du code, cependant, cela dépendra de l'importance du code, etc.
Vous pouvez soit passer par le code en ligne ou hors ligne - mais aucun changement ne doit être effectué lors de la réunion. Notez simplement les défauts sous forme d'annotations sur l'impression ou dans un fichier séparé.
Le développeur remonte ensuite et corrige les défauts, réorganisant tous les tests, etc., selon les besoins. En fonction du nombre et de la gravité des défauts, il peut y avoir un autre examen - bien que cela ne soit qu'un échantillon du code.
Mon point de vue sur un processus d'examen du code.
Premièrement, il y a deux règles de base:
- personne ne peut commettre un code sans prévision
- personne ne peut revoir un changement qu'elle a contribué à
I. Quand un collègue est sur le point de commettre un changement que nous asseyons ensemble et
- vérifiez que chaque cas de test est vert sur son ordinateur
- vérifiez qu'elle a écrit/des cas de test modifiés
- vérifiez que son code correspond à la directive de codage existante
- vérifiez ses modifications et concentrez-vous sur la liste Top 25 de Jeff Atwood
- nous traversons ses changements et discutons
Ceci est un chèque rapide, peut être fait en 5 minutes. C'est un bon moyen d'obtenir un retour rapide, découvrez le nouveau changement et rien n'est cassé
II. Le développeur principal/chef de l'équipe devait chercher quotidiennement les engagements et les examiner de manière approfondie et partager ses pensées et ses conclusions avec l'équipe (celles-ci met en œuvre les conclusions qui ont écrit le mauvais code)
III. Pendant la rétrospective (si vous en avez), vérifiez le code de l'autre pour apprendre