¿Cuáles son algunas de las mejores prácticas para mantener múltiples versiones de un proyecto?

Tengo un proyecto en el que estamos implementando v1 y comenzando a trabajar en v2. Me temo que vamos a ver correcciones de errores y cambios de funciones menores a v1 en los próximos meses, algunos de los cuales vamos a tener que pasar a la versión 2, algunos de los cuales vamos a tener que mantener separar. (Necesitamos mantener el set principal de características de v1, pero arreglemos cualquier error a medida que se encuentren).

Estamos usando SVN en este momento. He considerado cambiar a Git, pero soy un poco reacio a cambiar las herramientas. Aparte de esa posibilidad, ¿cuáles son algunas estrategias generales y mejores prácticas para hacer que gestionar esta situación sea lo más fácil posible?

Actualización: todo el mundo sugiere que ramifique el código en Subversion. Eso fue tan obvio para mí que pensé que estaba implícito en la statement "estamos usando SVN". Aparentemente no. 🙂 Sin embargo, voy a ver Mercurial and Bazaar y Git. ¿Algo más?

Usando SVN, lo mejor que puedes hacer es ramificar tu repository:

  • En el maletero, mantenga la última versión, no necesariamente estable.
  • Cada vez que necesite separar una nueva versión principal de allí, bifurque a, digamos, 2.0 y puede conservar la última versión y las versiones estables en el mismo repository.
  • Si encuentra cambios en la twig 2.0 que necesitan fusionarse en el enlace troncal, puede hacerlo sin problemas.

estamos utilizando TFS, pero para su problema específico, la solución será bastante similar: crear una nueva twig.
[Dependiendo del entorno de la aplicación que está utilizando, aparentemente no de Microsoft]
Nos hemos beneficiado de TFS porque:

  1. Puedes hacer fusiones entre twigs [fusiones sin base]
  2. Puede trabajar con elementos de trabajo, [para seguimiento de errores]
  3. Con el soporte de SharePoint, puede tener documentos, los scripts de testing pueden vivir juntos felizmente en un portal.
  4. Con los scripts de PowerShell, puede tener automotrices nocturnas

Para diferentes versiones, la mejor práctica es almacenar las versiones nombradas en la subcarpeta "tags". (Los documentos de SVN recomiendan que tenga una carpeta de troncales, tags y twigs para cada proyecto).

Cada vez que suelte una versión, copie el tronco en la carpeta de tags y asígnele un nombre. Esa versión puede seguir y correcciones de errores se pueden hacer por separado y fusionarse de ida y vuelta.

Documentos de SVN en el layout del repository:

http://svnbook.networking-bean.com/en/1.2/svn.branchmerge.maint.html

Debe usar SVN para labelr el código v1. De esta forma, puede crear una twig separada del código para admitir correcciones a esa base de código.

¿Has considerado ramificar tu tronco y hacer el desarrollo de v2 en la segunda twig una vez que la twig v1 está congelada? Si corrige errores en la twig v2 que afectan a v1 y desea liberar una actualización / parche para v1, solo combine esos cambios específicos con la twig v1 de la twig v2.

Todo eso es perfectamente factible en SVN, pero es mucho más fácil hacer una gestión de sucursales con una herramienta como Mercurial o Git. No puedo decirle si definitivamente vale la pena cambiarlo o no, ya que no conozco su compañía o base de código, pero es algo a considerar si puede evitar que esta situación surja repetidamente en el futuro a medida que libera más versiones.

Usando git puedes usar el siguiente enfoque:

Su repository git podría tener las siguientes twigs. Cada twig de revisión contiene una versión de function que debe mantenerse.

master - version: 3.0.0 (latest release) \ dev - version: 4.0.0 (next release) |\ | hotfix-1.x - version: 1.0.1 (current hotfix 1.x) \ | hotfix-2.x - version: 2.0.1 (current hotfix 2.x) \ hotfix-3.x - version: 3.0.1 (current hotfix 3.x) 

Correcciones:

Las correcciones de errores se realizan en hotfix-1.xy se combinan en "up" en hotfix-2.x y de allí a hotfix-3.x.

hotfix-1.x -> hotfix-2.x -> hotfix-3.x …

Las correcciones de errores también se pueden backported usando git el command cherry-pick de hotfix-3.x a hotfix-1.x (si es necesario). Con el command cherry-pick es posible elegir un solo compromiso y aplicarlo en una twig diferente. Git también detectará files movidos y renombrados y aún aplicará el cambio correctamente.

También puede agregar twigs de publicación en paralelo a las twigs de su revisión para preparar las versiones en esas twigs (se omite en este ejemplo). Esto es útil cuando no desea bloquear las twigs de revisión para nuevas confirmaciones. Por favor, compruebe gitflow si desea get más información sobre los detalles de las revisiones y las twigs de publicación.

Lanzamientos de funciones:

Las nuevas funciones se basan en la twig de desarrollo y se fusionaron de nuevo en la twig de desarrollo una vez completadas. Se crea una nueva twig de revisión para cada nueva versión de function.

Pasos:

  • Merge los cambios de la twig de la revisión actual en dev
  • La característica Merge se bifurca en el dev
  • Crear una nueva twig de revisión desde el desarrollador
  • Lanzamiento de una nueva twig de revisión
  • Fusionar nuevamente en el maestro

Notas:

Creo que la twig principal ya no es muy importante cuando decides mantener tus twigs de revisión. Creo que el esquema común de gitflow funciona de esa manera que destruye las twigs de su revisión y libera las twigs una vez que termina. Sus lanzamientos deben ser labeldos y, por lo tanto, accesibles.