Quand effectuer des révisions de code lors d'une intégration continue?
Nous essayons de passer à un environnement d'intégration continue, mais nous ne savons pas quand effectuer des révisions de code. D'après ce que j'ai lu sur l'intégration continue, nous devrions essayer de vérifier le code aussi souvent que plusieurs fois par jour. Je suppose que cela signifie même pour des fonctionnalités qui ne sont pas encore terminées.
Donc la question est, quand faisons-nous les revues de code?
Nous ne pouvons pas le faire avant d'avoir archivé le code, car cela ralentirait le processus où nous ne serions pas en mesure d'effectuer des enregistrements quotidiens, sans parler de plusieurs enregistrements par jour.
De plus, si le code que nous archivons se compile simplement mais n'est pas complet, effectuer une révision de code est alors inutile, car la plupart des révisions de code sont mieux faites lorsque la fonctionnalité est finalisée. Cela signifie-t-il que nous devrions effectuer des révisions de code lorsqu'une fonctionnalité est terminée, mais que le code non révisé entrera dans le référentiel?
OMI, vous devriez revoir le code avant qu'il ne soit publié sur la ligne principale afin que la ligne principale ait toujours le code de la plus haute qualité.
OTOH, un bon point pourrait être soulevé: `` Pourquoi s'embêter à vérifier si l'automatisation des tests CI ne l'a pas exécuté? '', Alors le mieux serait peut-être de donner aux développeurs chacun une branche privée que le serveur CI va construire et tester pour eux. . De cette façon, ils se sont d'abord engagés et poussés là-bas, puis une fois qu'il est passé, vérifiez-le, puis fusionnez-vous avec la ligne principale (où il sera exécuté à nouveau via le serveur CI).
Vous devriez certainement revoir le code non complet pour vous assurer que l'échafaudage pour les fonctionnalités futures est en place, ou au moins qu'il n'y a rien qui puisse empêcher ces futures fonctionnalités d'être implémentées.
Notez également que les révisions de code ne doivent pas être lentes ou synchrones - un outil comme gerrit ou reviewboard ou similaire peut les rendre asynchrones et assez indolores.
(Divulgation complète: j'ai travaillé pour SmartBear, les créateurs de Code Collaborator, un outil de révision de code)
Configurer la programmation par paire?
Tout le code est examiné au fur et à mesure de sa saisie sans étendre le processus ni introduire une autre étape.
Voici l'extrait de l'auteur de la livraison continue:
Jez Humble écrit comme:
J'écris actuellement un article de blog sur ce sujet. La réponse courte est la suivante:
- La meilleure façon d'examiner le code est la programmation par paire
- C'est une mauvaise idée de transférer la fusion vers la ligne principale - en créant une branche distincte, par exemple - sur un processus de révision formel. Cela empêche l'intégration continue (le meilleur moyen de réduire le risque de mauvais changements, c'est ce que vous visez vraiment à réaliser).
- Je pense que Gerrit est un bel outil, mais il devrait être utilisé après l'enregistrement (c'est ainsi qu'il est conçu, en fait). Une partie du travail des développeurs principaux consiste à examiner tous les enregistrements. Ils pourraient, par exemple, s'abonner à un flux.
Pour résumer: la revue de code est bonne. Si bien, nous devrions le faire en continu, par le biais de la programmation par paires et de la révision des commits. Si un développeur senior trouve un mauvais commit, il doit s'apparier avec la personne qui l'a commis pour l'aider à résoudre le problème.
Gating merge to mainline on a formal review is bad, and create branches to do so is extra bad, for the same raison that feature branches are bad.
Merci,
Jez.
le lien d'origine est: https://groups.google.com/forum/#!msg/continuousdelivery/LIJ1nva9Oas/y3sAaMtibGAJ
Je ne sais pas si c'est la meilleure façon de le faire ... mais je vais vous expliquer comment nous le faisons. Un ou plusieurs développeurs travaillent sur une branche donnée et valident leur code aussi souvent qu'ils le peuvent afin d'éviter de perdre du temps sur la fusion qui ne serait pas arrivé autrement. Ce n'est que lorsque le code est prêt qu'il est engagé dans la tête. Maintenant, c'est pour les commits et la branche/tête.
En ce qui concerne la révision de code, nous utilisons Sonar comme outil d'intégration continue (et Maven/Jenkins pour interagir avec Sonar) pour nous fournir de nouveaux résultats de test, une couverture de code et une révision automatique de code chaque matin (builds sont effectués tous les soirs) afin que nous, développeurs, puissions passer un maximum d'une heure chaque matin pour résoudre leurs problèmes/odeurs de code. Chaque développeur prend la responsabilité (en étant fier lui aussi!) De la fonctionnalité qu'il écrit. Maintenant, c'est une révision automatique du code, ce qui est génial pour trouver des problèmes techniques/architecturaux potentiels, mais ce qui est plus important est de tester si ces nouvelles fonctionnalités implémentées font ce que l'entreprise veut qu'elles fassent correctement.
Et pour cela, il y a deux choses: les tests d'intégration et la révision du code par les pairs. Les tests d'intégration aident à être raisonnablement sûr que le nouveau code ne casse pas le code existant. En ce qui concerne la révision du code par les pairs, nous le faisons le vendredi après-midi, ce qui est un peu plus détendu pour le faire :-) Chaque développeur est affecté à une branche sur laquelle il ne travaille pas, prend un certain temps pour lire les exigences de la nouvelle fonctionnalité d'abord, puis vérifie ce qui a été fait. Son travail le plus important est de s'assurer que le nouveau code fonctionne comme prévu compte tenu des exigences, ne rompt pas nos propres "règles" (utilisez cet objet pour cela, et non celui-là), est facile à lire et permet une extension facile.
Nous avons donc deux révisions de code, une automatique et une "humaine" et nous essayons d'éviter de commettre du code non révisé dans la branche HEAD. Maintenant ... Cela arrive parfois pour diverses raisons, nous ' re loin d'être parfait, mais nous essayons de maintenir un juste équilibre entre qualité et coût (temps!)
@pjz fournit également une bonne réponse, et il mentionne des outils de révision de code. Je n'en ai jamais utilisé, donc je ne peux rien dire à ce sujet ... même si j'ai été tenté par le passé de travailler avec Crucible puisque nous utilisons déjà JIRA .
Je pense que le concept principal qui va aider est celui d'une zone de "mise en scène".
Oui, vous ne voulez pas archiver le code cassé. Mais vous devez également vérifier fréquemment le code. Est-ce que cela implique la perfection? ;) Non. Utilisez simplement plusieurs zones et un DVCS comme git.
De cette façon, vous apportez des modifications (localement) et les validez fréquemment pendant que vous testez et développez jusqu'à ce que les tests réussissent. Ensuite, vous poussez vers une zone de transit pour la révision du code.
Vous devriez ensuite passer de Staging à d'autres efforts d'assurance qualité tels que les tests de navigateur et les tests utilisateur. Enfin, vous pouvez aller dans une zone de test de volume, puis enfin en production.
Il existe également des flux de travail dans ce domaine, tels que tous ceux qui travaillent sur la branche principale ou utilisent des branches individuelles pour tous les efforts.
L'intégration continue elle-même peut également se produire à plusieurs niveaux. Il peut être local sur une machine de développeur "jusqu'à ce que les tests réussissent" et il peut également se trouver dans les zones de transfert et de qa lorsque le code leur parvient.
Découpez la révision du code et l'intégration continue!
Pourquoi les avez-vous combinés?
Nous utilisons git flow pour nos référentiels, et nous faisons nos révisions de code quand il s'agit de fusionner dans la branche develop.
Tout ce qui est en développement est complet, déployable et révisé en code.
Nous avons également mis en place CI pour nos branches développement et master.
Je pense vraiment-vraiment-vraiment que vous auriez besoin d'un DVCS (par exemple Mercurial, git) pour le faire naturellement. Avec un CVCS, vous auriez besoin d'une branche et espérez que quel que soit le dieu que vous avez, il n'y a pas d'enfer fusionnant.
Si vous utilisez un DVCS, vous pouvez hiérarchiser le processus d'intégration afin que le code le fasse déjà passer en revue avant qu'il n'arrive sur le serveur CI. Si vous n'avez pas de DVCS, eh bien, le code arrivera sur votre serveur CI avant d'être examiné, sauf si les réviseurs de code examinent le code sur la machine de chaque développeur avant de soumettre leurs modifications.
Une première façon de le faire, surtout si vous n'avez pas de logiciel de gestion de référentiel qui peut aider à publier des référentiels personnels (par exemple bitbucket, github, rhodecode), est d'avoir des rôles d'intégration hiérarchique. Dans les diagrammes suivants, vous pouvez demander aux lieutenants d'examiner le travail des développeurs et au dictateur, en tant qu'intégrateur principal, d'examiner comment les lieutenants ont fusionné le travail.
Si vous disposez d'un logiciel de gestion de référentiel, vous pouvez également utiliser un workflow comme celui-ci:
Le logiciel de gestion de référentiel permet généralement d'émettre des notifications en cas d'activité dans les référentiels (par exemple, e-mail, rss) ainsi que d'autoriser les pull-requests . La révision du code peut se produire de manière organique pendant les demandes de tirage, car les demandes de tirage amènent généralement les gens à engager des conversations pour intégrer le code. Prenez cette pull-request publique comme exemple. Le gestionnaire d'intégration ne peut en réalité pas permettre au code d'arriver dans le référentiel béni (aka "référentiel central") si le code doit être corrigé.
Plus important encore, avec un DVCS, vous pouvez toujours prendre en charge un flux de travail centralisé, vous n'avez pas besoin d'avoir un autre flux de travail génial si vous ne le souhaitez pas ... mais avec un DVCS, vous pouvez séparer un référentiel de développement central du CI serveur et donnez à quelqu'un le pouvoir de pousser les modifications du repo dev vers le repo CI une fois la session de révision de code terminée .
P.S .: Crédit pour les images aller à git-scm.com
Cela signifie-t-il que nous devrions effectuer des révisions de code lorsqu'une fonctionnalité est terminée, mais que le code non révisé entrera dans le référentiel?
Bien au-dessus se trouve la façon dont je l'ai vu faire dans au moins trois projets qui utilisaient intensivement l'intégration continue et, si je me souviens bien, cela a fonctionné comme un charme. Cette pratique est connue sous le nom de revues de code post-commit - recherchez ce terme sur le Web si vous êtes intéressé par les détails.
- D'un autre côté, le seul cas où j'ai été dans un projet essayant de "marier" des revues de code pré-commit avec CI s'est avéré plutôt douloureux. Eh bien, lorsque les choses se sont bien déroulées à 100%, c'était OK - mais même des interruptions peu fréquentes (comme lorsque les examinateurs principaux et de secours n'étaient pas disponibles pendant quelques heures, par exemple) ont créé un stress notable. J'ai également remarqué que le moral de l'équipe avait quelque peu souffert - il y avait un peu trop de conflits.
Pourquoi ne pas avoir plus d'un référentiel? Un pour le travail "quotidien", la conduite d'un serveur d'intégration continue, l'exécution de tous les tests unitaires et tests d'intégration pour obtenir la boucle de rétroaction serrée de Nice, et un autre pour le travail "stable", où les commits sont moins fréquents, mais doivent passer par un examen.
Selon le chemin que prennent les changements au fur et à mesure qu'ils se déplacent dans le système, cela peut finir par être une solution complexe, et pourrait fonctionner mieux lorsque vous utilisez des outils comme Git ou Mercurial Queues, (mise en garde: je n'ai utilisé ni l'un ni l'autre dans la colère) mais beaucoup d'organisations font quelque chose de similaire.