Vérifiez avant ou après la validation du code, quel est le meilleur?
Traditionnellement, nous effectuions la révision du code avant la validation, j'ai eu un argument avec mon collègue aujourd'hui, qui préférait la révision du code après la validation.
Tout d'abord, voici quelques informations,
- Nous avons des développeurs expérimentés et nous avons également de nouvelles recrues avec une expérience de programmation presque nulle.
- Nous aimerions effectuer des itérations rapides et courtes pour lancer notre produit.
- Tous les membres de l'équipe sont situés sur le même site.
Les avantages de la révision du code avant la validation, j'ai appris:
- Mentor nouvelles embauches
- Essayez d'éviter les erreurs, les échecs et les mauvaises conceptions au début du cycle de développement
- Apprenez des autres
- Sauvegarde des connaissances si quelqu'un quitte
Mais j'ai aussi eu de mauvaises expériences:
- Faible efficacité, certains changements peuvent être revus au fil des jours
- Difficile d'équilibrer vitesse et qualité, en particulier pour les débutants
- Un membre de l'équipe ressentait de la méfiance
En ce qui concerne la révision post-validation, je ne sais pas grand-chose à ce sujet, mais ce qui m'inquiète le plus, c'est le risque de perdre le contrôle en raison du manque de révision. Des opinions?
MISE À JOUR:
- Nous utilisons Perforce pour VCS
- Nous codons et nous nous engageons dans les mêmes branches (branches de tronc ou de correction de bugs)
- Pour améliorer l'efficacité, nous avons essayé de diviser le code en petits changements. Nous avons également essayé une révision des dialogues en direct, mais tout le monde n'a pas suivi la règle. C'est un autre problème cependant.
Comme Simon Whitehead mentionne dans son commentaire , cela dépend de votre stratégie de branchement.
Si les développeurs ont leur propre branche privée pour le développement (ce que je recommanderais dans la plupart des situations de toute façon), je procéderais à la révision du code avant de fusionner avec le tronc ou le référentiel principal. Cela permettra aux développeurs d'avoir la liberté de s'enregistrer aussi souvent qu'ils le souhaitent pendant leur cycle de développement/test, mais à chaque fois que le code entre dans la branche qui contient le code livré, il est examiné.
Généralement, vos mauvaises expériences avec les révisions de code ressemblent plus à un problème avec le processus de révision qui a des solutions. En examinant le code en petits morceaux individuels, vous pouvez vous assurer qu'il ne prend pas trop de temps. Un bon nombre est que 150 lignes de code peuvent être examinées en une heure, mais le taux sera plus lent pour les personnes qui ne connaissent pas le langage de programmation, le système en cours de développement ou la criticité du système (une critique de sécurité nécessite plus de temps) - ces informations peuvent être utiles pour améliorer l'efficacité et décider qui participe aux revues de code.
Il y a un mantra que personne ne semble avoir encore cité: Arrivée tôt et souvent :
Les développeurs qui travaillent pendant de longues périodes - et j'entends par là plus d'une journée - sans rien vérifier dans le contrôle de code source se préparent à de sérieux maux de tête d'intégration sur toute la ligne. Damon Poole approuve :
Les développeurs retardent souvent l'enregistrement. Ils le retardent parce qu'ils ne veulent pas affecter les autres personnes trop tôt et ils ne veulent pas être blâmés pour avoir rompu la version. Mais cela entraîne d'autres problèmes tels que la perte de travail ou l'impossibilité de revenir aux versions précédentes.
Ma règle de base est "s'enregistrer tôt et souvent", mais avec la mise en garde que vous avez accès au versioning privé. Si un enregistrement est immédiatement visible pour les autres utilisateurs, vous courez le risque d'introduire des modifications immatures et/ou de casser la génération.
Je préfère de loin que de petits fragments soient vérifiés périodiquement plutôt que de passer de longues périodes sans aucune idée de ce que mes collègues écrivent. En ce qui me concerne, si le code n'est pas vérifié dans le contrôle de code source, il n'existe pas . Je suppose que c'est encore une autre forme de Don't Go Dark ; le code est invisible jusqu'à ce qu'il existe dans le référentiel sous une forme ou une autre.
... Si vous apprenez à vous enregistrer tôt et à vous enregistrer souvent, vous aurez amplement de temps pour les commentaires, l'intégration et l'examen en cours de route ...
J'ai travaillé pour quelques sociétés qui avaient des approches différentes à ce sujet. On l'a permis, tant qu'il n'empêchait pas la compilation. L'autre paniquerait si vous enregistriez des bogues. Le premier est de loin préféré. Vous devriez évoluer dans une sorte d'environnement qui vous permettrait de collaborer avec d'autres personnes sur des choses qui sont toujours en cours, étant entendu que tout cela sera testé plus tard.
Il y a aussi la déclaration de Jeff Atwood: N'ayez pas peur de casser des choses :
Le moyen le plus direct de s'améliorer en tant que développeur de logiciels est d'être absolument sans peur lorsqu'il s'agit de changer votre code. Les développeurs qui ont peur du code cassé sont des développeurs qui ne deviendront jamais des professionnels.
J'ajouterais également que pour les évaluations par les pairs, si quelqu'un veut que vous changiez quelque chose, avoir l'historique de votre version originale en source est un outil d'apprentissage très précieux.
J'ai récemment commencé à faire des revues de pré-validation dans un projet dans lequel je suis et je dois dire que je suis agréablement surpris de voir à quel point il est sans problème.
Le plus gros inconvénient des revues post-commit que je vois est qu'il s'agit souvent d'une affaire à une seule personne: Quelqu'un vérifie l'exactitude du code, mais auteur n'est généralement pas impliqué, sauf en cas d'erreur grave. Les petits problèmes, suggestions ou astuces n'atteignent généralement pas l'auteur du tout.
Cela change également le résultat perçu des révisions de code: il est considéré comme quelque chose qui ne produit qu'un travail supplémentaire, par opposition à quelque chose où tout le monde (le réviseur et l'auteur du code) peut apprendre de nouvelles choses à chaque fois.
Les revues de code pré-commit semblent si naturelles, il ne m'est jamais venu à l'esprit que les revues pouvaient délibérément être faites après la validation. Du point de vue de l'intégration continue, vous souhaitez valider votre code une fois qu'il est terminé, pas dans un état qui fonctionne mais peut-être mal écrit, non?
C'est peut-être parce que la façon dont nous l'avons toujours fait dans mes équipes est un dialogue en direct initié par le développeur d'origine, et non des révisions asynchrones, basées sur le contrôle et basées sur des documents.
Aujourd'hui, la plupart des référentiels prennent en charge une validation en deux phases ou un ensemble d'étagères (branche privée, demande d'extraction, soumission de correctif ou tout ce que vous voulez appeler), qui vous permettra d'inspecter/examiner le travail avant de le placer dans la ligne principale. Je dirais que tirer parti de ces outils vous permettrait de toujours effectuer des révisions avant validation.
En outre, vous pouvez considérer le codage par paires (paires senior avec junior) comme un autre moyen de fournir une revue de code intégrée. Considérez-le comme une inspection de la qualité sur la chaîne de montage plutôt qu'après la descente de la voiture.
Faire les deux :
- pré-engagement - faites ce genre de revues quand c'est quelque chose de très important, comme un morceau de code très réutilisable, ou une décision de conception majeure
- post commit - faites ce genre d'avis quand vous voulez avoir une opinion sur un morceau de code qui pourrait être amélioré
Toute révision formelle doit être effectuée sur les fichiers source qui sont sous contrôle de configuration, et les enregistrements de révision indiquant clairement la révision du fichier.
Cela évite tout argument de type "vous n'avez pas le dernier fichier" et garantit que tout le monde passe en revue la même copie du code source.
Cela signifie également que, si des corrections post-révision sont nécessaires, l'historique peut être annoté avec ce fait.
Pour l'examen du code lui-même, mon vote est pour "pendant" la validation.
Un système comme gerrit ou trèfle (je pense) peut mettre en place un changement, puis demander au réviseur de le valider dans le contrôle de source (Push in git) s'il est bon. C'est le meilleur des deux mondes.
Si ce n'est pas pratique, je pense qu'après commit est le meilleur compromis. Si la conception est bonne, seuls les développeurs les plus juniors devraient avoir des choses assez mauvaises, vous ne voulez pas qu'elles soient engagées. (Faites une revue de pré-validation pour eux).
Ce qui conduit à la révision de la conception - bien que vous puissiez le faire au moment de la révision du code (ou d'ailleurs au moment du déploiement du client), la recherche des problèmes de conception doit être effectuée plus tôt que cela - avant que le code ne soit réellement écrit.
Les avis bénéficient à la fois de pré et post-commits.
validation de la pré-revue
- Donne aux évaluateurs la confiance qu'ils examinent la dernière révision de l'auteur.
- Aide à s'assurer que tout le monde examine le même code.
- Fournit une référence pour la comparaison une fois que les révisions effectuées à partir des éléments de révision sont terminées.
Pas de validation en cours pendant l'examen
J'ai utilisé les outils Atlassian et j'ai vu des validations en cours d'exécution se produire lors de l'examen. C'est déroutant pour les critiques, donc je le déconseille.
Révisions après examen
Une fois que les examinateurs ont terminé leurs commentaires, verbalement ou par écrit, le modérateur doit s'assurer que l'auteur apporte les modifications demandées. Parfois, les examinateurs ou l'auteur peuvent être en désaccord sur la question de savoir si un élément de révision doit être considéré comme une faute, une suggestion ou une enquête. Pour résoudre les désaccords et s'assurer que les éléments d'enquête sont correctement éliminés, l'équipe d'examen dépend du jugement du modérateur.
D'après mon expérience avec environ 100 inspections de code, lorsque les réviseurs peuvent référencer une norme de codage sans ambiguïté, et pour la plupart des types de défauts de logique et de programmation, les résultats de la révision sont généralement clairs. Parfois, il y a un débat sur la piqûre de nit ou un point de style peut dégénérer en argument. Cependant, donner le pouvoir de décision au modérateur évite l'impasse.
Engagement post-examen
- Donne au modérateur et aux autres réviseurs un point de données à comparer avec le commit de pré-révision.
- Fournit des mesures pour juger à la fois de la valeur et du succès de l'examen lors de la suppression des défauts et de l'amélioration du code.
Avec l'examen par les pairs, le risque de perdre le contrôle est minime. Tout le temps, deux personnes connaissent le même code. Ils doivent changer de temps en temps, donc ils doivent être attentifs tout le temps pour garder une trace du code.
Il est logique d'avoir un développeur habile et un débutant travaillant ensemble. À première vue, cela semble inefficace, mais ce n'est pas le cas. En fait, il y a moins de bogues et il faut moins de temps pour les corriger. En outre, les débutants apprendront beaucoup plus rapidement.
Ce qui vient empêcher une mauvaise conception, cela doit être fait avant le codage. S'il y a un changement/amélioration/nouvelle pièce de conception considérable, il doit être examiné avant le début du codage. Lorsque le design est complètement développé, il ne reste plus grand-chose à faire. La révision du code sera plus facile et prendra moins de temps.
Je suis d'accord qu'il n'est pas essentiel de revoir le code avant de s'engager uniquement si le code est produit par un développeur expérimenté, qui a déjà prouvé ses compétences. Mais s'il y a un débutant, le code doit être examiné avant de s'engager: le réviseur doit s'asseoir à côté du développeur et expliquer chaque changement ou amélioration apporté par lui.
Mes collègues et moi-même avons effectué récemment des recherches scientifiques sur ce sujet.J'aimerais donc ajouter certaines de nos idées, bien qu'il s'agisse d'une question plutôt ancienne. Nous avons construit un modèle de simulation d'un processus/équipe de développement Kanban agile et comparé les revues pré-commit et post-commit pour un grand nombre de situations différentes (nombre différent de membres de l'équipe, niveaux de compétence différents, ...). Nous avons examiné les résultats après 3 ans de temps de développement (simulé) et recherché des différences en termes d'efficacité (points finis de l'histoire), de qualité (bogues trouvés par les clients) et de temps de cycle (temps du début à la livraison d'une histoire utilisateur) . Nos constatations sont les suivantes:
- Les différences en termes d'efficacité et de qualité sont négligeables dans de nombreux cas. Quand ils ne le sont pas, la revue post-commit présente certains avantages en termes de qualité (d'autres développeurs agissent en quelque sorte comme des "beta-testeurs"). Pour plus d'efficacité, la post-validation présente certains avantages dans les petites équipes et la pré-validation a certains avantages dans les grandes équipes ou non qualifiées.
- La révision avant validation peut entraîner des temps de cycle plus longs, lorsque vous avez une situation dans laquelle le début des tâches dépendantes est retardé par la révision.
De celles-ci, nous avons dérivé les règles heuristiques suivantes:
- Lorsque vous avez un processus d'examen de code établi, ne vous embêtez pas à changer, cela ne vaut probablement pas la peine
- sauf si vous avez des problèmes avec le temps de cycle => Passer à la publication
- Ou des problèmes glissés perturbent trop souvent vos développeurs => Passer à Pre
- Si vous ne faites pas encore d'avis
- Utilisez le pré-engagement si l'un de ces avantages vous est applicable
- L'examen préalable à la validation permet aux personnes extérieures sans droits de validation de contribuer à des projets open source
- S'ils sont basés sur des outils, la revue préalable à la validation impose une certaine discipline de la revue dans les équipes avec une adhésion au processus autrement laxiste
- L'examen préalable à la validation empêche la livraison des modifications non révisées, ce qui est pratique pour un déploiement continu/des cycles de publication très courts
- Utilisez le pré-engagement si votre équipe est grande et que vous pouvez vivre avec ou contourner les problèmes de temps de cycle
- Sinon (par exemple, petite équipe industrielle qualifiée), utilisez post commit
- Utilisez le pré-engagement si l'un de ces avantages vous est applicable
- Recherchez des combinaisons qui vous offrent les avantages des deux mondes (nous ne les avons pas étudiés formellement)
Le document de recherche complet est disponible ici: http://dx.doi.org/10.1145/2904354.2904362 ou sur mon site Web: http://tobias-baum.de
Cela dépend de la composition de votre équipe. Pour une équipe relativement expérimentée qui est bonne sur les petits commits fréquents, puis un examen post-commit juste pour avoir une deuxième paire d'yeux sur le code est bien. Pour les validations plus grandes et plus complexes et/ou pour les développeurs moins expérimentés, les révisions pré-validées pour résoudre les problèmes avant leur entrée semblent plus prudentes.
Dans ce sens, avoir un bon processus de CI et/ou des enregistrements bloqués réduit le besoin de révisions avant validation (et sans doute après validation pour beaucoup d'entre eux).
À mon avis, l'examen par les pairs du code fonctionne mieux s'il est effectué après la validation.
Je recommanderais d'ajuster votre stratégie de branchement. L'utilisation d'une branche développeur ou d'une branche fonctionnalité présente un certain nombre d'avantages ... dont le moindre n'est pas de faciliter les révisions de code post-commit.
Un outil comme Crucible facilitera et automatisera le processus de révision. Vous pouvez sélectionner un ou plusieurs ensembles de modifications validés à inclure dans la révision. Crucible, il montrera quels fichiers ont été touchés dans les ensembles de modifications sélectionnés, gardera une trace des fichiers que chaque réviseur a déjà lus (montrant un% complet) et permettra aux réviseurs de faire facilement des commentaires.
http://www.atlassian.com/software/crucible/overview
Quelques autres avantages des branches utilisateur/fonctionnalité:
- Les développeurs bénéficient des avantages du contrôle de version (sauvegardez les modifications, restaurez à partir de l'historique, modifiez les différences) sans vous soucier de casser le système pour tout le monde.
- Les modifications qui provoquent des défauts ou qui ne sont pas terminées à temps peuvent être annulées, reclassées en priorité ou mises en attente si nécessaire.
Pour les développeurs inexpérimentés, une consultation régulière avec un mentor et/ou une programmation en binôme est une bonne idée, mais je ne considérerais pas cela comme une "révision de code".
Tous les deux. (En quelque sorte.)
Vous devriez réviser votre propre code sommairement avant de le valider. À Git, je pense que la zone de rassemblement est super. Après avoir effectué mes modifications, j'exécute git diff --cached pour voir tout ce qui est mis en scène. J'utilise cela comme une opportunité pour m'assurer de ne pas archiver de fichiers qui n'appartiennent pas (créer des artefacts, des journaux, etc.) et m'assurer que je n'ai pas de code de débogage dedans ou aucun code important commenté en dehors. (Si je fais quelque chose que je sais que je ne veux pas enregistrer, je laisse généralement un commentaire en majuscules pour que je le reconnaisse pendant la mise en scène.)
Cela dit, votre examen du code par les pairs devrait généralement être effectué après votre validation, en supposant que vous travaillez sur une branche de sujet. C'est le moyen le plus simple de vous assurer que tout le monde examine la bonne chose, et s'il y a des problèmes majeurs, alors ce n'est pas grave de les corriger sur votre branche ou de les supprimer et de recommencer. Si vous effectuez des révisions de code de manière asynchrone (c'est-à-dire en utilisant Google Code ou Atlassian Crucible), vous pouvez facilement changer de branche et travailler sur autre chose sans avoir à suivre séparément tous vos différents correctifs/différences qui sont actuellement en cours de révision pendant quelques jours.
Si vous ne travaillez pas sur une branche de sujet, vous devriez. Cela réduit le stress et les tracas et rend la planification de la libération beaucoup moins stressante et compliquée.
Edit: je dois également ajouter que vous devriez faire la révision du code après le test, ce qui est un autre argument en faveur de la validation du code en premier. Vous ne voulez pas que votre groupe de test tripote des dizaines de correctifs/différences de tous les programmeurs, puis classe les bogues simplement parce qu'ils ont appliqué le mauvais correctif au mauvais endroit.
Programmation 100% jumelée (quelle que soit votre ancienneté) avec de nombreuses petites validations et un système CI qui s'appuie sur CHAQUE validation (avec des tests automatisés incluant les unités, l'intégration et les fonctionnalités dans la mesure du possible). Revues post-commit pour les changements importants ou risqués. Si vous devez avoir une sorte de révision fermée/pré-validation, Gerrit fonctionne.
L'avantage de la révision du code lors de l'enregistrement (vérification de contact) est une rétroaction immédiate, avant que de gros morceaux de code ne soient terminés.
L'inconvénient de la révision du code lors de l'enregistrement est qu'elle peut décourager les utilisateurs de s'enregistrer jusqu'à ce que de longues portions de code soient terminées. Si cela se produit, cela annule complètement l'avantage.
Ce qui rend cela plus difficile, c'est que tous les développeurs ne sont pas les mêmes. Les solutions simples ne fonctionnent pas pour tous les programmeurs. Les solutions simples sont:
Programmation par paire obligatoire, qui permet d'effectuer des enregistrements fréquents car le copain est juste à côté de vous Cela ignore que la programmation par paires ne fonctionne pas toujours pour tout le monde. Fait correctement, la programmation en binôme peut également être très fatigante, donc ce n'est pas nécessairement quelque chose à faire toute la journée.
Branches de développeur, le code est uniquement examiné et archivé dans la branche principale une fois terminé. Certains développeurs sont enclins à travailler en secret, et après une semaine, ils proposent un code qui peut ou non passer en revue en raison de problèmes fondamentaux qui auraient pu être repérés plus tôt.
Révision à chaque enregistrement, ce qui garantit des révisions fréquentes. Certains développeurs sont oublieux et comptent sur des enregistrements très fréquents, ce qui signifie que d'autres doivent faire des révisions de code toutes les 15 minutes.
Vérifiez à un moment non spécifié après l'enregistrement. Les avis seront poussés plus loin quand il y aura un resserrement des délais. Le code qui dépend du code déjà validé mais pas encore révisé sera validé. Les examens signaleront les problèmes et les problèmes seront mis en attente pour être corrigés "plus tard". Ok, j'ai menti: ce n'est pas une solution simple, ce n'est pas du tout une solution. Examiner à une heure spécifiée après les travaux d'enregistrement, mais c'est moins simple car vous devez décider quelle est l'heure spécifiée
En pratique, vous faites ce travail en le rendant encore plus simple et plus complexe à la fois. Vous définissez des directives simples et laissez chaque équipe de développement déterminer en équipe ce qu'elle doit faire pour suivre ces directives. Un exemple de telles directives est:
- Le travail est divisé en tâches qui devraient prendre moins d'une journée.
- Une tâche n'est pas terminée si le code (le cas échéant) n'a pas été archivé.
- Une tâche n'est pas terminée si le code (le cas échéant) n'a pas été révisé.
De nombreuses formes alternatives de telles directives sont possibles. Concentrez-vous sur ce que vous voulez réellement (code évalué par les pairs, progrès du travail observable, responsabilité) et laissez l'équipe trouver comment elle peut vous donner ce qu'elle veut.