¿Comprometerse temprano a menudo a menudo con revisiones de código?

Estoy buscando asesoramiento / experiencia / mejores prácticas sobre cómo lograr que un equipo de desarrolladores participe en un compromiso de compromiso temprano a menudo trabaje el paradigma mientras se beneficia de un process completo de revisión de código. Actualmente usamos la placa de revisión y es política que no se confíe ningún código a SCM sin una revisión por pares. Si bien adopto por completo las revisiones de códigos, parece ralentizar el process general y presenta un gran salto de velocidad a la idea de cometer compromiso temprano a menudo. Así que estoy pidiendo la experiencia de otros en lo que funciona y lo que no. ¿Te comprometes temprano y con frecuencia? ¿También usas revisiones de código? ¿Existe una forma obvia (que me falta) de que las dos ideas se puedan combinar?

Usamos la estrategia descrita en el Control de versiones para múltiples equipos ágiles , también funciona para un solo equipo, y funciona muy bien para nosotros.

A continuación, una ilustración para una iteración completa:

texto alternativo

Y una explicación muy 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.
  • Las fusiones de las twigs de tronco a trabajo se realizan todos los días.

Incluimos el "código revisado" en nuestra "Definición de Hecho" para que una historia no pueda ser publicada desde una twig de trabajo al tronco si el código no ha sido revisado. Sin embargo, las personas PUEDEN comprometerse temprano y con frecuencia en la twig de trabajo de su equipo (siempre que el código sea probado en unidades).

He utilizado este enfoque en varios proyectos, de varios tamaños (proyecto pequeño con un solo equipo para un gran proyecto con varios equipos), con diferentes VCS que incluyen Subversion con éxito. Y recomiendo leer todo el documento.

Todas las respuestas existentes proponen SCM distribuido. Esto es suficiente, pero no es necesario. Antes de la existencia de SCM distribuido, todavía era posible hacer esto.

Cada desarrollador debe trabajar en su propia sucursal (o puede preferir niveles más bajos de granularidad de sucursal, como por error o tarea (especialmente con progtwigción de pares, o desarrolladores que trabajan en muchas tareas a la vez). Esta decisión probablemente puede dejarse al desarrollador, si tiene un equipo maduro en lugar de confiar en ellos.

Los desarrolladores deben comprometerse temprano y con frecuencia en su propia sucursal: es como un sistema de respaldo, que realiza copys de security en puntos importantes y rastrea en qué estaba pensando cuando realizó el cambio.

Solo fusionar twigs revisadas por código nuevamente en la twig principal.

Los sistemas SCM distribuidos tienen muchos beneficios, y no quiero sonar como si estuviera en contra de ellos, pero si no está utilizando uno, no es excusa para no usar twigs por desarrollador.

Sugeriría cambiar a SCM distribuido. Podrías hacerlo para que cada miembro del equipo se comprometa con su propio repository. Cuando una característica está list para su revisión, el revisor recibe una notificación. Si el revisor acepta los cambios, los empuja / los fusiona en el repository estable (que es bastante sencillo).

Git y Mercurial (hg) son buenos ejemplos de SCM distribuidos

Use un sistema de control de versiones distribuidas. Uno de los mayores inconvenientes del control de versiones centralizado es que dificulta el "compromiso temprano, comprometerse a menudo". Los sistemas distribuidos lo alientan.

Debería echarle un vistazo a estos TechTalks de Google por Linus Torvalds: http://www.youtube.com/watch?v=4XpnKHJAok8

Linus explica por qué Distributed SCM (como Git o Hg) networkinguce la barrera psicológica para comprometerse, permitiendo así a los desarrolladores "comprometerse temprano, comprometerse a menudo" (usando twigs, gracias a que la fusión es tan simple en git).

Luego, la revisión por pares la realizan otros desarrolladores que conectan su twig con la de ellos, verifican lo que quieran comprobar y ejecutan sets de testings.

Finalmente, cuando todo el mundo esté contento, puede presionar a una sucursal "en vivo" o "previa a la transmisión" que debe ser mantenida por un equipo / persona preseleccionado.

Solo di algo como "¡No soy yo, es Linus diciéndolo!", Debería ayudar mucho 🙂

No puedo comentar eso, la estrategia con diferentes niveles de twigs (la respuesta de Pascal) es genial. Sin embargo, creo que una cosa que te gustaría aclarar es si "commit" equivale a "release". No debería.

Lo que hemos estado haciendo con un solo equipo por proyecto es que los desarrolladores se comprometan cuando están listos, pero el compromiso no debe romper el arnés de las testings unitarias (similar a la política "unidad probada" en el flujo de trabajo de la excelente respuesta de Pascal). Tenemos un server de testing que se ejecuta directamente desde el repository y se actualiza después de cada confirmación (lo hacemos con aplicaciones web; esto equivale a tener una compilation de su software cada compromiso o todos los días). Todos pueden acceder a ese server, incluidas las OP y las partes interesadas; de hecho, cualquiera que quiera puede jugar con él y proporcionar comentarios.

Ahora, las revisiones de código se asignan como trabajo explícito en la acumulación de sprints a cada elemento. Los elementos que no han sido revisados ​​por código no se consideran completados y no forman parte del incremento de envío que se lanza al final del sprint.

En este escenario, "confirmar" significa enviar su código al repository. Su código será visible para otros, también será visible trabajando en el server de testing (si no se rompe algo). La barrera psicológica es mucho más baja que si comprometerse significara enviar algo que se considera liberable. Aún así, cada desarrollador sabe que su código no se lanzará realmente antes de una revisión del código y que deberán usar un sombrero de aspecto divertido por el rest del día si envían un compromiso que rompa las testings unitarias.

En cuanto a las revisiones de código que toman time, bueno, este es un time bien empleado, el time invertido para una mayor calidad del producto. Bien vale la pena.

En primer lugar, ¿qué software de control de revisión está usando?

Dependiendo de su software RCS, puede lograr ambos objectives al mismo time. Por ejemplo, si está utilizando Subversion, cada desarrollador puede comprometerse temprano y con frecuencia a su propia twig de desarrollo privado. Se pueden requerir revisiones por pares antes de que las twigs de desarrollo se fusionen en el enlace troncal. Otros sistemas RCS pueden hacer algo similar.

Editar: Olvidé mencionar que si realmente está utilizando una estrategia de "commit early y often" con Subversion (con o sin twigs de desarrollo), los desarrolladores deben asegurarse de update su copy de trabajo con los cambios asignados al tronco igualmente a menudo. Este fue un problema que mi equipo tuvo durante un time después de migrar de VSS a Subversion. No estábamos acostumbrados a poder realizar fusiones de tres vías, y los desarrolladores actualizaban sus copys de trabajo con poca frecuencia (a veces less de dos veces al día), lo que normalmente requeriría una gran cantidad de fusiones manuales. Finalmente, todos se acostumbraron a ejecutar una svn update cada vez que se realiza una confirmación (tenemos un enlace posterior a la confirmación que actualiza una fuente RSS con confirmaciones nuevas) o, como mínimo, cada hora más o less. Como resultado, la mayor parte de la fusión se maneja automáticamente y la cantidad de trabajo manual requerido para fusionar los cambios de una twig de desarrollo en el tronco suele ser trivial. Esto también mantiene la diff entre el tronco y la twig de desarrollo lo más pequeña posible, lo que hace que la revisión del código sea más fácil (ya que normalmente nos centramos en la diff entre la twig y el tronco al revisar el código).

Si está buscando una mezcla, le sugiero que adopte una nueva política: el código producido en pares no requiere una revisión del código.

La progtwigción de pares proporciona el mismo valor que una revisión de código, permite una excelente transferencia de conocimiento y ayuda a los progtwigdores novatos (¡y en ocasiones a los progtwigdores experimentados!) A aprender rápidamente. Por supuesto, trae sus propios desafíos … ninguno de ellos insuperable.

Usa ramificación

Ejemplo:

Los desarrolladores trabajan en su propia twig en una twig de características. Revise los cambios cuando se combina con la twig de desarrollo de la línea principal. Fusionar en las twigs de desarrollo contra la twig de liberación cuando se realizan las versiones.

El equipo en el que estoy ha adoptado una política similar en la que no se compromete ningún código sin una revisión, pero la forma en que lo abordamos es hacer una progtwigción de pares casi exclusiva. Algunos podrían argumentar que eso no constituye una "revisión", pero sí garantiza que al less dos desarrolladores revisaron el código, el layout y la testing. En el check-in, ambos revisores ingresan sus iniciales para la trazabilidad.

No estoy seguro si eso funcionará con su panel de revisión, pero es algo que quizás quiera considerar.