Est-ce une bonne pratique d’utiliser des branches pour gérer différentes éditions du même logiciel?

Nous avons un produit qui a plusieurs éditions différentes. Les différences sont mineures: différentes chaînes ici et là, très peu de logique supplémentaire dans l'une, très peu de différence de logique dans l'autre. Lors du développement du logiciel, la plupart des modifications doivent être ajoutées à chaque édition. Cependant, il y en a quelques uns qui ne le font pas et d'autres qui doivent différer. Est-ce une utilisation valide des branches si j'ai des branches release-editionA et release-editionB (..etc)? Y a-t-il des pièges? Bonnes pratiques?

Mise à jour: Merci pour la perspicacité de tous, beaucoup de bonnes réponses ici. Le consensus général semble être que c'est une mauvaise idée d'utiliser des branches à cette fin. Pour ceux qui le souhaitent, ma solution finale au problème consiste à externaliser les chaînes en tant que configuration et à externaliser la logique différente sous forme de plug-in ou de script.

Cela dépend de l'ampleur du changement, mais je ne considérerais pas cela comme une bonne pratique pour les différences que vous avez décrites.

Généralement, vous voulez qu'une branche Git soit quelque chose qui sera fusionné à l'avenir ou stocké en lecture seule pour référence. Les branches Git qui coexistent indéfiniment signifient du travail pour tout le monde: les changements doivent être propagés et fusionnés, les conflits résolus, tout le plaisir. Si rien d'autre, chaque développeur doit se rappeler de transmettre les modifications à cinq référentiels au lieu d'un.

Si vous avez de petits changements, tous les efforts de fusion et de maintien de branche semblent excessifs par rapport au problème. Utilisez votre préprocesseur ou votre système de génération pour différencier les versions. Est-ce qu'un simple #ifdeffait le tour? Alors ne résolvez pas les problèmes avec git, c’est exagéré.

Ce n'est pas vraiment à quoi servent les branches. Les branches sont censées être des chemins secondaires à court et à moyen terme vers votre ligne de développement, et non des versions parallèles à long terme du même code.

Je mettrais toutes les versions différentes dans la même branche, avec un sous-répertoire pour les parties différentes d'une édition à l'autre, et configurerais votre processus de construction (vous avez une construction automatisée, n'est-ce pas?), De sorte qu'elle puisse générer l'une ou l'autre édition à la demande (ou tous à la fois).

Après tout, vous voulez garder une "source unique de vérité"; avec des branches, vous allez dupliquer du code, mais pas tout, et certaines fusions briseraient votre configuration.

Une solution - comme certains l’ont souligné - consiste à configurer le système de compilation pour prendre en charge différentes éditions.

J'envisagerais également de l'implémenter en tant que fonctionnalité bascule et d'utiliser un fichier de configuration. Moins vous devez construire, mieux c'est.

Regardez ce site.

Je pense que c'est une bonne idée à condition que vous ne puissiez pas le faire au sein d'une branche sans regrouper le code en trop.
Je préférerais pouvoir le conserver dans une branche et utiliser les fichiers de configuration et localisés, surtout si vous dites que les différences sont mineures.
Vous pouvez également utiliser différentes versions, par exemple votre fichier de compilation regroupe différents fichiers pour différents clients, mais je peux également voir l'outil de génération extraire différentes branches. Comme vous utilisez git, je dirais pas de vrais pièges. Une stratégie de création de branche pourrait consister à développer différentes branches pour différentes tâches, à s’enregistrer dans la branche principale et à passer de maître à édition X et Y.

Cela ressemble plus à un travail pour différentes configurations de construction. La réponse de thiton va dans cette direction mais je la prendrais beaucoup plus loin que #ifdef:

Utilisez différentes cibles de construction pour créer différentes éditions du logiciel. Les cibles peuvent différer selon

• la configuration qu'ils incluent,
• l'objet ou les fichiers source inclus, ou
• le prétraitement du code source.

Ce prétraitement peut évidemment inclure le préprocesseur C classique, mais il pourrait également impliquer l’utilisation d’un préprocesseur personnalisé, d’un moteur de gabarit pour créer des vues personnalisées,…

De cette façon, vous évitez de pousser activement chaque modification vers plusieurs branches, ce qui constitue une violation de DRY (bien sûr, cela peut aussi être automatisé mais je ne vois pas l'avantage).

J'utiliserais les branches uniquement pour les modifications significatives, sinon vous ajouteriez chaque petite modification à de nombreuses branches, ce qui n'est pas amusant du tout et qui est très sujet aux erreurs, surtout si vous travaillez avec plus de personnes.

Si vous les publiez tous sous forme de produits différents, il est recommandé d’avoir plusieurs branches. Sinon, il est toujours recommandé d'utiliser quelque chose comme un tronc ou une branche principale.

De plus, je pense que cela dépend du processus de développement que vous avez, notamment du déploiement. Si votre processus autorise uniquement le déploiement d'une branche en production et que les branches sont traitées comme des "versions incrémentielles", cela signifie que la version B ne peut pas être déployée en production, à moins que la version A ait été déployée en premier, car toutes les modifications apportées à A sont déjà en B, alors il faut aller avec plusieurs branches. Cela fonctionnera si vous avez des équipes dispersées dans le monde entier et que vous avez généralement des modifications ordonnées par priorité.

La solution avec les trois différentes branches (pour la production, le développement et les fonctionnalités) fonctionne vraiment bien. Disons que vous découvrez un bogue dans votre code de production, vous pouvez ensuite appliquer un correctif à celui-ci, puis le publier. Assurez-vous simplement de ne pas ajouter de fonctionnalités à la branche de production ni de modifications majeures à la branche de production. Vous et votre équipe devrez faire preuve de discipline pour ne pas ajouter de modifications de fonctionnalités majeures à votre branche de production. La branche de production ne devrait s'occuper que de corrections de bugs mineurs qui ne garantissent pas un changement majeur de votre base de code de production.