Describa su flujo de trabajo de usar control de versiones (VCS o DVCS)

Me gustaría aprender el flujo de trabajo de otras personas cuando utilizo vcs o dvcs.

Por favor describa su estrategia para manejar las siguientes tareas:

  • Implementar una característica
  • Corrección de errores (durante el desarrollo y la aplicación implementada)
  • Revisión de código
  • Código de refactorización (revisión de código postal)
  • Incorporar parches
  • Lanzando la versión más nueva de su aplicación (escritorio, web, mobile, ¿los trataría de manera diferente?)

Siéntase libre de organizar su respuesta no agrupada por las tareas, sino agrupada por lo que considere relevante, pero organícela mediante VCS / DVCS (no las mezcle).

Gracias.

La característica principal que todo VCS usa para las diversas tareas que menciona es la ramificación : la capacidad de aislar un esfuerzo de desarrollo de forma queueborativa. Dado que es un VCS central, varios desarrolladores pueden queueborar en una misma twig, con lockings pesimistas u optimistas en los files, para desarrollar una historia paralela.

Pero ser un VCS tiene dos efectos principales en la ramificación:

  1. Tiende a desalentar las confirmaciones, porque una vez que se compromete un file, influirá inmediatamente en el espacio de trabajo de otras vistas con la misma configuration (es decir, "trabajando en la misma twig").
    ~ El process de "publicación" es uno activo, con consecuencias inmediatas,
    ~ mientras que la parte "consumidora" (actualización de su área de trabajo) es pasiva (se ve obligado a ocuparse de los cambios publicados por otros inmediatamente después de la actualización de su área de trabajo)
  2. Funciona bien para el flujo de trabajo de combinación lineal (es decir, "solo se fusiona de la twig A a la twig B, no mezcla las fusiones en ambas direcciones" – A a B a A a B …). Las fusiones son triviales, todas las modificaciones de A simplemente se transfieren a B

Ahora:

Implementando una característica

Cualquier VCS hará eso haciendo una twig, pero lo que me sorprendió mucho es que una twig "característica" no es fácil:
* la característica puede volverse demasiado complicada
* puede estar listo a time para la próxima versión
* solo es posible que deba combinarse una parte de la misma en la twig de desarrollo principal
* puede depender de otras características que aún no se han completado

Por lo tanto, debe tener cuidado en la forma en que administra su twig de características y sus compromisos: si están estrechamente relacionados con la misma function, funcionará bien (fusionará todo de nuevo en su twig de desarrollo principal cuando lo necesite). . De lo contrario, las fusiones parciales no son fáciles con esas herramientas.

Corregir errores

La diferencia entre la corrección de errores durante el desarrollo y después del lanzamiento es que, en el primer caso, a menudo puede hacerlo de forma lineal en la misma twig, ya que en este último caso deberá establecer una twig de corrección de errores y decidir qué errores tendrá. necesidad de back-port a su twig de desarrollo actual.

Revisión de código

Se utiliza mejor con herramientas externas ( como Crucible, por ejemplo), y usa funciones de VCS como censuras o annotations extensamente, para asignar mejor las correcciones de código después de una revisión.

Código de refactorización (revisión de código postal)

Si la refactorización es menor, puede continuar en la misma twig. Pero si es grande, se debe configurar una twig especial, con testings unitarias antes de comenzar dicha refactorización.

Incorporar parches

Mismo comentario que el último punto. Si el parche es grande, se necesita crear una twig.

Liberando la versión más nueva de tu aplicación

Un VCS solo lo llevará tan lejos a la hora de lanzar su aplicación, porque no es una herramienta de administración de versiones.
Necesitará identificar previamente una versión para ser lanzada (label), pero luego viene el process de implementación que involucra:

  • detener lo que se está ejecutando actualmente
  • copyndo los nuevos files
  • desplegándolos (actualizando la database sql, webapp, …)
  • crear instancias de todos los files de configuration (con los valores correctos, direcciones, número de puerto, routes, …)
  • reinicio (y si su sistema está compuesto por varios componentes, ¡reinícielos en el order correcto!)

Las cosas key con VCS y administración de lanzamientos son:

  • no están muy bien adaptados para almacenar binarys que se lanzarán, lo que significa que los necesita para build su aplicación, no para almacenar el ejecutable resultante
  • no siempre son bienvenidos en el entorno de producción (donde las restricciones de security limitan el acceso a la escritura, así como la cantidad de herramientas que se ejecutan en esas plataforms, básicamente herramientas de supervisión y generación de informes)

El mecanismo de liberación también influye en las dependencies binarias:

  • para dependencies binarias externas, probablemente use mecanismos como maven para get revisiones fijas de bibliotecas externas
  • pero para las dependencies internas, cuando no está desarrollando solo una aplicación, sino varias que dependen una de otra, necesita saber cómo hacer reference a los files binarys producidos por las otras aplicaciones (dependencies binarias internas) y, por lo general, no se almacenarán. en su VCS (especialmente en la fase de desarrollo, donde puede producir muchos lanzamientos diferentes para que otras aplicaciones puedan usar)

También puede elegir estar en dependencies de origen (y get todas las fonts de los otros proyectos internos que necesita para su propio), y un VCS está bien adaptado para eso, pero no siempre es posible / práctico recomstackr todo.

La principal diferencia con un DVCS (Distributed Version Control) de un VCS, es que está hecho (por la propia naturaleza de su trabajo distribuido) para hacer una cosa, y una cosa bien:

fusionar

Entonces, las tareas que menciona pueden verse desde ese ángulo.
Se seguirán realizando sucursales, pero no todos serán visibles por otros desarrolladores. Muchos de ellos no saldrán de tu repository local .

Ser un DVCS tiene dos efectos principales en la fusión:

  1. te comprometes tantas veces como quieras. Esos compromisos no son inmediatamente visibles para otros (es decir, "no tendrán que fusionarlos inmediatamente después de la próxima actualización de su área de trabajo").
    ~ el process de publicación es pasivo: los repositorys pueden ignorar sus impulsos.
    ~ la parte "consumidora" es activa: puede examinar qué se le ha enviado antes de fusionarla con su sucursal y decidir qué desea fusionar y de quién (y no solo porque todos están trabajando en un "mismo twig").
  2. funciona bien para cualquier flujo de trabajo de fusión (parcial, entrecruzado, recursivo, …) El DAG (Gráfico Acíclico Direccionado ) usado a menudo para registrar el historial por aquellos DVCS (al less Git y Mercurial) hace que sea más fácil encontrar lo que ha ya se ha fusionado y encuentra el ancestro común. Esa es una diferencia importante entre SVN y sus equivalentes DVCS , pero también hay otros .

Ahora:

Implementar una característica

Como detallo en mi respuesta de CVCS (Central VCS) , la dificultad detrás de una twig de "característica" es que muchas subcaracterísticas terminan entrelazadas.
Aquí es donde brillará DVCS, ya que le permitirán reorganizar su historial local (como en "no empujado todavía") (sets de cambios para Mercurial, SHA1 commits ofr Git), para facilitar fusiones parciales, o creaciones de subcaracterísticas de sucursales.

Corregir errores

Casi puede crear una twig por arreglo de errores si lo desea. La idea es asegurarnos de que se identifique una solución de errores mediante un set lineal simple de commmits fusionados en la twig de desarrollo (o la twig de mantenimiento si se libera).
Prefiero asegurarme de volver a establecer la base de la twig de reparación de errores en la parte superior de la twig de desarrollo (para asegurarme de que mis correcciones siguen siendo compatibles con cualquier trabajo que se haya realizado en paralelo en dicha twig principal), antes de fusionar esa twig de desarrollo con la solución de errores uno (fusión de avance rápido: la twig principal ahora hace reference a todas las correcciones)

Revisión de código

La function de anotación o culpa aún está allí para ayudar a asignar las tareas durante una revisión de código, pero esta vez, todos los desarrolladores no están necesariamente en un sitio (ya que es un * Distributed * VCS) y no con el mismo esquema de identificación ( no usar el mismo LDAP por ejemplo).

Una forma de DVCS para organizar la revisión del código es enviar nuevos cambios a un repository de revisión de código especial, que:

  • rechazar aquellos compromisos si no responden a los criterios de calidad requeridos
  • aceptarlos (combinarlos con el repository de revisión de código) e insertlos en un repository nuevo (utilizado para varias testings, por ejemplo)

Código de refactorización (revisión de código postal)

Se realizan en el repository local del desarrollador, en una sucursal (ya que es tan fácil fusionarlo de nuevo)

Incorporar parches

El mismo process que la última sección.

Lanzando la versión más nueva de su aplicación (escritorio, web, mobile, ¿los trataría de manera diferente?)

El process de lanzamiento real simplemente se inicia mediante una versión especial identificada (label) de su software. (El rest del "process de gestión de versiones", que es la parte de implementación y configuration, se detalla en la respuesta de CVCS )
La pregunta es, con un DVCS:
"¿De qué repository vendrá esa versión oficial de su software?"

Necesita establecer un repository "central" o más bien "oficial" que desempeñará el papel de:

  • Repo para las versiones que se lanzarán
  • Repo para nuevos repositorys quería contribuir

Por lo tanto, puede servir tanto para fines de publicación como para nuevos fines de desarrollo.