¿Deberían sus mejores programadores tener que verificar el código de todos los demás en el control de fuente?

Una de las diferencias entre svn y git es la capacidad de controlar el acceso al repositorio. ¡Es difícil comparar los dos porque hay una diferencia de perspectiva sobre quién debería poder realizar cambios!

Esta pregunta trata sobre el uso de git como un repositorio centralizado para un equipo en una empresa en algún lugar. Suponga que los miembros del equipo tienen diferentes niveles de habilidad, como lo son en la mayoría de las empresas.

Git parece suponer que solo sus mejores programadores (los más productivos y experimentados) son de confianza para verificar el código. Si ese es el caso, se está tomando el tiempo de escribir el código para revisar el código de otras personas con el fin de registrarlo. ¿Vale la pena? Realmente quiero enfocar esta pregunta en cuál es el mejor uso del tiempo de su mejor programador, no en las mejores prácticas de control de versiones en general . Un corolario podría ser: ¿renuncian los buenos programadores si una parte importante de su trabajo es revisar el código de otras personas? Creo que ambas preguntas se reducen a: ¿vale la pena el examen de la productividad?

Dado que no está claro en su pregunta, solo quiero señalar que un flujo de trabajo de gatekeeper no es necesario con git. Es popular entre los proyectos de código abierto debido a la gran cantidad de colaboradores no confiables, pero no tiene tanto sentido dentro de una organización. Tiene la opción de dar acceso push a todos si lo desea.

Lo que la gente descuida en este análisis es que los buenos programadores pasan mucho tiempo lidiando con el código roto de otros programadores de todos modos. Si todos tienen acceso push, entonces la construcción se romperá, y los mejores programadores tienden a ser los que con frecuencia integran y rastrean a los culpables cuando las cosas se rompen.

Lo que pasa cuando todos tienen acceso push es que cuando algo se rompe, todos los que tiran obtienen una construcción rota hasta que se revierte o repara el compromiso ofensivo. Con un flujo de trabajo de gatekeeper, solo se ve afectado el gatekeeper. En otras palabras, solo afecta a uno de sus mejores programadores en lugar de a todos.

Podría resultar que la calidad de su código es bastante alta y la relación costo-beneficio de un controlador de acceso todavía no lo vale, pero no descuide los costos familiares. El hecho de que esté acostumbrado a esa pérdida de productividad no significa que no se incurra.

Además, no olvide explorar opciones híbridas. Con git es muy fácil configurar un repositorio al que cualquiera pueda presionar, y luego tener un guardián como un desarrollador senior, un probador o incluso un servidor de integración continua automatizada decidir si un cambio lo convierte en un segundo repositorio más estable y cuándo. De esa manera puedes obtener lo mejor de ambos mundos.

He trabajado en un trabajo donde los registros se limitaron solo a los líderes del equipo (y los líderes del equipo no pudieron registrar su propio código). Esto sirvió como nuestro mecanismo para hacer cumplir las revisiones de código, en gran parte debido a una serie de incidentes en los que se cometieron malas confirmaciones en la base de código incluso alrededor de registros cerrados y análisis estático.

Por un lado, hizo su trabajo. Se encontraron varias confirmaciones erróneas antes de ingresar a la base de código (y se olvidaron de inmediato durante una semana más o menos hasta que alguien se topó con ellas). Esto causó menos interrupciones en la base de código. Además, podría retrasar algunas cosas de formato / estructura antes de que se convirtieran en deuda tecnológica; atrapar algunos errores antes de que se conviertan en errores. Y me dio una gran sensación de lo que estaba haciendo mi equipo.

Por otro lado, me hizo entrar espontáneamente en rabia asesina cuando mi cambio de 3 líneas tardó 4 horas en comprometerse debido a que tenía que rastrear otra pista y hacer que cometieran el compromiso. Me empujó a hacer confirmaciones mucho menos frecuentes que las mejores prácticas, y ocasionalmente ocasionó problemas al tratar de rastrear los cambios en el desarrollador que los realizó.

Generalmente no lo recomendaría, excepto en los entornos más necesitados. Hacer las revisiones y los compromisos no fue tan malo en realidad. Sin embargo, tener mi propio proceso dependiente de los caprichos de los demás fue exasperante. Si no puede confiar en que sus desarrolladores verifiquen el código, obtenga mejores desarrolladores.

No. Cualquiera debería poder comprometerse.

Si tiene problemas con errores cometidos, no es la política de control de la fuente lo que está mal. Son los desarrolladores los que no se aseguran de que lo que él / ella comete funcione. Entonces, lo que debe hacer es definir pautas claras sobre qué comprometerse y cuándo.

Otra gran cosa se llama pruebas unitarias;)

Sin embargo, hay una alternativa.

a) Si utiliza el control de versión distribuido, puede crear repositorios principales en los que solo se pueden realizar solicitudes de extracción. De esa manera, todos los desarrolladores pueden obtener versiones de su propio código mientras usted obtiene el control de la rama principal.

b) En Subversion y similares, puede usar ramas donde cada desarrollador tiene que crear parches para llevarlo a la rama principal.

Debería echar un vistazo a proyectos como Gerrit, que permite a todos los desarrolladores insertar su código en la rama de 'revisión' y una vez que los desarrolladores principales / líderes estén contentos con estos cambios, pueden llevarlos a master / release.

Si no están contentos, pueden dejar comentarios junto a una línea de código, solicitar un parche actualizado, etc.

De esta manera, cualquier persona con un cambio pendiente puede sacarlo tan pronto como esté listo y solo las personas calificadas (con los privilegios de +2 correctos en Gerrit) podrán enviar ese código a prueba y luego a producción.

No, es un mal uso de tu mejor talento. Imagine una compañía editorial que toma a sus autores más exitosos y les hace editar; mala idea.

Debería haber revisiones de código, pero eso no significa que siempre sea un Sr. revisando el código de un jr. Eventualmente, se debe esperar que todos en el equipo lleguen al nivel en el que puedan contribuir con código con una orientación mínima. Pasan por los tres niveles de confianza:

1. Ninguno: quiero ver cada línea de código antes de que lo registres.
2. Algunos: déjame saber lo que estás haciendo y te enviaré comentarios
3. La mayoría: vaya a hacer su trabajo y solo pida ayuda cuando sea necesario.

Ventajas de liberar tu talento:

• centrarse en el diseño
• participación en el establecimiento de estándares de codificación y estrategias de aplicación (sin hacerlo manualmente todos ellos)
• abordar los difíciles problemas de codificación
• Proporcionar tutoría (sin haber aprobado cada línea de código)

Hay desarrolladores interesados ​​en una ruta de administración que prefieren no codificar todo el día; deja a los demás solos.

¿Vale la pena el comentario sobre la productividad?

Depende del "equilibrio" del equipo y de cómo se configuran las revisiones. Ambos son asuntos de gestión y trabajo en equipo, ninguna cantidad de magia tecnológica de control de versiones (centralizada o distribuida) puede tener una influencia sustancial en eso.

Si se hace mal , el impacto en la productividad, por supuesto, matará cualquier beneficio de la revisión; Sin embargo, la respuesta no es descartar la idea de las revisiones, sino descubrir cómo hacerlo correctamente .

Un enfoque para averiguar si sus comentarios están bien es utilizar la herramienta de seguimiento de problemas para rastrear el tiempo dedicado a las revisiones (algunas herramientas de revisión de código también lo permiten). Si descubre que las revisiones están tomando bastante tiempo, invierta un poco de esfuerzo para encontrar las razones y las formas de mejorar las cosas. Además, no estaría de más tener una relación 1: 1 regular con los miembros del equipo para descubrir posibles problemas con las revisiones de código.

Si los "mejores" programadores del equipo se ven obligados a pasar horas cavando en la basura incomprensible producida por los codificadores de mierda, la solución es despedir a los fabricantes de basura, no recurrir a la tecnología VCS.

• ^{En uno de los proyectos anteriores, me asignaron revisar los cambios de código realizados por un miembro del equipo con un rendimiento inferior permanente, en un componente que tardó casi una hora en crear y ejecutar pruebas. Comencé a leer los diferenciales y cuando noté un cambio no disponible, simplemente terminé la revisión, publiqué los comentarios necesarios y le pedí a la gerencia que se asegurara de que las solicitudes de revisión adicionales reciban una confirmación por escrito de que su código se compila. No hubo "solicitudes de revisión" desde entonces y pronto se fue.}

Por otro lado, cuando el equipo está razonablemente equilibrado, las revisiones de código son divertidas y educativas. En mi proyecto anterior, teníamos un requisito para la revisión del código al 100% y no tomó mucho tiempo ni fue una distracción. Se descubrieron errores a través de la revisión, y hubo debates sobre el estilo de codificación y las opciones de diseño, pero eso se sintió simplemente ... normal .

Si los cambios en el código se bloquean durante días ... semanas desde el control de calidad para la prueba "debido a las revisiones", estudiar los trucos de VCS sería la forma menos probable de resolver este problema. En cambio, uno centraría mejor su esfuerzo en descubrir problemas en la forma en que se organiza el proceso de revisión.

• <sup>- Oh, la integración de este cambio se retrasó mucho porque el crítico se enfermó repentinamente, qué desgracia.
  - ¡Hola! Diablos, ¿alguna vez pensaste en tener revisores de respaldo para tratar casos como ese?</sup>

Sí. Pero solo si está hablando del control de fuente distribuida. Con centralizado, depende.

Si solo hay pocos programadores, lleva poco tiempo. Ciertamente menos que las correcciones que se necesitarán para eliminar errores y deudas técnicas más adelante.

Si hay muchos programadores, puede delegar la tarea de revisión de código real a los tenientes y hacer que el desarrollador principal realice sus cambios (casi) sin lugar a dudas. Funciona para el kernel de Linux, no creo que haya proyectos de software más grandes ...

Nuevamente, si el proyecto es pequeño, el líder verá rápidamente quién da un buen código y quién produce un mal código. Rápidamente verá que J.Random escribe un código bueno que solo necesita verificar las decisiones arquitectónicas, mientras que el interno escribe un código malo que debe revisarse línea por línea antes de fusionarse. La retroalimentación generada de esta manera reducirá la carga de mantenimiento en el futuro y brindará experiencia de primera mano sobre lo que el pasante realmente aprenda y deba mantenerse en compañía. Obtener y fusionar una rama de otro gitrepositorio lleva literalmente una (dos) docenas de segundos, por lo general, leer los títulos de los mensajes de confirmación llevará más tiempo, por lo que después de saber en quién se puede confiar para escribir un buen código, fusionar el código de otras personas no es un problema.

La revisión de código no requiere necesariamente la atención de sus mejores programadores. En mi opinión, debería ser algo informal. Solo una segunda opinión o un segundo par de ojos en un código de un no novato antes de que se registre en producción. Ayuda a mitigar los descuidos importantes, al tiempo que ayuda a las personas a mejorar la codificación como oficio al exponerse a otras perspectivas de desarrollo.

Una especie de lite de programación de pares menos desagradable. En otras palabras, no debería tomar mucho tiempo y no debería tener que esperar a alguien por horas. Cualquier cosa en su proceso de desarrollo que implique que las personas esperen cosas es un desperdicio de dinero y paralizante para el impulso / la moral, en mi opinión.

Si la revisión del código pretendiera detener el 99.5% de los errores antes de que ingresaran a su base de código, en primer lugar, no tendría sentido un control de versiones sofisticado. Dicho esto, git es intimidante al principio, pero el uso general básico no es tan complicado y es altamente configurable. Debería poder detenerse durante unas horas para enseñar a todos cómo usarlo. Todos se comprometen. Todos menos los novatos más novatos revisan hasta que demuestran experiencia en algo.

Mientras los cambios que se envíen hayan sido revisados ​​por los 'mejores programadores', a cualquiera se le debería permitir enviar el código. La única persona que debería tener la capacidad de imponer el control en un repositorio es el ingeniero de lanzamiento, si esa persona existe.

Personalmente, estaría muy enojado si tuviera que revisar el código de otras personas.

Alguna entrada en su edición: No, no deberían. Las revisiones son un mal necesario, hacen más bien que mal y los buenos programadores lo apreciarán. Tal vez haya reticencias a participar en las revisiones porque no les gusta la idea de que los 'programadores menores' critiquen su código. Eso es muy malo. Serían mucho más propensos a dejar de fumar si la línea de código tiene errores constantemente y, en cambio, pasan su tiempo limpiando después de los envíos a medias de otras personas.

Sí, la reseña merece la pena. No estoy seguro de que haya un impacto en la productividad si el proceso de revisión es proporcional por las siguientes razones:

• Mantiene a los programadores honestos: si sabe que se revisará, las personas tomarán menos atajos
• Ayuda a los nuevos programadores a aprender de programadores con más experiencia.
• Ayuda a transferir conocimiento específico del dominio
• La revisión es otra puerta donde se pueden encontrar y solucionar errores y posibles problemas.

Al no permitir que todos los programadores usen el control de fuente, pierden la capacidad de rastrear cambios, deshacer errores y ver un historial razonable de cambios. No estoy seguro de que quieras que solo tus "mejores" programadores puedan registrarse en git.

Dicho esto, creo que es razonable que tengas a alguien que esté a cargo de ciertas ramas clave, como una rama de lanzamiento. En este caso, me imagino que todos pueden usar el repositorio git, pero solo ciertas personas se fusionan en la rama de lanzamiento. No estoy seguro de que haya una manera de aplicar esto en git, pero debería ser posible hacerlo mediante el proceso y simplemente verificando que nadie más se haya registrado.

La fusión en la rama de lanzamiento podría ser realizada por los "mejores" programadores, o más probablemente por personas competentes después de que se haya realizado una revisión suficiente.

Por qué los buenos programadores renuncian si una parte importante de su trabajo es revisar el código de otras personas?

Si no disfrutan del trabajo y se ven obligados a realizar esta actividad, entonces SÍ. Es muy probable que suceda. Como encontrar el próximo trabajo interesante para un buen desarrollador no es un gran desafío hoy en día.

¿Deberían sus mejores programadores tener que verificar el código de todos los demás en el control de fuente?

Absolutamente no. Es sin duda una pérdida de tiempo, a excepción de alguna lógica crítica que debe estar en estado sólido .

Sin embargo, los desarrolladores junior o con experiencia probablemente deberían estar en un período de prueba para la calidad del código , solo para estar seguros y asegurarse de que su código siga las pautas de desarrollo del equipo, al menos durante un par de semanas antes de obtener el privilegio de comprometerse.