¿Control de versión ágil?

Estoy tratando de encontrar un buen método para administrar los cambios de código en un proyecto grande con varios equipos. Usamos subversión en este momento, pero quiero más flexibilidad para crear un nuevo lanzamiento de lo que parece que puedo get con subversión.

Esto es más o less lo que quiero:

  • para que cada desarrollador cree parches fácilmente identificables para el proyecto. Cada parche brinda una historia completa del usuario (una function o solución liberable). Puede abarcar muchos cambios en muchos files.
  • los desarrolladores pueden aplicar y eliminar fácilmente sus propios parches y otros para facilitar las testings
  • release manager selecciona los parches que se utilizarán en la próxima versión en una nueva twig
  • sucursal es probada, las soluciones se fusionan y finalmente se fusionan en vivo
  • los equipos pueden volver a colocar estos cambios en sus cajas de arena.

Estoy buscando git astackdos como una forma de lograr esto, pero ¿qué otras herramientas o técnicas pueden ofrecer este tipo de flujo de trabajo?

Estoy tratando de encontrar un buen método para administrar los cambios de código en un proyecto grande con varios equipos.

Recomiendo leer el artículo de Henrik Kniberg Control de versiones para múltiples equipos ágiles en InfoQ.

En breve:

  • El tronco contiene historias HECHAS HECHAS, tiene una política liberable (se puede lanzar en cualquier momento).
  • El desarrollo se realiza en twigs de trabajo (una por equipo), tienen una política más flexible (unidad probada).
  • cuando se HACE una historia, se empuja desde la twig de trabajo al tronco.
  • La fusión de las twigs de tronco a trabajo se realiza todos los días.

Aquí hay una ilustración de un sprint completo:

texto alternativo

Esta es una versión extremadamente simplificada del trabajo de Henrik, pero ese es el espíritu. Es totalmente compatible con nuestro process (Scrum) y funciona muy bien para nosotros.

PD: Por cierto, realmente no entiendo por qué los desarrolladores trabajarían durante una iteración en algo que los administradores de versiones no elegirían para el lanzamiento.

Si sus historias son verdaderamente aisladas y muy aditivas (muy pocos cambios en las líneas de código existentes), el enfoque podría funcionar. Sin embargo, a medida que el trabajo se entrelaza más y más, las fusiones se volverán cada vez más difíciles.

Los entornos de CI, como lo sugiere duffymo, serán útiles, pero esas herramientas, según mi experiencia, no tienen muchas (o ninguna) características para crear muchas versiones del proyecto ni tampoco son inteligentes para mezclar / fusionar sucursales.

Sería mejor adoptar un enfoque más jerárquico. Cada grupo debe tener su propia IC y luego pasar a un sistema de versión maestra / sistema de IC cuando sea apropiado (¿fin del sprint de cada grupo?). Esto minimizaría las interacciones dolorosas para el grupo, pero permitiría que el proyecto en set avance continuamente. Si tiene muchos grupos, agregue algunos niveles adicionales de integración.

Tenga en count que, en este enfoque, las testings unitarias pueden permanecer en el nivel grupal, pero deberá encontrar forms de escribir testings de integración y del sistema que puedan funcionar en las comstackciones de alto nivel.

Por el lado de too, cualquiera de los sets de herramientas de CI debería funcionar. Para el control de versiones, Git y Mercurial admiten este tipo de enfoque (otros también pueden).

No es exactamente lo que está pidiendo, pero no creo que haya muchas herramientas que aborder el tipo de enfoque que desea tomar. Además, creo que un número razonable de historias provoca un nivel de refactorización de las existentes que dificultará la mezcla y los cambios de correspondencia.

Esto es una ilusión a less que, como ya se dijo, cada característica no se superponga en absoluto. Esa es una exception y no la regla.

Una mejor forma de hacerlo es involucrarse realmente con el equipo y tener una idea de cuándo algunas características pueden estar cerca de completarse. Haga que estos equipos de twig fusionen sus twigs a medida que se desarrollan. Fusionarlos en la twig de desarrollo y luego en el master luego de su lanzamiento será muy fácil.

Hay algunos puntos para agregar:

Rebase cuando sea posible, especialmente si una característica no se ha trabajado durante un time. Rebasing solidificará las resoluciones de conflictos en una historia lineal. Las fusiones o rebases posteriores no tendrán que volver a tomar estas decisiones, en cuyo momento la recolección puede no ser tan precisa.

Use la opción –no-ff (no avance rápido) al fusionar una twig en otra. Esto garantiza que si la segunda twig no tiene confirmaciones para fusionarse, se agrega una confirmación vacía que señala las dos twigs que se fusionan. Si esto no se hace, puede perder un punto de ramificación. Esta puede ser información importante.

Me parece que necesita una installation de continuous integration como Cruise Control, Hudson, Cruise, Team City, etc.