Meilleure stratégie de twigment lors de l’continuous integration?

Quelle est la meilleure stratégie de twigment à utiliser lorsque vous souhaitez effectuer une continuous integration?

  1. Release Branching: développez sur le tronc, conservez une twig pour chaque version.
  2. Branchement des fonctionnalités: développez chaque entité dans une twig séparée, fusionnez une fois seulement de manière stable.

Est-il judicieux d’utiliser ces deux stratégies ensemble? Comme dans, vous twigz pour chaque version mais vous twigz également pour les grandes fonctionnalités? Est-ce que l’une de ces stratégies s’intègre mieux avec l’continuous integration? Est-ce que l’utilisation de l’continuous integration aurait même un sens lorsque vous utilisez un tronc instable?

La réponse dépend de la taille de votre équipe et de la qualité de votre contrôle de source et de la possibilité de fusionner correctement des ensembles de modifications complexes. Par exemple, le contrôle de source complet tel que CVS ou SVN peut s’avérer difficile et le premier modèle peut vous convenir, alors que si vous utilisez un système plus complexe comme IBM ClearCase et une plus grande taille d’équipe, vous pourriez être plus à l’aise avec le second. modèle ou une combinaison des deux.

Personnellement, je séparerais le modèle de twig, où chaque fonctionnalité majeure est développée sur une twig distincte, avec des sous-twigs de tâches pour chaque modification effectuée par un développeur individuel. Au fur et à mesure que les fonctionnalités se stabilisent, elles sont fusionnées dans le tronc, ce qui vous permet de restr raisonnablement stable et de passer tous les tests de régression à tout moment. À la fin de votre cycle de publication et lorsque toutes les twigs fonctionnelles fusionnent, vous stabilisez et twigz une twig du système de publication sur laquelle vous ne faites que des correctifs de bogues de stabilité et des backports nécessaires. twigz pour les nouvelles twigs de fonctionnalités. Etc.

De cette façon, le tronc contient toujours le code le plus récent, mais vous restz relativement stable, en créant des étiquettes stables sur les modifications majeures et les fusions, les twigs sont un développement rapide avec une continuous integration et les sous-twigs Actualisé à partir de la twig des fonctionnalités pour que tout le monde travaille sur la même fonctionnalité en synchronisation, sans affecter les autres équipes travaillant sur des fonctionnalités différentes.

Dans le même temps, vous avez à travers l’historique un ensemble de twigs de publication, où vous pouvez fournir des backports, un support et des corrections de bogues pour vos clients qui, quelle que soit la raison, restnt sur les versions précédentes de votre produit. Comme avec la ligne réseau, vous ne configurez pas une continuous integration sur les twigs de la version, elles sont soigneusement intégrées lors de la réussite de tous les tests de régression et de tout autre contrôle de qualité des versions.

Si pour une raison quelconque deux fonctionnalités sont co-dépendantes et nécessitent des modifications mutuelles, vous pouvez envisager de développer les deux sur la même twig ou d’exiger que les fonctionnalités fusionnent régulièrement des parties stables du code pour ensuite actualiser les modifications. tronc pour échanger du code entre les twigs du tronc. Ou, si vous devez isoler ces deux fonctionnalités des autres, vous pouvez créer une twig commune à partir de laquelle vous twigz ces twigs et que vous pouvez utiliser pour échanger du code entre les fonctionnalités.

Le modèle ci-dessus n’a pas beaucoup de sens avec des équipes de moins de 50 développeurs et système de contrôle de source sans twigs clairsemées et capacité de fusion comme CVS ou SVN, ce qui ferait de ce modèle un cauchemar à configurer, gérer et intégrer.

Je trouve le sujet vraiment intéressant car je compte beaucoup sur les twigs dans mon travail quotidien.

  • Je me souviens de Mark Shuttleworth proposant un modèle pour garder la twig principale vierge tout en allant au-delà de l’IC conventionnel. J’ai posté à ce sujet ici .
  • Comme je suis familier avec Cruise Control, j’ai également blogué sur les twigs de tâches et les CI ici . C’est un tutoriel étape par étape expliquant comment le faire avec Plastic SCM .
  • Enfin, j’ai trouvé certains des sujets sur le CI (et potentiellement sur le twigment) au livre de Duvall sur le CI très intéressant .

J’espère que vous trouvez les liens intéressants.

Personnellement, je trouve qu’il est beaucoup plus propre d’avoir un tronc stable et des fonctionnalités de twigment. De cette façon, les testeurs et autres utilisateurs restnt sur une seule “version” et effectuent des mises à jour à partir de la ligne de réseau pour tester toute fonctionnalité complète du code.

De même, si plusieurs développeurs travaillent sur des fonctionnalités différentes, ils peuvent tous avoir leurs propres twigs, puis les fusionner lorsqu’ils sont terminés et envoyer une fonctionnalité à tester sans que le testeur doive passer à plusieurs twigs pour tester différentes fonctionnalités.

Comme bonus supplémentaire, il existe un certain niveau de test d’intégration qui vient automatiquement.

Je pense que l’une ou l’autre de ces stratégies peut être utilisée avec un développement continu, à condition que vous vous souveniez de l’un des principes clés que chaque développeur s’engage chaque jour sur le tronc / la ligne principale.

http://martinfowler.com/articles/continuousIntegration.html#EveryoneCommitsToTheMainlineEveryDay

MODIFIER

J’ai fait quelques lectures de ce livre sur CI et les auteurs suggèrent que la ramification par libération est leur stratégie de twigment préférée. Je suis d’accord. Le twigment par fonctionnalité n’a aucun sens pour moi lorsque j’utilise CI.

Je vais essayer d’expliquer pourquoi je pense de cette façon. Supposons que trois développeurs prennent chacun une twig pour travailler sur une fonctionnalité. Chaque fonctionnalité prendra plusieurs jours ou semaines pour terminer. Pour s’assurer que l’équipe s’intègre en permanence, elle doit s’engager dans la twig principale au moins une fois par jour. Dès qu’ils commencent à le faire, ils perdent l’avantage de créer une twig de fonctionnalité. Leurs changements ne sont plus séparés de tous les changements des autres développeurs. Cela étant, pourquoi se donner la peine de créer des twigs de fonctionnalités en premier lieu?

Utiliser les twigments par version nécessite beaucoup moins de fusion entre les twigs (toujours une bonne chose), garantit que toutes les modifications sont intégrées au plus vite et (si cela est fait correctement) garantit que votre base de code est toujours prête à être publiée. L’inconvénient de la création de twigs est que vous devez être beaucoup plus prudent avec les modifications. Par exemple, le refactoring de grande taille doit être effectué de manière incrémentielle et si vous avez déjà intégré une nouvelle fonctionnalité dont vous ne voulez pas dans la prochaine version, il doit être masqué à l’aide d’ un mécanisme de basculement de fonctionnalités .

UN AUTRE EDIT

Il y a plus d’une opinion à ce sujet. Voici un article de blog qui est une twig professionnelle avec CI

http://jamesmckay.net/2011/07/why-does-martin-fowler-not-understand-feature-twigs/

Les twigs de publication sont très utiles, et même absolument nécessaires, si vous devez gérer plusieurs versions de votre application.

Les fonctions spéciales sont également très pratiques, notamment si un développeur doit travailler sur un énorme changement, tandis que d’autres publient encore de nouvelles versions.

Donc, pour moi, utiliser les deux mécanismes est une très bonne stratégie.

Lien intéressant du livre de SVN .

J’ai récemment aimé ce modèle en utilisant git. Bien que votre question soit étiquetée “svn”, vous pourrez toujours l’utiliser.

L’continuous integration peut se produire dans une certaine mesure dans la twig “développer” (ou ce que vous appelez) dans ce modèle, bien que le fait d’avoir de longues twigs fonctionnelles pour les versions futures ne le rende pas si rigide. La question demeure, si vous voulez vraiment cela. Martin Fowler le fait.

L’continuous integration ne devrait pas être un facteur quelconque dans la détermination de votre stratégie de twigment. Votre approche de twigment doit être sélectionnée en fonction de votre équipe, du système en développement et des outils à votre disposition.

Ayant dit cela …

  • il n’y a aucune raison pour laquelle CI ne pourrait pas être utilisé dans les deux approches que vous décrivez
  • ces approches fonctionnent assez bien en combinaison
  • aucun des deux ne fonctionne “mieux” que l’autre
  • CI a un sens total avec un tronc instable

Tout cela a été répondu à la quasortingème question sur la page à laquelle vous avez pris les diagrammes: http://blogs.collab.net/subversion/2007/11/branching-strat/

Tant que vous comprenez les principes, vous pouvez toujours réinventer les meilleures pratiques. Si vous ne comprenez pas les principes, les meilleures pratiques vous mèneront aussi loin avant de s’effondrer en raison de certaines exigences externes contradictoires.

Pour une meilleure introduction dans le modèle Mainline, lisez ceci: https://web.archive.org/web/20120304070315/http://oreilly.com/catalog/practicalperforce/chapter/ch07.pdf

Lisez le lien. Une fois que vous avez compris les bases, lisez l’article suivant du vénérable Henrik Kniberg. Cela vous aidera à établir une relation entre le modèle Mainline et l’continuous integration.

http://www.infoq.com/articles/agile-version-control

Lorsque nous avons démarré notre équipe, nous avons hérité d’une stratégie basée sur les versions du fournisseur qui avait initialement développé le système dont nous allions nous occuper. Cela a fonctionné jusqu’au moment où nos clients ont demandé que plusieurs fonctionnalités développées ne soient pas incluses dans une version (par exemple, environ 250 000 lignes de code, environ 2 500 fichiers, Scrum avec XP SDLC).

Ensuite, nous avons commencé à examiner les twigs basées sur les fonctionnalités. Cela a également fonctionné pendant un certain temps – comme 2 mois jusqu’à ce que nous ayons réalisé que notre processus de test de régression prendrait plus de 2 semaines, ce qui, combiné à l’incertitude de ce qui serait publié, a créé un inconvénient majeur.

Le dernier “clou dans le cercueil” des stratégies SC pures est venu quand nous avons décidé que nous devrions avoir 1. un tronc stable et 2. La production devrait contenir ST, UAT et les BINARIES testés par régression (pas seulement la source – pensez CC).

Cela nous a conduit à concevoir une stratégie qui est un hybride entre les stratégies SC basées sur les fonctionnalités et les versions.

Nous avons donc une malle. À chaque sprint, nous dérivons la twig sprint (pour les joueurs non agiles – un sprint est un effort de développement à durée variable avec une sortie variable basée sur la complexité). À partir de la twig sprint, nous créons les twigs fonctionnelles. Une fois que les fonctions sont terminées et que le système est testé, et que nous avons l’intention de les déployer, elles sont fusionnées dans la twig sprint – certaines peuvent flotter sur plusieurs sprints, généralement les plus complexes. Une fois que le sprint est proche de sa fin et que les fonctionnalités sont complètes … nous “renommons” la twig sprint en “régression” (cela permet à CruiseControl de le prendre sans reconfiguration) et le test de régression / intégration commence OREILLE. Quand tout cela sera fait, il sera mis en production.

En bref, les twigs basées sur les fonctionnalités sont utilisées pour développer, tester le système et les fonctionnalités UAT. La twig sprint (en fait la twig release) est utilisée pour fusionner de manière sélective les fonctionnalités à la demande et les tests d’intégration.

Maintenant, voici une question pour la communauté – nous avons évidemment du mal à réaliser une continuous integration car le développement se produit sur de nombreuses twigs et sur la reconfiguration de CruiseControl. Est-ce que quelqu’un peut suggérer et conseiller?

La façon dont je le vois, vous voulez avoir un ensemble limité de twigs où vous pouvez vous concentrer. Étant donné que vous voulez que les tests, les mesures de qualité du code et de nombreuses choses intéressantes à exécuter avec les builds, avoir trop de rapports vous fera probablement manquer des informations.

Quand et quoi twigr, dépend généralement de la taille de l’équipe et de la taille des fonctionnalités en cours de développement. Je ne pense pas qu’il y ait une règle d’or. Assurez-vous d’utiliser une stratégie où vous pouvez obtenir des commentaires tôt / souvent, et notamment impliquer la qualité dès le début des fonctionnalités. Le niveau de qualité signifie que lorsque vous automatisez au fur et à mesure que l’équipe se développe, si vous créez une twig pour une équipe importante, vous devez également impliquer la qualité dans l’équipe.

ps Où as-tu trouvé ces références d’approche? – ne pense pas que ces graphiques représentent toutes les options

Mise à jour 1: Expliquer pourquoi j’ai dit que ce n’est pas une règle d’or. Fondamentalement, pour des équipes relativement petites, je l’ai trouvé le mieux en utilisant une approche mixte. Les fonctions sont créées si elles sont longues et si une partie de l’équipe continue à append des fonctionnalités plus petites.

Je pense que les outils que vous utilisez sont un facteur important ici.

  • Si vous utilisez subversion, restz avec l’option 1 et libérez des twigs.
  • Si vous utilisez GIT, l’option 2 fonctionnera bien pour vous.