¿Cómo puedo administrar adecuadamente las confirmaciones, prevenir conflictos de características y administrar dependencias con un VCS?

Se ha convertido en un factor molesto de trabajar con equipos grandes: ¿cómo se gestionan los registros y se evitan conflictos de características y se gestionan las dependencias con el control de origen correctamente?

Actualmente en mi lugar de trabajo utilizamos TFS 2008 y estamos migrando a TFS 2010 a principios de diciembre. En primer lugar, cualquier control de fuente es mejor que ninguno, pero ¿qué enfoque le ha resultado útil a alguien para evitar múltiples registros y deshacer todo el historial de control de fuente? ¿Es una troncal volátil la mejor manera de ir o ramificarse cuando implementa una nueva característica y una vez que está satisfecho, vuelva a fusionarse en la troncal?

Realmente me gustaría escuchar las experiencias de otras personas y quizás algunas mejores prácticas para administrar el control de código fuente.

TFS? ¡Corre por las colinas! Muévete lo más rápido que puedas. Hace muchas cosas diferentes, pero ninguna de ellas es tan buena como las mejores herramientas disponibles.

Pero en serio:

Una vez que tenga un sistema de control de versiones decente (SVN, GIT, etc.), recomendaría establecer reglas para la administración de sucursales, por ejemplo, cuándo crear sucursales, para qué, cuándo fusionar, quién y mucho más.

Hasta hace poco, utilizamos una única rama para el nuevo desarrollo ('troncal'). Para un lanzamiento, crearíamos una rama del tronco. El control de calidad final se realizaría en esa rama y una vez completado, lanzaríamos (estamos en lanzamientos mensuales).

Hemos cambiado al concepto de 'no hay basura en el maletero' para reducir el riesgo del horario. Este concepto contiene básicamente una regla por la cual crearía ramas para el trabajo de desarrollo separadas del tronco. Por ejemplo, podría tener una rama separada para una característica, para un pequeño equipo de desarrollo o similar. Utilizamos 'epopeyas' para describir una pequeña característica o parte liberable de una característica y crear una rama para cada épica. Al menos una vez al día, todos los cambios del tronco se fusionan en la rama épica. La clave es un buen soporte de combinación mediante el control de versiones o una herramienta separada (por ejemplo, combinación de tres vías). El control de calidad para la epopeya se haría en la rama épica. Una vez aprobada, la rama épica se fusionaría en el tronco y se ejecutaría una prueba de integración. Todavía tenemos sucursales para lanzamientos.

Con las ramas épicas, hemos reducido sustancialmente el riesgo del cronograma ya que ahora estamos en condiciones de liberarnos del tronco e incluir todas las epopeyas que se fusionaron con éxito en el tronco. Las epopeyas que no están completas pierden el autobús y harán el próximo lanzamiento (el próximo mes).

Por supuesto, esto puede funcionar solo en nuestro entorno. Es muy probable que tenga factores diferentes a los nuestros que influirán en cuáles son las mejores opciones para la gestión de sucursales.

Por ejemplo, si tiene un equipo con mucha gente trabajando de manera remota y no siempre conectado al servidor de control de versiones, entonces querrá usar un sistema de control de versiones que admita un modelo distribuido. GIT y algunos otros entrarían en esta categoría. Según mi conocimiento, TFS requiere una conexión al servidor para que los archivos se puedan escribir (¿arreglado en la versión 2010?).

Espero haber podido demostrar que no hay "una talla para todos". Comience con sus procesos en la gestión de sucursales en particular, determine los requisitos y finalmente seleccione la herramienta que mejor se adapte a sus necesidades. Tal vez sea TFS, tal vez no.

Abogo por una rama por característica, ya que permite una gran flexibilidad al decidir qué características enviar y cuáles diferir.

Lo bien que funcione en su situación depende de qué tan bien su VCS maneje las ramas y, lo que es más importante, la fusión. DVCS como Git & Mercurial hacen de este un ejercicio relativamente trivial. SVN menos. Me las arreglé para evitar TFS, aunque he leído mucho al respecto, me temo que en su mayoría no son complementarios. Si está atascado con TFS, realice una pequeña versión piloto basada en una función por rama y vea qué tan bien la fusión va por usted.

En primer lugar, un descargo de responsabilidad. Es difícil decir cuál es la mejor manera de administrar su fuente, ya que no somos conscientes de cómo su equipo o equipos trabajan día a día.

En general, es mejor trabajar en el tronco. Para cada versión principal, bifurque, de modo que las correcciones de errores para la versión de lanzamiento estén en la bifurcación que se puede fusionar nuevamente en el tronco. Todos los desarrolladores trabajan en la troncal y confirman el código regularmente (mínimo una vez al día).

Fusionar código nuevo en forma regular minimiza el dolor de fusionarse en grandes fragmentos de código en una fase de integración masiva. Al extender el dolor, lo sentirás menos. Cuanto más a menudo los miembros de su equipo confirmen el código, menos tendrán que fusionarse, porque siempre estarán en la última fuente.

Nunca he usado TFS 2008/2010, pero de lo que he leído en varios foros hay mucha negatividad sobre el uso de TFS para el control de versiones. Esto me ha hecho permanecer alejado de TFS desde ahora.

Actualmente estoy usando SVN y Git, los encuentro buenos tanto para equipos pequeños como para equipos de un solo hombre, pero personalmente no recomendaría SVN para un equipo grande.

He tenido mis ojos en PlasticSCM y lo intentaré en el futuro cercano.

Pido disculpas por no responder a su pregunta específica, habría publicado un comentario si mis privilegios me lo permitieran.

Creo que git hace que el resto del software de control de fuente sea obsoleto. La ramificación y la fusión son fáciles, y si hay problemas, se contiene, pero muchos problemas se evitan por la forma en que fomenta compromisos, ramificaciones y fusiones muy frecuentes. Cada usuario obtiene una copia completa del repositorio (esto se puede eliminar, pero yo trabajo con una base de código bastante grande y no es un problema), por lo que hay una especie de copia de seguridad automática. Los commits / push / pull son rápidos, y una de las cosas más importantes es que rompe el acoplamiento entre el nombre del archivo y el seguimiento. Los datos del archivo, incluidos el nombre y la ruta, son un blob de datos al que hace referencia un nodo de árbol, que es independiente de las rutas. Esto no solo es más seguro, sino que ciertos tipos de problemas de "nunca hagas eso" en algo como SVN no son un problema. Se puede usar como una configuración de concentrador tradicional o de igual a igual, y esos usos se pueden mezclar libremente en la misma configuración. Es criptográficamente seguro contra inserciones indocumentadas. Y es muy rápido.

Encuentro que lo uso en casa ahora todo el tiempo, solo para hacer un seguimiento de los documentos y sincronizarlos entre computadoras, porque es más fácil confirmar y enviar al servidor de archivos que hacer una copia de seguridad en el servidor o guardarlo allí.

El inconveniente es una curva de aprendizaje un poco empinada, ya que rompe todas las reglas a las que las personas están acostumbradas con el control de la fuente, de manera sutil, pero es una curva de aprendizaje empinada corta.

Algunas de las buenas prácticas que realmente seguimos y nos ayudaron mucho:

1) Asegúrese de no tener una copia editable del archivo en su local y siempre revise para editar. (Si a veces tiene que trabajar localmente, intente fusionarlo en el control de origen antes de EOD).

2) Etiquete sus archivos periódicamente, después de cualquier pequeño hito significativo.

3) Dé un buen pago o comentarios de registro. Esto ayudará cuando revises, a veces no tienes que abrir y comparar entre versiones.

¿Cómo gestiona los registros y evita conflictos de características y gestiona las dependencias con el control de origen correctamente?

Es, desde mi punto de vista, una tarea de dos factores: debe hacerlo desde el lado técnico (buena y fácil y a prueba de balas | fusión | auditoría, etc.) y gestión (política bien establecida "qué" "cuándo" "cómo"). Dos o incluso tres niveles de código de separación en ALM: algo así como "estable" (prueba de unidad aprobada), "inestable" (cada característica incluida terminada, pero la aplicación como producto tiene preguntas posteriores a la integración / sí, puede suceder /) y " trabajo en progreso". De esta manera, el administrador de proyectos adecuado puede disminuir la interferencia del trabajo del desarrollador por separado en común.

TFS (que no usé, usaré y no usaré) tiene algunos problemas fundamentales, AFAIK, en su aspecto de Source Control Management. Acabo de vincular aquí a algunos de los textos de James McKay:

• Team Foundation Server es Lotus Notes de las herramientas de control de versiones
• Fusiones sin base en el servidor de Team Foundation: ¿por qué?

Aquí hay un artículo muy bonito y reciente que compara y contrasta de manera clara y concisa algunas formas diferentes de trabajar con el control de código fuente: Control de código fuente bien hecho .

No creo que haya una estrategia / práctica recomendada para usar el control de código fuente. Los equipos maduros que han estado trabajando juntos durante mucho tiempo tienen mucho menos "dolor" en esta área, incluso si no siguen exactamente las "mejores prácticas" populares.

En cuanto a qué herramientas ... Casi no importa. Lo que realmente importa es que todos en su equipo estén en la misma página en cuanto al uso. Esto significa que todos deben comprender cómo se gestiona la línea de código y qué se espera que hagan. Y de todos modos, en la práctica, generalmente NO tiene la opción de elegir qué herramienta utilizar. Aproveche al máximo lo que esté usando.