Comment les DVC sont-ils utilisés dans les grandes équipes?
J'ai récemment commencé à entrer dans Git sur un projet personnel, et je peux voir comment un DVCS pourrait nous bénéficier au travail (qui est une grande entreprise de logiciels d'entreprise, actuellement en cours D'exécution Perforce). Le travail de fonctionnalité dans mon équipe, par exemple, consiste principalement à créer leurs propres branches; parfois, celles-ci sont partagées entre de petites équipes de développeurs. Je pense qu'il serait plus efficace dans ce cas d'utiliser un DVCS.
Dans le cas plus général, cependant, je serais intéressé d'entendre des personnes qui utilisent un DVCS au travail, dans les moyennes et grandes équipes.
- Comment gérez-vous les fusions n-way? Est-ce même un scénario commun? Mercurial ne supporte que les fusions n-way en faisant (N-1) des fusions 2-way (et Lire que c'est la solution préférée dans d'autres DVC), ce qui semble être un processus très laborieux pour même relativement petit N.
- utilisez-vous un seul référentiel central faisant autorité, ou est-ce vraiment P2P?
- Est-ce que les développeurs poussent et tirent souvent du code et de l'autre, ou fait tout passer par le référentiel central?
6 réponses
Mon équipe de mon ancien employeur utilisait Git, et cela a bien fonctionné pour nous. Nous n'étions pas si grands (peut-être 16 ou plus, avec peut-être 8 committers vraiment actifs?), mais j'ai des réponses à vos questions:
- les fusions n-Way NE sont pas très courantes. Nous avons trouvé quelques conventions sur la dénomination des branches qui nous ont permis d'écrire des scripts qui ont facilité le processus" release engineering " (j'utilise des citations effrayantes parce que nous n'avions pas d'ingénieur de publication), et les gens créaient des branches de fonctionnalités privées, mais nous avons rarement eu un problème avec la fusion de plus de deux branches (voir le prochain).
- (et #3). Nous avions un référentiel central sur un serveur de développement pour trois raisons: (a) la machine de développement avait un RAID5 (plus tolérant aux pannes) et des sauvegardes nocturnes (les postes de travail de développement n'étaient pas nocturnes), (B) les versions de production étaient construites sur le serveur de développement et (c) un référentiel central simplifiait les scripts. En conséquence, les fusions n-way ne se sont tout simplement jamais produites. La chose la plus proche que nous avions À N-way a quand quelqu'un a fusionné latéralement, puis fusionnées verticalement.
Git était vraiment une bonne chose pour nous en raison de son haut degré de flexibilité; cependant, nous avons dû établir des conventions (noms de branches et de balises, emplacements de repo, scripts, etc., processus) ou cela aurait pu être un peu chaotique. Une fois que nous avons mis en place les conventions, La flexibilité que nous avions était tout simplement fantastique.
Update: nos conventions étaient donc essentiellement:
- un répertoire sur notre serveur NFS qui logé tous les dépôts centraux
- nous avions plusieurs projets qui partageaient des composants, donc nous les avons divisés en bibliothèques, essentiellement, avec leurs propres dépôts, et les projets livrables les ont simplement inclus en tant que sous-modules git.
- Il y avait des chaînes de version et des noms de version qui nous étaient imposés d'en haut, Donc nous avons juste utilisé des variantes de celles-ci comme noms de branche
- de même, pour les tags, ils ont suivi les noms de version dictés par le processus
- les projets livrables contenaient un fichier de propriétés que j'ai lu dans les scripts shell, et qui m'a permis d'écrire un seul script pour gérer le processus de publication pour tous les projets, même si chacun avait de légères variations sur le processus-les variations ont été prises en compte dans ces fichiers de propriétés
- j'ai écrit des scripts qui reconstruiraient un paquet livrable à partir de n'importe quelle balise
- l'utilisation de git nous a permis de contrôler L'accès en utilisant PAM et / ou les autorisations utilisateur normales (ssh, etc)
- Il y avait d'autres conventions qui sont plus difficile à mettre dans une liste à puces, comme quand les fusions devraient se produire. Vraiment, moi et un autre gars étions en quelque sorte les "gourous git" internes, et nous avons aidé tout le monde à comprendre comment utiliser les branches et quand fusionner.
- amener les gens à s'engager en petits morceaux et à ne pas laisser tomber des bombes diff dans la branche master était un défi. Un gars a laissé tomber environ deux semaines solides de travail en un seul engagement, et nous avons finalement dû démêler tout. Unénorme perte de temps, et frustrant de tout.
- commentaires informatifs et détaillés pour aller avec commits
Il y a d'autres choses que vous apprenez à mesure que votre équipe est expérimentée et apprend à travailler les uns avec les autres, mais cela a suffi pour nous aider à démarrer.
Update : tous ceux qui suivent de telles choses le savent déjà, mais Vincent Dreissen a écrit une version solide et assez complète (mais pas exaustive) sur l'ingénierie de branchement et de publication en utilisant Git . J'aimerai fortement encourager en utilisant son processus comme point de départ parce que pour deux raisons:
- beaucoup d'équipes le font de cette façon ou utilisent une variante proche (y compris Linux, Git et de nombreuses autres équipes de projet OSS), ce qui signifie que cette méthode a été testée et modifiée pour réussir dans la plupart des circonstances. Il est très peu probable que vous fassiez face à un problème qui n'a pas été rencontré et résolu dans les contraintes de ce modèle.
- en raison de ce qui précède, presque tout ingénieur ayant une expérience Git comprendra ce qui se passe. Vous n'aurez pas à écrire de documentation détaillée sur la nature fondamentale de votre processus de publication; vous n'aurez qu'à documenter des éléments spécifiques à votre projet ou à votre équipe.
Schéma de flux de travail de whygitisbetterthanx :
Pour étendre cela à encore plus de développeurs, vous ajoutez simplement une autre couche de" lieutenants de confiance " entre le gestionnaire d'intégration et les développeurs.
Je travaille depuis plusieurs années avec l'équipe Glasgow Haskell Compiler en utilisant Darcs. J'ai récemment (plusieurs mois) commencé à utiliser git pour ma propre copie du repo, à la fois pour la performance et pour améliorer mon éducation.
-
Comment gérez-vous les fusions n-way?
Il n'y a pas de fusion N-way. Chaque développeur génère un flux de correctifs, et les flux sont fusionnés un à la fois à chaque repo. Donc, si n développeurs font des changements simultanément, ils sont fusionnés par paires.
-
utilisez-vous un seul référentiel central faisant autorité?
Absolument. C'est la seule façon de dire ce qui est GHC et ce qui ne l'est pas.
-
les développeurs poussent-ils et tirent-ils souvent du code les uns vers les autres, ou tout passe-t-il par le référentiel central?
Je pense que cela dépend des développeurs et des VCS que vous utilisez. Sur le projet GHC presque tous les TIRE et pousse je vois aller à travers le référentiel central. Mais il y a un gatekeeper lourd (auto-administré) sur les poussées vers le repo central, et si un collègue a un correctif de bug dont j'ai besoin maintenant, je vais le tirer directement de son repo. Avec darcs il est très facile de tirer un seul patch (plutôt que l'ensemble de l'état comme dans git), et je sais que mes collègues deveopers, qui ont plus d'expérience avec darcs, l'utilisation de cette fonctionnalité beaucoup plus que je n'---et ils aiment beaucoup.
Avec
git
, quand je travaille étroitement avec un autre développeur, je vais fréquemment créer une nouvelle branche juste dans le but de le partager avec une autre personne. Cette branche ne touchera jamais le repo central.
Le assez célèbre "Tech Talk: Linus Torvalds on git" explique comment il est utilisé pour Linux (à peu près aussi grand que l'équipe que je peux penser)
Si je me souviens bien, son utilisation a été comparée à une chaîne de commandement militaire-chaque module a un mainteneur, qui gère les demandes de pull des développeurs, alors il y a quelques personnes "les plus fiables" qui s'occupent de tirer des données des mainteneurs de module dans l'officiel kernel.org dépôt git.
"Linux: gérer la source du noyau avec 'git' " l'explique aussi, bien que ce ne soit pas une explication concise..
Voici un exemple (en aucun cas un exemple "universel")
Nous avons des VCS centraux (ClearCase ou SubVersion, selon les différents projets), et nous les utilisons pour des efforts de développement "officiels" (dev, patches, correctifs), où le nombre de branches est limité et bien identifié.
Cependant, pour les développements de refactoring impliquant beaucoup d'état intermédiaire, où rien ne fonctionne, et où de nombreux développeurs doivent avoir leur propre branche basée sur l'activité ou branches , certains dépôts Git sont mis en place entre ces développeurs, de manière P2P.
Une fois que le travail atteint une sorte de stabilité de 0,1 et que les fusions sont réduites, il est réimporté dans le VCS, où le travail peut se poursuivre de manière centrale "ordonnée".
Puisque Git sur Windows fonctionne bien (MSysGit), nous parvenons à faire rapidement de petits développements initiaux de cette façon.
Nous évaluons toujours Git pour un développement de projet à grande échelle.
Il est probablement préférable de regarder comment fonctionnent les développeurs du noyau linux. Ils ont un flux de travail assez complexe où les changements sont soumis à partir de nombreuses sources, puis les développeurs de confiance pour chaque sous-système (appelés lieutenants) tirent les changements, et quand ils sont heureux de les soumettre à Linus, qui finit par les tirer dans son arbre ou les rejette. Bien sûr, il est plus complexe que cela, mais c'est un aperçu général.