Les DVCS découragent-ils l'intégration continue?
Disons qu'il y a une équipe de dix développeurs agiles. Chaque jour, ils choisissent chacun une tâche du conseil d'administration, commet plusieurs changements contre celui-ci, jusqu'à (d'ici la fin de la journée), ils ont terminé la tâche. Tous les développeurs enregistrent directement contre le coffre (google-style, chaque commit est un candidat à la libération, à l'aide de la fonctionnalité bascule, etc.).
S'ils utilisaient un CV centralisé comme SVN, chaque fois que l'un d'entre eux s'engage, le serveur de construction intégrera et testera leurs modifications contre les neuf autres développeurs. Le serveur de construction sera à peu près fonctionner en continu toute la journée.
Mais s'ils utilisaient un DCVS comme Git, le développeur peut attendre jusqu'à ce qu'ils complètent la tâche avant de repousser tous leurs engagements locaux jusqu'au référentiel central. Leurs modifications ne seront pas intégrées avant la fin de la journée.
Dans ce scénario, l'équipe SVN s'intègre continuellement plus fréquemment et découvre beaucoup plus rapidement les problèmes d'intégration que l'équipe GIT.
Cela signifie-t-il que les DVCS sont moins adaptés aux équipes continues que les outils centralisés plus âgés? Comment les gars entrent-ils autour de ce problème de poussée différé?
Ma petite équipe est passée à un DVCS par an ou deux, et le reste de ma société a suivi il y a quelques mois. Dans mon expérience:
- Les personnes utilisant une VC centralisée ont toujours tendance à se débrouiller lorsqu'elles effectuent un grand projet. Ce n'est pas un problème unique à DVCSES. Ils auront des déplacements qui attendent plusieurs jours avant de faire un commit. La grande différence est que si elles font une erreur à un moment donné pendant cette période, ou si l'ordinateur se bloque, il nécessite beaucoup plus d'efforts pour le réparer.
- Nous utilisons un flux de travail commettre où chaque développeur travaille sur sa propre branche nommée, et seule la personne qui a examiné son code est autorisée à fusionner leurs changements dans la tête. Cela réduit la probabilité d'une commission qui cause des problèmes, afin que les gens prennent vraiment attention lorsque le serveur de construction produit un message d'erreur. Cela signifie également que d'autres développeurs peuvent continuer à travailler sur leurs propres branches jusqu'à ce que la tête soit fixée.
- Sur un DVCS, Les gens ont tendance à dépenser plus de temps de programmation avant de fusionner leur code dans la tête. Il a donc tendance à introduire un petit retard dans la continuité de la construction. Mais la différence n'est pas assez significative pour contrer les avantages des DVC.
J'ai récemment observé sur environ 19 projets qui utilisaient Mercurial sur Subversion (j'étais Subversion Geek ): Les développeurs ont commencé à devenir des plus individualistes en travaillant sur leur propre branche et en intégrant uniquement après des jours ou des semaines survenus. Cela a provoqué de graves problèmes d'intégration et des préoccupations.
Un autre problème rencontré est avec le serveur d'intégration continue. Nous avons été informés des problèmes (test d'échec par exemple), uniquement lorsque la synchronisation des commits a été apportée au serveur.
Il semble que Martin Fowler a écrit à ce sujet sur son site.
Cela dit, une partie du projet que je mentionne a fait une synchronisation au moins une fois par jour, réduisant les problèmes. Donc, pour répondre à votre question, je pense que les DVCS peuvent décourager l'intégration continue et augmenter l'individualisme. Cependant, DVCS n'est pas la cause directe.
Le développeur est toujours en charge, quels que soient les VCS qu'ils utilisent.
Idée que vous baseez votre raisonnement sur est très fragile, doucement. C'est la question de l'équipe/de la gestion/processus que développeur peut attendre jusqu'à ce qu'ils complètent la tâche.
Le faire d'une manière ou d'une autre, "Attendez" ou "Dépêche", une branche partagée ou une branche isolée, est connue comme Stratégie de ramification, et si vous - Informations sur l'étude disponibles en ligne, vous découvrirez que choisir une stratégie particulière n'a fondamentalement rien à voir avec VCS étant centralisée ou distribuée.
Dites, pour les VC distribués comme Mercurial, vous pouvez facilement trouver recommandation forte pour les fonts fréquents :
Tout d'abord, fusionnez souvent! Cela facilite la fusion de tout le monde et vous découvrez des conflits (qui sont souvent enracinés dans des décisions de conception incompatibles) plus tôt ...
Étudier les recommandations telles que ci-dessus, on peut facilement savoir que ces opposations à des considérations n'ayant rien à voir avec le miséricurbial étant distribuée.
Maintenant, regardons la situation à côté de VSC centralisée, Subversion. Étudiez des informations en ligne, on peut trouver parmi les principales stratégies populaires, appelées coffre stable et coffre instable - chacun ayant un impact opposé sur la fréquence des fonts. Vous voyez, les gens choisissent une ou une autre façon de faire des choses sans même prêter attention aux VCs centralisés.
- J'ai vu sévèrement des fonts retardés (même encouragés par la gestion boiteuse) avec des VC centralisés, ainsi que des fantasmes fréquents effectués avec DVCS lorsque l'équipe/la direction pensait simplement que c'est la bonne façon. J'ai vu que personne ne se soucie si VCS est distribué ou centralisé pour décider d'une manière ou d'une autre.
Compte tenu ci-dessus, il ressemble à la bonne réponse à DVCSES décourageez l'intégration continue ? serait M.
VCS étant distribuée ou non n'a pas d'impact substantiel sur cela.
Mon expérience est le contraire, les équipes utilisant svn n'Insister pour jour, parce que le code qu'ils travaillaient sur causerait le tronc à compile pas pour tout le monde sans perdre de temps sur une fusion manuelle. Puis à la fin du sprint, tout le monde s'engagerait, la folie la fusion aurait lieu, les choses iraient plus écrit et perdu et doivent être récupérés. Le système de CI allait RED et pointer du doigt en découlerait.
Jamais eu ce problème avec Git/Gitorious.
Git vous permet de tirer et de fusionner d'autres changements des peuples à votre convenance, non pas parce que quelqu'un d'autre chose vérifié et que vous voulez enregistrer, mais vous avez 20 minutes de fusion manuelle à faire.
Git vous permet également de tirer tout le monde d'autre les commits, fusionner votre code et puis appuyez sur une version de travail à tout le monde afin qu'ils ne doivent pas deviner ce qu'ils devraient avoir à fusionner en fonction de ce que vous avez changé.
Avoir quelque chose comme Gitorious comme médiateur pour les revues de code via demandes de fusion rend la gestion de nombreuses branches et beaucoup de contributeurs très indolore.
Mise en place Jenkins/Hudson pour suivre toutes les branches actives dans un dépôt Git est très facile aussi. Nous avons obtenu plus de traction avec CI et des commentaires plus fréquents sur l'état des dépôts lorsque nous avons déménagé à Git de SVN.
Cette ancienne question vient d'être marquée comme un duplicata d'un nouveau et, étant donné que beaucoup de réponses font référence à des idées obsolètes, je pensais que je posterais une mise à jour.
Une chose qui n'était apparemment pas très courante il y a cinq ans était exécutée des tests CI sur les succursales de la demande avant de les fusionner dans Maître. Je pense que cela reflète une attitude changeante qui, bien que la fusion soit souvent souhaitable, partageant chaque changer avec tout le monde, dès que vous le faites, ISN ' t optimal.
DVCS a engendré un mode plus hiérarchique d'intégration de vos commits. Par exemple, je travaille souvent sur des tâches de très près avec le développeur qui se trouve à côté de moi. Nous tirerons plusieurs fois des succursales de l'autre par jour. Aujourd'hui, nous avons collaboré avec un autre développeur via des modifications poussées toutes les quelques heures.
Nous faisions des modifications approfondies aux scripts de construction. Jenkins fusionne localement toutes les suites de relations publiques avec des tests de maître et de gestion, nous avons donc des commentaires automatisés de cette façon, sans déranger aucun autre développeur qui avait besoin d'une construction propre. Ce sera probablement un autre jour avant que la PR soit prête à fusionner à maîtriser et à partager en dehors de notre groupe de trois développeurs.
Cependant, si quelqu'un ne peut pas attendre que nos changements fusionnent à maîtriser, car leur changement dépend de la nôtre, ils peuvent fusionner notre branche de développement localement et continuer avec leur travail. C'est ce que beaucoup de gens qui sont habitués aux CVCs manquent. Avec CVCS, le seulement moyen de partager vos modifications consiste à les fusionner dans le représentant central, et c'est pourquoi la fusion est souvent plus critique. Avec DVCS, vous avez d'autres options.
Construire des serveurs sont bon marché. Demagez-vous que votre serveur CI récupère toutes les succursales que vous connaissez.
Jenkins a appuyé pour vérifier plusieurs référentiels Git et obtenir le "dernier" de l'un de ceux-ci dans un seul emploi. Je suis sûr qu'il y a des solutions similaires avec d'autres outils.
Je dirais que les DVC sont plus propices à l'intégration continue. Les fantasmes ne sont pas aussi irritants avec eux. Cela nécessite toutefois plus de discipline. Vous devriez suivre un commit local avec une tire de la base pour fusionner, puis pousser lorsque votre tâche est terminée (avant d'aller à la suivante).
Lorsque mon équipe est passée à Git, nous avons explicitement établi notre processus de manière à ce qu'une poussée devait être traitée exactement comme un commit dans les VC plus âgés, et les engagements locaux pourraient être effectués comme fréquemment/rarement que chaque individu a choisi. Avec cela, il n'y a pas de différence dans le système CI, que nous utilisions des DVC ou une VC centralisée.
Git n'empêche pas l'intégration continue. Votre flux de travail basé sur le tronc est.
Cela peut sembler contre-intuitif, mais: si les développeurs travaillent sur des branches de fonctionnalités, ils peuvent être encouragés à intégrer fréquemment sur leurs propres machines (et nécessaires pour le faire avant de soumettre leur fonctionnalité de fusion). En revanche, un flux de travail basé sur un coffre favorise des engagements importants et donc une intégration moins fréquente.
Je maintiens qu'un flux de travail sur le tronc de style Google est contre-productif avec un VCS tel que GIT où la fusion est facile. Voici ce que je conseillerais à la place:
- Casser les caractéristiques suffisamment petites qu'aucun ne prendra plus d'une journée ou de deux fois pour se développer.
- Chaque fonctionnalité est développée sur une succursale privée.
- Le développeur s'intègre fréquemment sur une branche privée (
git fetch Origin; git merge master). Je fais généralement cela plusieurs fois par jour lorsque vous travaillez de cette façon. - Lorsque le développeur soumet une succursale pour la fusion et l'examen, CI Server effectue une construction automatisée. La fusion ne se produit que lorsque cela passe.
Donc, là, vous l'avez: petit commettre, intégration fréquente et antécédents traçables de ce qui appartenait à la fonctionnalité. Les branches, utilisées correctement, sont la clé de tout ce qui vaut la peine d'être git, alors évitez-les, c'est une grosse erreur.