Quand dois-je arrêter de m'engager à maîtriser de nouveaux projets?

Chaque fois qu'un nouveau projet démarre, il est généralement logique de commencer par s'engager directement sur master jusqu'à ce que vous ayez quelque chose de "stable", puis vous commencez à travailler dans des branches.

Au moins, c'est comme ça que je le fais normalement. Existe-t-il un moyen de démarrer immédiatement des branches à partir du deuxième commit? Est-il sensé de procéder ainsi? Évidemment, "Initial Commit" sera toujours sur master, mais après cela, quand saurai-je que c'est le bon moment pour commencer à créer des branches pour de nouvelles fonctionnalités?

Immédiatement.

La clé est la question de savoir quelle est la politique du Maître. Avec git, généralement, la politique de branche sur Master est la version stable à construire . Parfois, Master est la «ligne principale» à partir de laquelle les branches sont créées et fusionnées avant de fusionner avec une branche Release. Ce sont deux approches de rôle / politique différentes.

C'est souvent une source d'erreurs pour les personnes qui changent le rôle ou la politique d'une branche en cours de projet. Il est plus facile pour un développeur solo de communiquer ces changements aux contributeurs, mais en essayant de faire reconnaître par une douzaine de programmeurs tous "Master est maintenant à 1.0, branchez les fonctionnalités plutôt que tout le monde le pousse"

J'ai abordé l'approche politique ci-dessus. La politique de Master est qu'il s'agit de la version stable à construire . L'inscription de petites modifications incrémentielles dans cela signifie que vous n'avez pas quelque chose de stable à construire en tout temps. Ne pas enregistrer de petits changements va à l'encontre des "beaucoup de petits (mais complets) enregistrements" qui ont tendance à être la meilleure politique (et encouragés par une ramification facile).

Du point de vue du rôle, vous avez commencé avec le maître en tant que rôle principal, de version, de maintenance et de développement, puis certains indiquent la voie à suivre pour que le rôle de développement et de maintenance passe aux succursales. Cela signifie à nouveau un changement dans ce qui est autorisé sur le maître et peut confondre les contributeurs quant à la place des choses. Cela peut également (légèrement) confondre l'histoire de la branche, encourageant les grands commits qui signifient des fusions plus importantes et plus difficiles à comprendre.

Clé les rôles et les politiques sur les branches simples et cohérents dès le départ.

Cette «branche sur le changement de politique» peut être vue dans les modèles de branchement . L'idée de chaque branche ayant des rôles peut être lue dans Advanced SCM Branching Strategies . Ces deux lectures sont très bonnes.

Il existe principalement deux situations dans lesquelles vous souhaitez généralement commencer à travailler avec des branches:

• lorsque vous ou votre équipe devez démarrer une nouvelle fonctionnalité qui a la moindre chance de ne pas être ajoutée à la prochaine version (qui peut être la toute première version), puis démarrez le développement dans une branche de fonctionnalité distincte.

• lorsque vous devez fournir des correctifs pour les bogues graves à la dernière version et que vous souhaitez créer une nouvelle version de correction de bogue contenant uniquement ces correctifs, mais pas de fonctionnalités nouvellement développées (et probablement instables)

Pour ce type de décisions, je pense qu'il est utile de toujours penser en termes de "nouvelles fonctionnalités" ou "corrections de bugs", à partir du moment où vous avez une première version compilable / exécutable de votre programme.

Michael Feathers énumère quatre raisons de changer dans son célèbre livre, mais je mettrais "optimiser les ressources" sous "nouvelle branche de fonctionnalité" (pour une fonctionnalité non fonctionnelle) et "améliorer la conception" la plupart du temps sous "nouvelle branche de fonctionnalité" également , car à mon humble avis, il ne faut jamais améliorer la conception lorsque celle-ci n'est pas destinée à faciliter la mise en œuvre d'une fonctionnalité spécifique .

Si vous suivez git-flow - et, très franchement, je pense que vous êtes fou si vous utilisez Git et n'utilisez pas ce modèle de branchement - alors vous ne devriez jamais vous engager masteravant d'être prêt pour une version publique.

Votre premier commit masterdoit être un référentiel vide. Votre prochain commit masterdevrait être un commit de fusion de la developbranche ou d'une branche de publication temporaire, et il devrait être stable, testé et prêt pour le déploiement (si c'est une application) ou la distribution publique (si c'est une bibliothèque).

Il existe d' autres modèles de branchement pour Git, mais la plupart d'entre eux sont dérivés d'anciens modèles SCM centralisés et peuvent entraîner de graves problèmes dans un environnement DVCS. Vous n'êtes pas obligé d'utiliser réellement l'extension git-flow, et vous n'avez pas nécessairement besoin de toutes ces branches release / hotfix / feature, mais le noyau est developet master, et le code instable entre develop.

Neal Ford de Thoughtworks préconise l'utilisation de bascules de fonction sur la ramification pour éviter le problème de «l'enfer de fusion». Considérez le cas dans lequel deux programmeurs fusionnent consciencieusement quotidiennement à partir de la branche principale et l'un des changements considérables au cours de quelques semaines puis s'engage. L'autre programmeur pourrait très bien se retrouver en enfer de fusion. Pour éviter ce problème, Ford recommande de "faire avancer la douleur" (un attribut agile bien connu) en n'ayant qu'une seule branche et en s'y engageant quotidiennement. Des fonctionnalités supplémentaires sont ajoutées via des bascules de fonctionnalités qui désactivent la fonctionnalité jusqu'à ce qu'elle soit entièrement testée.

Cette méthodologie semble fonctionner le mieux dans un environnement qui implémente la livraison continue, car les problèmes de validation seraient immédiatement détectés.

Cela fait deux ans depuis la dernière réponse à cette question et je pense que maintenant l'histoire change. Pour moi, la réponse est "Chaque fois que vous utilisez le contrôle du code source pour suivre les versions."

Pour élaborer, ces jours-ci, le suivi des versions de projet avec le contrôle du code source ne fonctionne pas toujours. (par exemple, en utilisant npm pour gérer la dépendance et spécifier les versions sémantiques avec '^') Dans ce cas, les artefacts du projet changent à chaque fois qu'une génération se produit, sans nécessairement correspondre aux changements de code source à chaque fois. Pour gérer ce genre de nouveaux défis, certaines équipes choisissent d'avoir déjà construit des «artefacts» enregistrés dans le système de contrôle des artefacts (par exemple, JFrog Artifactory) pour les versions de projet de piste.

De toute évidence, lorsque vous avez déjà un contrôle de version des artefacts en place, vous ne tireriez pas le `` code de production '' d'une branche GIT et ne le construisez / déployez pas en production, vous consultez plutôt le système de contrôle des artefacts pour des versions directement exécutables pour le déploiement. Dans de tels cas, le concept de «branche de libération» perd soudainement son sens. Et chaque fois que votre équipe décide de ne pas associer la branche git à la version finale, engager / pousser directement vers master devient à nouveau un choix judicieux: il s'agit de la branche par défaut chaque fois que le dépôt est cloné, d'où automatiquement la sémantique largement acceptée et bien communiquée. changements. Pourtant, comme le suggère la réponse acceptée, vous devriez probablement diriger un rôle d'attribution aux branches, y compris le maître, et utiliser ces branches uniquement pour ces rôles particuliers.

Enfin, je vais un peu plus loin et je suggère d'utiliser master comme branche de développement dans des projets avec seulement une poignée de committers principaux. C'est le cas pour mon équipe et probablement la même chose pour la plupart des micro-services. S'engager sur le maître supprime le processus de communication des changements et évite potentiellement de «fusionner l'enfer» lorsque vous travaillez sur des fonctionnalités sur plusieurs sprints. De plus, le code dans la branche principale n'a même pas à `` fonctionner '', le processus de construction / test automatisé vous dira ce qui s'est mal passé et il est de toute façon assez facile de vérifier l'historique de git et de contacter l'auteur qui a cassé la construction / test :-)

Je vais prendre une position radicale: brancher sur chaque idée. Tout d'abord, les branches git sont bon marché, le coût principal d'une branche est de se rappeler à quoi cela sert. Je conviens également que le premier commit à master est un candidat à la libération. Je recommande de commencer par une branche de preuve de concept. Lorsque vous avez prouvé votre concept, vous pouvez le fusionner avec votre branche de développement vide ou réécrire en fonction de la qualité de votre premier essai. à partir de ce point, vous dérivez de devel pour chaque bogue, fonctionnalité, abstraction, etc.