Quelle stratégie de branchement dois-je utiliser pendant le développement / maintenance d'une application web?

Question

Je suis en train de décider de la meilleure stratégie de branchement pour un projet d'application Web. Voici ce que je suis venu avec jusqu'à présent et je serais très heureux des commentaires et des expériences.

La façon dont je le vois, il y a deux principales stratégies de branchement: « branche par la libération » et « branche en fonction »

.

"Direction de la libération" : Le développement se fait sur le tronc. Lorsque le temps pour une sortie est proche, une branche est fait pour que la libération. Cette branche est ensuite stabilisée / testée et enfin une version est faite. Après la sortie, la branche est de retour fusionné dans le coffre, tout en gardant la branche de sortie en vie pour la correction de bogues. Est-ce un bug-correctif appliqué, il est fusionné dans le tronc (si le développement sur le tronc n'a pas éclipsé le bogue dans d'autres moyens). De nouvelles fonctionnalités sont ajoutées au tronc et ne touchent pas la branche de sortie. Quand une nouvelle touche à sa libération de temps, une nouvelle branche de sortie est créé a.s.o.

"Branch par fonction" : Le tronc est toujours le tronc "de production" (le code qui est en direct). Bugfixes directement commited sont le tronc. Caractéristiques pour la prochaine version sont développés dans les longs branches.Bugfixes sont fusionnés de temps en temps dans les branches de fonction. Lorsque le temps de libération vient, les caractéristiques branches sont fusionnées dans le tronc et le cycle de la vie continue.

Maintenant, la façon dont je vois la grande différence pratique entre ces deux stratégies est que « par la libération » vous permet de maintane différentes versions de production de votre logiciel (lorsque le client A a la version 1 et client version B 1.5, le client est le paiement client dans ce cas). En revanche en utilisant la « fonction par » stratégie que vous ne pouvez soutenir la version de production actuelle (tous les clients utilisent la dernière version).

Comme dans un typique application web tous les clients utilisent la même version « dernière » (car ils ont tous accès au même serveur), je suppose que l'approche « par fonction » est le plus souvent utilisé. Il supprime la nécessité de fusionner « dans la hiérarchie », par exemple quand un bugfix doit être appliquée à toutes les 3 versions de mise à jour.

Donc, mon état actuel est que je devrais aller avec « branche par fonction ». Si cela importe, mon équipe n'est pas très habile.

Answer 1

Si vous avez seulement une version en direct à tout moment, et vous faites tout le développement dans une seule branche de fonctionnalité, ces approches sont effectivement les mêmes.

Si la branche par fonction signifie pour vous avoir un plusieurs branches sur la route à la fois, il faut éviter comme la peste. Plus branches des moyens plus fusionnement, ce qui est une douleur en elle-même, et plus l'enfer d'intégration. Il est de loin préférable de faire une intégration continue avec une seule ligne de code.

Si votre processus de déploiement est plus impliqué que la branche, test, aller vivre, alors un avantage de la branche par la libération est que vous pouvez avoir des branches de libération multiples va à la fois, dans les différentes phases: l'un en direct et étant sans bogues, comme nécessaire, et un autre étant stabilisé, testé, en passant par l'acceptation, etc., tandis que le développement se poursuit sur le tronc. Si vous avez un coffre en direct, d'autre part, une fois que vous fusionnez une branche de fonctionnalité avec vue de prendre en direct, vous avez perdu votre capacité à faire des corrections de bugs au système en direct actuel. La fusion de la branche de fonction devient un point de non-retour.

Answer 2

Quel type de logiciel développez-vous? Film rétractable? Projet Open Source? Si oui, passez à l'approche « branche par la libération » ou « instable tronc ». Surtout si vos cycles de libération sont tous les six mois à un an d'intervalle.

Mais si votre maintien d'un projet basé sur le Web qui a des changements allant sur des fréquences plus courtes, comme une fois toutes les quelques semaines ou moins, puis aller avec l'approche « branche par fonction » ou « tronc stable ». Le problème avec cette approche consiste à intégrer les multiples changements de caractéristiques qui ont des changements radicaux rendent le processus de fusion moins amusant. Il devient vraiment difficile.

Mais ces deux questions bien, mais si vous avez besoin à la fois? C'est, vous avez un projet qui se déploie dit une fois toutes les deux semaines avec de grands changements de fonctionnalités, mais vous trouvez que vous avez un certain nombre de corrections de bugs que vous ne pouvez pas attendre les changements fonctionnalité pour être prêt. Tronc est votre branche de sortie avec l'approche « branche en fonction ». Que faire si vous pouvez obtenir les deux versions et les caractéristiques de leur propre branche?

Consultez cette entrée de blog par Bob de CollabNet Archer. Sa stratégie Agile vous donne le meilleur de presse des deux. Je l'ai utilisé cela. Il est extrêmement flexible. Même si Bob ne montre pas dans son schéma, vous pouvez avoir des branches de libération multiples vont en même temps. Cela signifie que vous pourrait avoir une branche de sortie qui est prêt pour le déploiement à la production, et une autre qui est en cours de préparation pour le contrôle final d'assurance qualité. Mais deux choses à considérer:

Tout d'abord, à quel point sont vos développeurs à la fusion? Vous ne pouvez pas faire la l'approche de la stratégie de libération agile par vous-même, même si elle est une petite équipe. Tout le monde doit faire sa part et ils ont vraiment comprendre la fusion et les outils qu'ils utilisent pour faire la fusion.

En second lieu, vous allez avoir besoin d'une bonne connaissance sur les changements prêts et ceux qui sont sur le point d'être. La gestion des versions est la clé pour faire ce travail comme une horloge. Chaque fonction quand le besoin prêt volonté de s'attribuer à une branche de libération et ont fusionné pour elle.

Quelle que soit l'approche que vous choisissez, il se résume à ce que vous développez et la fréquence des changements que vous libérons pour que le développement.

Answer 3

Au risque de vous confondre plus: vous pouvez avoir des branches de libération et faire toutes les modifications sur les branches de fonction. Ces choses ne sont pas mutuellement exclusifs.

Cela étant dit, il semble que vous n'avez pas besoin des familles de libération parallèles et que vous souhaitez déployer souvent, peut-être même en continu. Donc, vous voulez avoir un « tronc stable » que vous pouvez libérer à tout moment. les branches fonctionnelles aident à garder la stabilité du tronc, parce que vous ne fusionnez dans le tronc lorsque les changements sont effectués et ont fait leurs preuves.

Je dirais donc que votre choix est un bon ajustement.

Answer 4

.

Ces choix ne sont pas mutuellement exclusifs - utiliser à la fois Ils résolvent des problèmes différents:

« Direction de la libération » - branche de sortie est utilisé pour vous assurer que vous pouvez revenir à la source utilisée pour produire la version live actuelle (ou les versions précédentes publiées) alors que la prochaine version est en développement. Par exemple. Ceci afin d'apporter des modifications à la version pour des corrections de bugs ou de caractéristiques backpatch du tronc de développement actuel.

« Branch par fonction » -. Utilisée pour le tronc de développement stable en tout temps, ce qui est particulièrement utile pour plusieurs développeurs et à des fins expérimentales « peut-être » caractéristiques

J'utiliser les deux, mais vous pouvez renoncer à l'une des approches si le problème qu'il résout ne vous concerne pas ou si vous avez une autre solution à ce problème.

Je recommande fortement d'utiliser un DVCS moderne comme git ou Mercurial. Ils sont axés sur le développement parallèle, de sorte qu'ils stockent différemment que les changements des systèmes plus anciens, ce qui rend la fusion beaucoup plus sain.

Answer 5

Je tends à utiliser Git pour mes projets, mais le processus que je tendance à suivre va comme ceci (et devrait fonctionner pour Subversion ainsi):

• pour chaque nouvelle fonctionnalité, créez une branche pour cette fonction.
• Lorsque tout fonctionne, fusionner dans la branche staging, et le déployer sur le serveur de mise en scène (vous en avez un de ceux-ci, non?)
• Une fois que nous sommes sûrs que le client est satisfait de ce qui est sur scène, on fusionne la branche de mise en scène dans la branche de production, étiquette comme quelque chose comme production_release_22 ou production_release_new_feature_x, puis déployer cette étiquette sur le serveur de production.

sont jamais , jamais mise à jour - une fois quelque chose est déployé, il reste ainsi jusqu'à ce que d'autres changements sont construits, testés et étiquetés - et la nouvelle balise est déployé. En faisant en sorte que c'est balises se déployer et non branches , je me tiens (ou autres) de faire des choses comme « Je vais juste commets Ce changement rapide et mettre à jour le serveur sans le tester ».

Il a travaillé très bien pour moi jusqu'à présent.