¿Son los conflictos de fusión complicados frecuentes un signo de problemas?

35

En nuestro equipo, utilizamos Git como nuestro control de origen. Tenemos varias áreas de código que son casi independientes pero que tienen cierta superposición. Últimamente hemos estado discutiendo flujos de trabajo y enfoques para usar el control de código fuente. Una queja que surge cuando promuevo el uso de un flujo de trabajo de rama de características es que las personas a menudo se encuentran con conflictos de fusión complicados que resuelven incorrectamente. Por complicado, quiero decir "no es obvio en cuanto a cómo resolver". A la luz de esto, se están utilizando más activamente otros flujos de trabajo, como un flujo de trabajo basado en "rebase de extracción".

Como defensor del enfoque de la rama de características, realmente no estoy recibiendo la queja. Sí, debe mantener sus ramas de características locales actualizadas desde el maestro o donde sea, pero ese es el único problema real que veo. Estoy pensando que si sus fusiones son siempre complicadas y pueden tener efectos secundarios, entonces eso es más un problema de trabajo en equipo que un problema de Git.

¿Estoy en lo correcto al pensar esto? ¿Los conflictos de fusión complicados son un signo de algo bueno o malo?

joshin4colours
fuente
1
¿Cuánto duran las funciones? ¿Qué tan bien modularizado está el código? ¿Podría (por ejemplo) seleccionar el código de prueba (se hizo primero y se separó del código real, ¿verdad?) Para ver cómo cambió la funcionalidad?
@MichaelT La base del código es para nuestra base de código de prueba automatizada. Estamos a punto de comenzar a trabajar en una nueva adición a nuestro proyecto que probablemente necesite un poco de desarrollo paralelo por un tiempo. De ahí la discusión de las ramas de características frente a otras.
joshin4colours
77
¿La gente realmente se encuentra con este tipo de problema, o simplemente temen que puedan aparecer esos problemas?
Christopher Creutzig
2
Por cierto IMPRESIONANTE tutorial al que te has vinculado :)
Vorac
1
Rebasar la rama de la característica o fusionarla con troncal da como resultado fusiones similares. Rebasar en realidad hace más fusiones y, como tal, es más probable que genere conflictos graves . Lo que importa es con qué frecuencia se hace.
Jan Hudec

Respuestas:

23

No es imposible que el problema sea tu código. Si su base de código tiene muchas interrelaciones entre módulos, entonces cada cambio tendrá zarcillos en todas partes, y cada desarrollador interactúa con el código de cualquier otra persona, será una pesadilla.

Tendería a pensar que notarías esto de otras maneras primero, pero es posible que estés tan acostumbrado que ya no puedas verlo.

Michael Kohne
fuente
99
Este fue mi primer pensamiento. Los conflictos de fusión complicados ocurren cuando se realizan múltiples cambios en el mismo código. Si tiene un proyecto bastante joven, esto es común, pero si tiene una base de código de buen tamaño, esto podría ser un signo de "objetos divinos" o que algunos módulos / clases están haciendo demasiado y necesitan ser refactorizados. También puede provenir de cometers excesivamente entusiastas que cometen docenas de pequeños cambios, pero eso es menos común.
TMN
1
El hecho de que nuestra base de código sea algo "joven" (aproximadamente 6 meses de edad, pasó por varios refactores importantes) podría ser un indicador de esto.
joshin4colours
10
@ joshin4colours Si está refactorizando mientras alguien está escribiendo una función grande, está en problemas.
Sean McSomething
17

Estoy acostumbrado al flujo de trabajo "fetch-rebase-push". ¿Cuál es en realidad el primer flujo de trabajo más primitivo que se describe en su tutorial? Aquí están las ventajas:

  • Verdadera integración continua
  • Gestión temprana de conflictos: justo después de que uno haya escrito y probado el código
  • Respuesta rápida: "-Oye, Bob, la interpolación cúbica que escribiste está dando una salida graciosa, ¿podrías mirarla mientras estoy almorzando?"
  • Sin compromisos de fusión: limpie la línea de tiempo como si un desarrollador escribiera everithyng

Ahora, sobre conflictos de fusión complicados. No entiendo cómo se pueden experimentar fusiones frecuentes y complicadas. La complicación surge de no hacer rebase / selección de cerezas durante mucho tiempo, trabajando en esa característica solitaria durante un mes.

Personalmente, preferiría lidiar con conflictos de fusión fáciles y frecuentes (en realidad, rebase), en lugar de un horror de fusión raro y abarcador.

Vorac
fuente
1
Excelente descripción de un buen flujo de trabajo de Git, pero esto no responde a mi pregunta.
joshin4colours
2
@joshy esto es cierto. Solo el tipo de párrafo medio responde a su pregunta. Pero aquí hay una respuesta directa. Si la fusión es frecuente y difícil, entonces esto es sin duda una indicación de un flujo de trabajo problemático / problema de comunicación / problema de arquitectura / división o el problema de roles.
Vorac
7

Las fusiones y rebases deben causar exactamente los mismos conflictos, para aquellos conflictos inherentes que un humano debe resolver (es decir, dos desarrolladores que cambian la misma línea de código). Para otros conflictos, las fusiones en realidad tienden a ser más limpias, porque no está cambiando el SHA-1 de los commits en todo el lugar. No estoy seguro de cómo se las arregla para entrar en un estado donde las fusiones causan más conflictos que rebases, pero ciertamente es una señal de que el flujo de trabajo de algunas personas está en mal estado, y probablemente necesiten más capacitación sobre cómo funciona git. ¿Están eliminando los compromisos de fusión de otras personas cuando hacen sus rebases locales, o algo así?

El beneficio y el inconveniente del método pull-rebase es muy similar a los flujos de trabajo centralizados a los que mucha gente está acostumbrada. No tiene que entender la ramificación para usarla.

En cualquier caso, es perfectamente factible hacer un flujo de trabajo de sucursal de características solo localmente, si no puede hacer que otras personas inicien sesión en él.

Karl Bielefeldt
fuente
5

El proyecto en el que estoy trabajando tiene este tipo de problemas de vez en cuando y parece ser el resultado de un par de factores:

  • Estamos usando Visual Studio y archivos como Visual Studio .sln son solo documentos XML (que no responden bien a las fusiones textuales) llenos de Guías (que Git no puede entender mejor que el resto de nosotros) y pueden ser fácilmente mal fusionado y hacer que los archivos se pierdan.
  • Algunas personas están trabajando en áreas similares del código, de modo que los cambios que se empujan pueden estar uno al lado del otro en las clases. Aunque inevitable en esta situación, este tipo de configuración va a ser un trabajo muy duro para cualquier sistema de control de fuente. Incluso si tiene una gran comunicación en su equipo, a veces las personas no se darán cuenta de que están tropezando con el código de los demás y surgen conflictos.

Estoy interesado en el potencial de Semantic Merge para ayudarme con algunos de esos problemas, pero obviamente eso solo sirve de algo si estás trabajando en un idioma que pueda analizar y aún no me he encontrado con desafíos importantes cuando ' Lo estoy usando, así que no puedo garantizar su efectividad.

glenatron
fuente
4

A menos que los desarrolladores estén modificando confirmaciones históricas (en lugar de combinaciones puras), los conflictos en un modelo git de flujo de trabajo de características son un signo de una base de código estrechamente acoplada (/ nueva base de código) o una asignación de características superpuestas.

sjakubowski
fuente
0

Tiene una rama principal (maestra) y todos trabajan en sus ramas características.

El trabajo en las ramas de funciones puede llevar desde unas pocas horas hasta unos pocos meses.

De vez en cuando, alguien volverá a fusionar su conjunto de cambios en la rama principal. El líder de su equipo debe asegurarse de que solo una persona realice una fusión inversa a la vez. Una vez hecho esto, debe reenviar la fusión de la rama principal a su rama de características. Una vez que todos hacen una combinación directa, se puede permitir que otra persona invierta la combinación en la rama principal. De lo contrario, demasiados cambios se fusionarán inversamente y tendrá toneladas de conflictos de fusión en su combinación hacia adelante.

Solo para aclarar la terminología, por "fusión inversa" me refiero a la fusión de la rama característica en la rama principal, y por "fusión directa" me refiero a la fusión de la rama principal en la rama característica. Según lo que he experimentado antes, es probable que vea más conflictos de fusión en combinación inversa, en lugar de combinación directa.

CodeART
fuente
1
La fusión en la rama principal nunca debe tener ningún conflicto. Siempre fusiona main con feature primero, por lo que feature to main está libre de conflictos.
gnasher729
@ gnasher729 - Creo que eso es lo que dice esta respuesta: la sugerencia que veo es que cada desarrollador se fusiona de main a sus ramas de características cada vez que alguien compromete algo a main, de modo que todos los conflictos se resuelven inmediatamente en las ramas de características.
Periata Breatta
Dijo "es más probable que tenga conflictos fusionándose de una función a otra"
gnasher729
0

Dos cosas que pueden ayudar: una, evite las herramientas que realizan cambios por su cuenta. Dos desarrolladores que usan diferentes configuraciones de pestañas son una receta para el desastre. Dos, hacer cambios en diferentes ubicaciones. Obtendrá un problema, por ejemplo, si tres desarrolladores agregan código al final del mismo archivo, mucho mejor si agregan código en diferentes lugares.

gnasher729
fuente