Reparando un error mientras trabajaba en una parte diferente de la base del código

Esto me pasó al menos una vez. Estoy trabajando en alguna parte de la base del código y encuentro un pequeño error en una parte diferente, y el error me impide completar lo que estoy tratando de hacer actualmente. Arreglar el error podría ser tan simple como cambiar una sola declaración.

¿Qué haces en esa situación?

1. Solucione el error y confírmelo junto con su trabajo actual
2. Guarde su trabajo actual en otro lugar, corrija el error en una confirmación por separado, luego continúe su trabajo [1]
3. Continúa lo que se supone que debes hacer, confirma el código (incluso si rompe la construcción falla algunas pruebas), luego corrige el error (y La construcción hacer pasar las pruebas) en una confirmación por separado

[1] En la práctica, esto significaría: clonar el repositorio original en otro lugar, corregir el error, confirmar / empujar los cambios, arrastrar el compromiso al repositorio en el que está trabajando, fusionar los cambios y continuar su trabajo.

Editar: Cambié el número tres para reflejar lo que realmente quise decir.

He hecho 1 y 2 y al final, creo que prefiero # 2. Permite una mayor visibilidad para la corrección de errores, que puede ser importante para el control de calidad / notas de la versión / otros desarrolladores.

También me encontré con una situación en la que lo que pensé que era un error en realidad no lo era (sin decir que este es el caso aquí), y "arreglarlo" en una confirmación separada permitió que otro desarrollador se pusiera en contacto conmigo y explicara qué era qué en lugar de la "solución" simplemente perderse en mi check-in normal.

Generalmente voy por el # 2. Hace que el repositorio sea más limpio y hace que los registros sean más comprensibles. Odio cuando otros desarrolladores con los que trabajo cometen 15 correcciones de errores, características y refactorizaciones diferentes, todo en el mismo compromiso.

Además, dependiendo de cómo su equipo realice el seguimiento de defectos, es posible que deba buscar en el repositorio de defectos para asegurarse de que si el defecto que está arreglando está allí, marque el elemento completo. O puede que necesite crear un nuevo elemento y marcarlo como completo para que el sistema de defectos y el repositorio de código coincidan.

Yo hago el # 2. El uso de herramientas como git hace que sea trivial dividirlo en múltiples confirmaciones. Si no puede convencer a su equipo para que cambie a herramientas más modernas, git-svn le dará una porción decente de lo que usaría para resolver este problema. Esta publicación de blog ofrece una buena visión general del flujo de trabajo que está tratando de resolver: The Thing About Git

Elijo la opción no escrita (4): Divida su proyecto en ensamblajes / bibliotecas altamente especializadas, para que los errores no relacionados siempre estén en una ubicación diferente en el árbol de control de versiones.

Pido disculpas si lo anterior suena sarcástico, pero lo digo sinceramente. Me estremezco cada vez que veo un proyecto monolítico con cien formas y espacios de nombres que no tienen nada que ver entre sí. Solía ​​enfrentar este mismo dilema a menudo, preguntándome si y cómo debería romper los compromisos que estaban tratando con diferentes áreas funcionales; No fue hasta mucho después que me di cuenta de que tener todas estas áreas funcionales diferentes en un solo proyecto comprometible era, en sí mismo, un gran defecto de diseño.

Todavía encuentro errores totalmente no relacionados mientras trabajo en una función específica. Podría estar trabajando en la interfaz de usuario y encontrar un error en alguna lógica de negocios, y tengo que arreglarlo antes de poder continuar. La diferencia es que la lógica de negocios siempre está en un ensamblaje / proyecto diferente de la interfaz de usuario, por lo que todo lo que tengo que hacer es hacer un cambio muy pequeño al BL y proceder con un compromiso muy pequeño, luego seguir trabajando.

Tener una organización de proyectos realmente buena hace que no solo sea posible, sino que sea bastante fácil manejar estos problemas sin enterrar un cambio, romper la construcción o quedar atrapado en una rama / fusión irritante (incluso si está utilizando un DVCS no es totalmente indoloro) )

Si no tiene esta opción, es decir, es un desarrollador junior sin voz en la organización del proyecto, entonces simplemente iría con el # 1 y tomaría las notas apropiadas en el registro para que otras personas sepan por qué hizo lo que hizo. Si ha realizado un cambio importante , también presente un informe de error en su sistema de seguimiento de problemas para dar visibilidad de lo que ha solucionado y por qué.

Intento hacer el n. ° 2. Si realmente es un tema separado, es muy probable que esté en un archivo diferente al que está trabajando. Debería poder registrar el archivo como una confirmación por separado, incluso si está hecho en el mismo repositorio en el que está trabajando. Por todas las razones indicadas anteriormente, tiene sentido tener confirmaciones lo más independientes posible, para rastrear y revertir el cambio si es incorrecto.

Por lo general, solo soluciono el error y luego continúo en lo que estaba trabajando. Cuando es hora de confirmar, suponiendo que la corrección de errores esté en un archivo separado, hago dos confirmaciones simultáneas: la primera es una confirmación parcial que contiene solo la corrección de errores, y la segunda es todo lo demás.

Respuesta corta: # 2. Realmente desea que esa corrección de errores (con su nota en su rastreador!) Esté etiquetada en su historial de versiones como una entidad separada.

Respuesta más larga:

• Tropezar con el error
• Escriba una prueba o más demostrando el error
• Haz pasar la prueba
• Confirme solo ese cambio y sus pruebas ( git add --interactiveo darcs record -icomo lo haga su VCS) (*)
• Vuelve a lo que estaba haciendo.

(*) En CVS (no, de verdad) a veces tengo un árbol limpio y una copia en la que trabajo. Luego uso una combinación, winmerge, en mi caso, para extraer solo la corrección de errores en el árbol limpio para que pueda cometerlo por separado. (La otra opción es cambiar el nombre de los archivos modificados cvs updatey fusionarlos. Cuando haya confirmado el cambio, elimine el archivo y cambie el nombre de los archivos movidos a sus nombres originales).

Sin embargo, algo a tener en cuenta es que generalmente solo encuentro errores que están relacionados con lo que estoy trabajando o que están muy cerca. Me sorprendería si fuera normal que las personas encuentren errores en partes no relacionadas de la base de código: ¿por qué leen código no relacionado al corregir el error? (¡Sí, esto es exactamente lo contrario de lo que dice Aaronnaught!)

Arreglo el error y hago commits separados , uno para cada arreglo / característica.

La mayoría de las veces, los cambios no están en el mismo archivo, por lo que es fácil separar las confirmaciones. Si los cambios están en el mismo archivo, uso TortoiseHg (una interfaz gráfica de usuario de interfaz gráfica de usuario) para seleccionar con precisión los diferenciales que quiero confirmar (creo que es posible hacerlo en la línea de comandos con la extensión Record , pero es menos conveniente )

Algunas personas usan las Colas Mercuriales para aislar las correcciones menores mientras trabajan en una función. Las correcciones menores se apilan en el MQ, y cuando la característica está terminada y confirmada, el contenido de la cola también se confirma (un conjunto de cambios para cada entrada en la cola).

Usualmente hago el # 2. Guardar mi trabajo actual en otro lugar: esto generalmente funciona bien creando un parche. También algunos IDEs (IntelliJ) permiten cambios de estantería, que es exactamente eso: guardar el trabajo actual en otro lugar.

Lo que hago depende de si el error realmente está en una parte diferente. Si es así, registrarlo es independiente de mis cambios a medio hacer. Hago el cambio, construyo esa parte diferente para asegurarme de que no he cometido algún error trivial, lo pruebo (tal vez haciendo lo que me impedía hacer) y verifico al explicar lo que estaba sucediendo. A menudo haré un elemento de trabajo para ello, y después del registro / resolución, asignaré el WI a un probador. Luego vuelvo a lo que estaba haciendo.

Si todo está mezclado con los archivos que he cambiado a medias, no puedo construir y probar esa parte de forma independiente. En ese caso, hago otro WI para ello y cuando reviso mis cambios resuelvo ambos WI con el mismo registro, lo que generalmente va en contra de mis principios, pero se aplica bien en este caso.

En ambas circunstancias, la corrección de errores termina probada por mí, verificada con algún tipo de rastro para que la gente entienda por qué cambié ese código al azar ese día, y se asigna un WI a otra persona para confirmar que es correcto ahora.

Hacemos el # 1. # 2 suena bien, pero no puedo decir que hayamos tenido problemas con # 1 que solucionaría # 2.

Un factor adicional en mi empresa es que creamos aplicaciones web, y nuestras pruebas se realizan casi por completo a través de la interfaz web, más o menos, lo que las personas llaman pruebas funcionales en lugar de pruebas unitarias. Tenemos todas las pruebas aprobadas antes de registrarnos. Dividir las confirmaciones en bits más pequeños significaría ejecutar las pruebas una vez para cada bit, y eso tomaría más tiempo. Me encantaría tener un conjunto de pruebas mucho más rápido, lo que nos permitiría realizar confirmaciones más pequeñas, pero simplemente no lo tenemos.