¿Hay algún daño al dejar que una rama git "envejezca"?

Question

Oí hablar del flujo de trabajo branch-per-feature usando Git, y también he leído algunas razones por las cuales this could be a bad idea.

Mi verdadera pregunta es esta: si estoy desarrollando solo una característica pequeña (como un analizador simple de tiempo regex), después de fusionar esta rama nuevamente en el tronco, ¿qué ocurre (o debería ocurrir) en esa rama? ¿Simplemente se sienta allí? Desde que lo creé para esa característica muy específica, no puedo pensar en una razón por la que tendría que volver atrás y usar la rama. ¿Debería de alguna manera marcar esta rama como extinta, o simplemente seguir adelante y olvidarme de ella?

Gracias

Answer 1

Cuando uso ramas de características, me gusta retener el hecho de que una característica se desarrolló en una rama después de la fusión. Eso hace que navegar por la historia sea mucho más fácil. Agrupa los cambios por función o error y hace que sea más fácil saber lo más importante: por qué se realizó un cambio.

Por eso, cuando me fusiono, desactivo deliberadamente el reenvío rápido con git merge --no-ff. Esto conserva la estructura de la rama en la historia. Entonces, soy libre de eliminar la etiqueta de rama (git branch -d branch_name), el punto de fusión contiene el nombre de la rama y limpiar el conjunto de ramas.

Por el contrario, cuando se trabaja en una rama, prefiero rebase la rama ascendente. Esto mantiene el historial de la sucursal limpio y agradable, libre de mucho ruido de fusión ascendente y resolución de conflictos.Por lo general, volveré a establecer una base de datos antes de fusionarme para facilitar el trabajo de integración (ya que el autor de la sucursal puedo solucionar conflictos y pruebas rotas) y el limpiador de combinación resultante.

Este enfoque conserva el historial de las ramas al tiempo que evita que las ramas antiguas que ya no se desarrollen obstruyan las cosas. Hace que la visualización de la historia con gitk o GitX sea muy útil.

Estoy de acuerdo con los puntos básicos del artículo que vinculó, a medida que obtiene más ramas de funciones grandes que se trabajan simultáneamente, hay más y más posibilidades de problemas de conflicto e integración. El aislamiento que los hace tan útiles se convierte en una responsabilidad. Una de las soluciones es no tener ramas grandes y antiguas. Si puede reventar una rama de función en piezas más pequeñas que pueden completarse e integrarse, entonces evita el problema. Esto a menudo es útil por muchas otras razones, como el pobre cabrón que tiene que revisar el código.

Si es posible integrar continuamente una rama de características en la línea principal, entonces la rama de características debe tener un trabajo útil, probado y documentado. Si tiene eso, entonces esos podrían ser cortados en sus propias ramas.

libremente admito que puede estar leyendo demasiado en esto, pero uno de los defectos posiblemente contando en el artículo es que las ramas se nombran para las personas y no características. Esto implica que cada rama es para "lo que sea que Jim esté trabajando" en lugar de "agregar widgets azules". Implica una serie de problemas de desarrollo ...

• características y las ramas son propiedad por individuos o equipos
• ramas no son para funciones discretas
  • lugar, las ramas son parques infantiles personales
  • con sin característica definida, pueden seguir y seguir
• desarrollo se hace en silos
  • individuos no hablan entre sí con regularidad
  • individuos no trabajan juntos en las ramas
  • personas no hablan de sus cambios hasta la integración

Mucho de esto no es una técnica problema, pero un problema social. Mucho de esto se puede resolver mediante el uso de un buen rastreador de problemas fuertemente relacionado con el control de versiones, como el de Github. El principal cambio es:

• ramas deben ser de características definidas
• desarrolladores deben informar de un problema antes ir fuera y hacer un montón de trabajo
• nadie "posee" una característica (aunque puedan ser responsable de ello)

Desafortunadamente, el segundo es desanimado por la mayoría de las políticas de seguimiento de errores del proyecto. El impulso de tener un parche listo antes de informar un error es muy fuerte.

La buena administración de la sucursal requiere una buena socialización que se ve facilitada por un buen rastreador de problemas con una fuerte integración de control de versiones y una política de bienvenida.

Answer 2

Borrarlo, si ya no lo necesitas. Si luego te das cuenta de que lo necesitas de nuevo, puedes crearlo de nuevo. Y debido a que fusionó los cambios de nuevo en "troncal", no se pierde nada.

Answer 3

Las únicas razones, que puedo ver, usted quiere mantener a su alrededor es:

• ¿Quieres una historia de la última vez que trabajó en ella.
• Podría inferir cuándo comenzó el desarrollo.

Answer 4

Dos cosas a tener en cuenta:

1. tal vez debería tener un hábito de rebase estas ramas en la punta de la maestra (o donde sea) antes de aterrizar ellos. De esta forma, son estrictamente redundantes, como sugiere KingCrush anteriormente, y se pueden destruir para volver a crearlas más adelante si encuentras un problema.

2. Use el rename para marcar las ramas que no está seguro si va a necesitar otra vez con un prefijo específico, para que pueda escanearlas rápidamente en una lista de sucursales cuando sepa que no está buscando una obsoleta rama de características

Puede utilizar alguna combinación de estas técnicas, p. siempre rebase, luego cambie el nombre de la rama foo a aterrizado-foo, y luego después de un intervalo establecido (por ejemplo, una versión, o 30 días) elimine la rama aterrizada-foo.

Tenga en cuenta que si no rebase (y ejecuta pruebas en la versión reestablecida) no tiene forma de estar seguro de que un error encontrado después de su aterrizaje estaba realmente en el código como desarrollado y no causado por el impacto de fusionarlo después del desarrollo, por lo que en este caso es posible que desee mantener la rama por un tiempo. Esto ocurrirá más a menudo con cambios invasivos/muy grandes, no como en el escenario de su pregunta.

Answer 5

Lo bueno de Git y las ramas es que cada rama es esencialmente un puntero a una confirmación. Una vez que haya fusionado su sucursal, las confirmaciones que solían formar su sucursal ahora son una parte integral de la historia principal.

        your branch 
            main 
             | 
    (main) -------x----x----x-x---x----x 
        \    /
    (your branch) \--x--x-x--x-x---/ 

En este punto, si se elimina el uso de su sucursal "-d git branch", uno se queda con:

        main 
             | 
    (main) -------x----x----x-x---x----x 
        \    /
    (your branch) \--x--x-x--x-x---/ 

Como se puede ver, las confirmaciones de su sucursal están a salvo . Todo lo que ha cambiado es que el puntero llamado "su rama" ha sido eliminado.

Tenga en cuenta que si no se hubiera combinado en main, entonces "git branch -d" habría fallado. Si borrar fuerza en ese punto, usted se quedará con:

        main 
            | 
    (main) -------x----x----x-x---x--x 
        \ 
    (your branch) \--x--x-x--x-x 

Puesto que no hay rama puntero en esta etapa, las confirmaciones están "colgando" y se eliminarán la próxima vez Git hace su basura colección.

En resumen, si su rama se ha fusionado, puede y debe eliminarla. Si no se ha fusionado, no deberías.