Comment gérez-vous l'intégration de code provenant de plusieurs branches / développeurs à chaque sprint?

Je viens de recevoir un appel rétro où les développeurs ont exprimé leur préoccupation quant à l'intégration de leurs histoires dans la branche principale à chaque sprint. Les développeurs codent tous dans leur propre branche et vers la fin du sprint, ils fusionnent tous en une seule branche principale.

Ensuite, il reste un développeur (généralement le même) chargé de s’assurer que tout s’intègre bien avec le code des autres développeurs (la plupart des modifications se trouvent sur la même page. Par exemple, une histoire d’affichage des données, une histoire de filtrage des données, et un indicateur SLA).

Comment pouvons-nous réduire ce fardeau et faciliter la fusion de notre code? De mon point de vue, le fait que le bon de commande ou le gestionnaire de priorités hiérarchise les histoires de manière plus efficace, de sorte que nous n'ayons pas ce type de dépendances dans le même sprint, pourrait résoudre certains problèmes. Comment chacun aborde-t-il cela? Ou est-ce juste une partie du processus?

Si vous utilisez Git, chaque développeur tire de la developbranche dans sa propre branche de fonctionnalité afin de s’assurer qu’il ne s’éloigne pas trop de la base actuelle. Ils peuvent le faire quotidiennement, de sorte que les tâches qui durent plus de deux jours restent synchronisées et que les problèmes de fusion soient résolus tant qu'ils sont encore petits.

Lorsque le développeur a terminé son travail, il crée une demande d'extraction . Une fois approuvé, cela est fusionné dans la developbranche.

La developbranche devrait toujours avoir du code de travail et être prête pour la publication à tout moment. Lorsque vous effectuez en fait une version, vous fusionnez developdans masteret taguez.

Si vous disposez d'un bon serveur Continuous Integration Server, chaque branche sera créée lors de l'enregistrement des modifications, en particulier pour les demandes d'extraction. Certains serveurs de génération s'intègrent à votre serveur Git pour approuver ou refuser automatiquement une demande d'extraction si la construction échoue ou si les tests automatisés échouent. C'est une autre façon de trouver des bogues d'intégration potentiels.

J'ai travaillé dans une équipe où nous avons lutté avec le même problème. Nous avons constaté que moins nous avions de temps avant l'intégration, moins cela devenait difficile. Je sais que la plupart des enseignants en intégration continue parlent d'engagement toutes les quelques minutes - nous nous sommes probablement engagés toutes les heures environ.

Nous avons également constaté que la construction ne suffisait pas. Nous avions besoin d'un bon niveau de couverture de test afin de nous assurer que nous ne casserions pas accidentellement le code de chacun.

• Gardez vos branches éphémères (on dirait que vous le faites déjà).
• Laissez les résultats de vos tests parler d'eux-mêmes.
• N'attendez pas la fin du sprint.

Vous n'avez même pas besoin de vous abonner à TDD pour celui-ci. Tout ce dont vous avez besoin sont quelques tests qui prouvent que les fonctionnalités de vos développeurs fonctionnent correctement. Ceux-ci pourraient inclure des tests unitaires et des tests d'intégration, mais constitueraient idéalement deux tests automatisés de bout en bout des fonctionnalités critiques. Trucs de pack de régression standard.

Ensuite, une fois votre fusion terminée, vous pouvez vérifier le rapport de test d'automatisation ensemble et vérifier que tout a été intégré avec succès.

Je suis d’accord avec l’une des autres réponses dans lesquelles l’auteur a déclaré que les relations publiques de Git permettraient de résoudre ce problème en amenant chaque développeur à fusionner son propre travail.

Un autre point qui, à mon avis, est suffisamment important pour rester jusqu'au dernier paragraphe. Je suggère que vous exécutiez des tests manuels sur vos versions nocturnes, plutôt que d’attendre la fin du sprint. Les développeurs doivent fusionner dès que la fonctionnalité est terminée afin de pouvoir l'intégrer, la déployer et la tester le plus rapidement possible.

Ne pas

En fonction de votre langue et des fichiers que vous modifiez, il peut ne pas être judicieux que chaque développeur les modifie sur sa propre branche. Par exemple, en C #, il est préférable qu'une seule personne puisse éditer des fichiers de concepteur d'interface utilisateur à la fois. Il s’agit de fichiers générés automatiquement. Par conséquent, le code est parfois déplacé sans raison apparente - ce qui cause des ravages sur la plupart des outils de fusion.

Cela signifie que certaines histoires peuvent en bloquer d'autres jusqu'à ce que le travail de l'interface utilisateur soit terminé. Et / ou, une nouvelle histoire est créée pour simplement mettre en page l'interface utilisateur, les autres histoires implémentant des fonctionnalités. Ou peut-être qu'un développeur effectue tout le travail d'interface utilisateur pendant que d'autres implémentent les fonctionnalités de cette interface utilisateur.

Sur une note connexe, si vous savez que plusieurs histoires vont toutes toucher le même fichier, vous voudrez peut-être simplement éviter de les traiter toutes en même temps. Ne les tirez pas tous dans le même sprint ou ne commencez pas à les travailler tous avant qu'un ou plusieurs ne soient terminés.

Les drapeaux de caractéristiques sont une autre approche possible pour éviter les fusions tardives et volumineuses : vous protégez vos modifications avec un drapeau configurable (idéalement de manière dynamique) qui les empêche de devenir actives avant la fin prévue.

Cela vous permet de fusionner vos modifications très tôt dans l'une masterou l' autre de vos branches de développement conjoint sans rien casser. Les autres développeurs peuvent ensuite fusionner ces modifications dans leurs branches de fonctionnalités (ou rebasonner leurs branches en conséquence).

Comme les autres réponses l'ont déjà indiqué, cette solution devrait être associée à une solution d'intégration continue.

Les indicateurs de fonctionnalité présentent des avantages supplémentaires (par exemple, ils facilitent les tests A / B). Voir cet article de Martin Fowler pour plus d'informations.

Nous suivons une approche de branche de développement distincte pour chaque fonctionnalité, puis nous fusionnons les branches en une branche d'assurance de la qualité pour les tester dans un environnement de test d'intégration.

Une fois les tests de régression et d'intégration terminés, nous déplaçons facilement les fonctionnalités prêtes à l'emploi vers la branche des versions.

Si tout se passe bien, nous fusionnons la branche release avec la branche master.

En termes simples, engager et fusionner réduit souvent la fenêtre d'opportunité pour la fusion de conflits et réduira considérablement les conflits. L’autre partie concerne en effet la planification par le chef de file, ce qui peut garantir une plus grande fluidité du travail.

Les autres réponses donnent un bon aperçu des meilleures pratiques pour les commits. En les observant, vous réduirez probablement la grande majorité de vos problèmes de fusion. Plus de fusions sont certainement une nécessité, mais pour une petite équipe, votre approche de branche par personne fonctionne probablement assez bien. Bien sûr, cela ne fait pas mal (beaucoup) d'entrer dans des pratiques plus extensibles!

Cependant, personne ne semble avoir répondu à l'une de vos questions les plus importantes: que faire lorsque vous touchez tous aux mêmes zones de code. C’est pourquoi il est utile de faire appel à un chef de projet qui connaît bien la base de code et peut reconnaître les dépendances de différentes tâches. S'ils n'orchestrent pas le temps de travail et les validations, vous vous retrouverez probablement avec des conflits de fusion et une résolution ligne par ligne. Organiser les tâches \ chronométrer est beaucoup plus difficile avec une équipe plus grande, mais avec une petite équipe, il est possible d'identifier ces tâches contradictoires. Le responsable pourrait alors même confier toutes les tâches liées au même ingénieur, afin d'éviter le conflit.