Résolution des conflits de fusion dus au refactoring

J'ai récemment participé à une discussion sur la façon de gérer la refactorisation en général (qui est un sujet intéressant en soi). Finalement, la question suivante a été soulevée:

Comment gérer les conflits de fusion qui se sont produits du fait que quelqu'un a refactorisé une partie du code, alors que quelqu'un d'autre travaillait sur une fonctionnalité pour le même morceau de code?

Fondamentalement, je n'ai aucune idée de la façon de traiter cela de manière efficace. Y a-t-il des meilleures pratiques à suivre à ce sujet? Y a-t-il une différence sur la façon de gérer cela pour un système avec des tonnes de code hérité?

Bonne question. La meilleure stratégie à laquelle je peux penser est:

La prévention

Une combinaison d'intégration continue et de petits remaniements fréquents (au lieu de grands remaniements occasionnels) contribuera grandement à minimiser le coût et la fréquence de ces conflits.

Je pense que pour répondre à votre question, nous devons d'abord voir pourquoi les conflits se produisent et quel est le véritable sens et le véritable processus de fusion?

Les conflits ne se produisent que lorsque deux développeurs ou plus travaillent sur le même fichier en même temps et qu'ils essaient tous les deux de s'enregistrer. Le premier développeur n'obtiendra aucun conflit, bien sûr. Mais le deuxième (troisième, quatrième, etc.) provoquerait des conflits. Pourquoi, parce qu'il a du code qui est partiellement ou entièrement différent du code existant sur le serveur.

Cela signifie que le deuxième développeur a quelque chose de différent du premier développeur. Cette différence peut varier du style, comme l'utilisation new UserManager().GetUserName()au lieu du UserManager userManager = new UserManager(); userManager.GetUserName();niveau que vous avez mentionné, ce qui signifie que les deux développeurs avaient des idées différentes sur la façon de refactoriser le code pour l'améliorer.

La fusion, d'autre part, ne signifie pas que les développeurs peuvent archiver leur code sans tenir compte des conflits. Ils doivent et doivent régler ces conflits. Si les conflits ne sont pas importants, ils peuvent archiver et remplacer le code précédent. Mais lorsqu'ils voient quelque chose de complètement différent, ils doivent appeler le développeur précédent et lui parler, afin qu'ils puissent tous les deux se coordonner pour trouver la meilleure solution.

Par exemple, si vous demandez à deux développeurs d' améliorer la bibliothèque de paiement en ligne et que leur travail se chevauche, cela signifie qu'au moins à certains endroits, il existe 2 solutions différentes. Donc, une de ces solutions doit être discutée et acceptée, donc enregistrée, comme la meilleure solution.

Je ne suis pas d'accord pour empêcher ces circonstances, car nous devrions avoir tendance à être plus réels que théoriques. Parfois, un gars est vraiment bon en CSS, tandis qu'un autre est vraiment bon en ASP.NET Markup. Mais leur travail peut entrer en conflit lorsqu'ils doivent tous deux travailler sur la page de connexion pour le faire fonctionner. Je veux dire, si nous pensons réel (pas idéal), nous pouvons voir que plusieurs fois ce phénomène (conflit) se produit.

Un autre point que je voulais juste mentionner, est d'utiliser des outils pour vous aider dans votre processus d'enregistrement. Ces outils visualisent généralement la différence entre le code serveur et le code développeur, et aident beaucoup à déterminer quelle partie doit être archivée.

S'il n'y a pas de gestion active des tâches, vous avez des conflits.

Si, cependant, vous avez une réunion quotidienne debout ou un gestionnaire , vous ne pouvez pas avoir ce problème.

Soit parler (via un stand up quotidien) ou parler à un manager.

Cela est trivialement évité en parlant.

Avoir une branche commune distincte pour développer une certaine fonctionnalité, fusionner / tirer / pousser souvent - c'est tout.

Et communiquez . Parlez avec d'autres développeurs du code même lors du lancement. Même lors du codage)))

Assurez-vous que la fusion est aussi simple que possible. Le refactoring est généralement un processus plutôt mécanique qui modifie de nombreuses lignes existantes : déplacer les déclarations de variables, les changements d'espaces, le formatage, la séquence des opérations. La création de fonctionnalités est généralement une entreprise beaucoup plus créative, aboutissant souvent à un nouveau code plus quelques ajustements mineurs au code existant. Maintenant, si le développeur effectuant la refactorisation enregistre les étapes (par exemple sous forme d'expressions régulières), il peut être beaucoup plus facile de les appliquer au code avec les fonctionnalités supplémentaires plutôt que l'inverse. Sur cette base, je dirais qu'en règle générale, vous devez d'abord appliquer la modification la plus complexe, suivie de modifications progressivement plus simples.