¿Con qué frecuencia comprometer cambios al control de la fuente?

¿Con qué frecuencia debo enviar cambios al control de fuente? ¿Después de cada característica pequeña, o solo para funciones grandes?

Estoy trabajando en un proyecto y tengo una function a largo ploop para implementar. Actualmente, estoy comprometido después de cada pedazo de trabajo, es decir, cada sub-function implementada y corregida. Incluso me comprometo después de haber agregado un nuevo trozo de testings para alguna function después de descubrir un error.

Sin embargo, estoy preocupado por este patrón. En un día productivo de trabajo, podría hacer 10 commits. Dado que estoy usando Subversion, estos commits afectan a todo el repository, entonces me pregunto si de hecho es una buena práctica hacer tantos.

Cada vez que completo un "pensamiento completo" de código que comstack y ejecuta el check-in. Esto generalmente termina entre 15 y 60 minutos. A veces puede ser más largo, pero siempre trato de verificar si tengo muchos cambios de código que no me gustaría reescribir en caso de falla. También suelo asegurarme de que mi código comstack y me logging al final del día de trabajo antes de irme a casa.

No me preocuparía hacer "demasiados" commits / check-ins. Realmente apesta cuando tienes que reescribir algo, y es bueno poder revertirlo en pequeños incrementos por las dudas.

Cuando dices que te preocupa que tus "commits afecten a todo el repository", ¿te refieres al hecho de que el número de revisión de todo el repository aumenta? No sé cuántos bits utiliza Subversion para almacenarlo, ¡pero estoy seguro de que no te quedarán sin numbers de revisión! Muchos compromisos no son un problema. Puedes comprometerte diez veces más que el chico de al lado y no boostás tu huella de carbono en absoluto.

Una sola function o método debe nombrarse para lo que hace, y si el nombre es demasiado largo, está haciendo demasiado. Intento aplicar la misma regla a los check-in: el comentario de check-in debe describir exactamente lo que logra el cambio, y si el comentario es demasiado largo, probablemente cambie demasiado al mismo time.

Me gusta este pequeño artículo de Jeff Atwood: Check In Early, Check-in a menudo

Yo personalmente comprometo cada grupo lógico de código que está terminado / estable / comstack y trato de no dejar el día sin comprometer lo que hice ese día.

Si está realizando cambios importantes y le preocupa afectar a otros que trabajan en el código, puede crear una nueva, y luego volver a fusionarse en el enlace troncal una vez que se hayan completado los cambios.

Me comprometo cada vez que termino con una tarea. Eso generalmente toma 30 minutos a 1 hora.

No confíe código que realmente no funciona. No use su repository como una solución de respaldo.

En su lugar, haga una copy de security local de su código incompleto de forma automática. Time Machine se ocupa de mí, y hay muchos progtwigs gratuitos para otras plataforms.

Si su comentario de control de versión es más largo que una o dos oraciones, probablemente no esté cometiendo con suficiente frecuencia.

Sigo el mantra de código abierto (parafraseado): cometer temprano, comprometerse a menudo.

Básicamente cada vez que creo que agregué funcionalidades útiles (por pequeñas que sean) sin introducir problemas para otros miembros del equipo.

Esta estrategia de compromiso a menudo es particularmente útil en entornos de continuous integration, ya que permite realizar testings de integración en comparación con otros esfuerzos de desarrollo, lo que permite la detección temprana de problemas.

La regla práctica, que yo uso, es el check-in cuando el grupo de files que se está registrando puede ser cubierto por un único comentario de check-in.

En general, esto es para garantizar que los check-ins sean atómicos y que los comentarios puedan ser fácilmente digeridos por otros desarrolladores.

Es especialmente cierto cuando los cambios afectan a un file de configuration (como un file de context de spring o un file de configuration de struts) que tiene un amplio scope de aplicación. Si realiza varios 'grupos' de cambios antes de realizar el check-in, su impacto se superpone en el file de configuration, provocando que los dos grupos se fusionen entre sí.

No creo que deba preocuparse tanto por la frecuencia. Lo importante aquí es qué, cuándo y por qué. Decir que tienes que cometer cada 3 horas o cada 24 horas realmente no tiene sentido. Comprométase cuando tengas algo que comprometer, no lo hagas si no lo haces.

Aquí hay un extracto de mis mejores prácticas recomendadas para el control de versiones :

[…] Si está haciendo muchos cambios en un proyecto al mismo time, divídalos en partes lógicas y confírmelos en varias sesiones. Esto facilita mucho el seguimiento del historial de cambios individuales, lo que le ahorrará mucho time al intentar encontrar y corregir errores más adelante. Por ejemplo, si está implementando las características A, B y C y soluciona los errores 1, 2 y 3, eso debería dar como resultado un total de al less seis confirmaciones, una para cada característica y otra para cada error. Si está trabajando en una function grande o haciendo una amplia refacturación, considere dividir su trabajo en partes aún más pequeñas y realice una confirmación después de que se complete cada parte. Además, cuando implemente cambios independientes en múltiples modules lógicos, realice los cambios en cada module por separado, incluso si son parte de un cambio mayor.

Lo ideal es que nunca salga de su oficina con cambios no confirmados en su disco duro. Si está trabajando en proyectos donde los cambios afectarán a otras personas, considere usar una sucursal para implementar sus cambios y volver a fusionarlos en el tronco cuando haya terminado. Al realizar cambios en bibliotecas o proyectos de los que dependen otros proyectos (y, por lo tanto, otras personas), asegúrese de no romper sus comstackciones mediante la asignación de un código que no se compile. Sin embargo, tener un código que no comstack no es una excusa para evitar comprometerse. Usa twigs en su lugar. […]

Tu patrón actual tiene sentido. Tenga en count cómo utiliza este control de origen: ¿qué sucede si tiene que retroceder, o si desea hacer una diferencia? Los fragments que describe parecen exactamente el diferencial correcto en esos casos: el diff le mostrará exactamente qué cambió al implementar el error # (especificado en el logging de logging), o exactamente cuál fue el nuevo código para implementar una característica. La reversión, de manera similar, solo tocará una cosa a la vez.

También me gusta comprometerme después de terminar un pedazo de trabajo, que a menudo es varias veces al día. Creo que es más fácil ver lo que está sucediendo en compromisos pequeños que los grandes. Si le preocupan demasiadas confirmaciones, puede considerar crear una sucursal y volver a fusionarla en la troncal cuando finalice toda la function.

Aquí hay una publicación de blog relacionada: Horror de encoding : registrarse temprano, registrarse a menudo

Como han indicado otros, intente asignar un fragment lógico que sea "completo" lo suficiente como para que no entre en el path de otros desarrolladores (por ejemplo, comstack y pasa testings automatizadas).

Cada equipo / compañía de desarrollo debe definir qué es "lo suficientemente completo" para cada sucursal. Por ejemplo, puede tener twigs de function que requieren el código solo para build, un Troncal que también requiere código para pasar testings automatizadas, y tags que indican que algo ha pasado la testing de QA … o algo así.

No estoy diciendo que este sea un buen patrón a seguir; Solo estoy señalando que lo hecho está "hecho" depende de las políticas de su equipo / compañía.

En el momento en que piensas sobre eso.

(siempre que lo que ingrese sea seguro)

Depende de su sistema de código fuente y qué más tiene en su lugar. Si está usando Git, entonces comprométase cada vez que termine un paso. Uso SVN y me gusta comprometerme cuando termino una function completa, por lo tanto, cada una a cinco horas. Si estuviera usando CVS, haría lo mismo.

Estoy de acuerdo con varias de las respuestas: no ingrese el código que no comstackrá; use una sucursal personal o repository si su preocupación es tener una "copy de security" del código o sus cambios; registrarse cuando las unidades lógicas estén completas.

Otra cosa que agregaría es que dependiendo de su entorno, la tasa de check-in puede variar con el time. Por ejemplo, al principio de un proyecto de verificación después de que cada pieza funcional de un componente está completa, tiene sentido tanto para la security como para tener un historial de revisión (estoy pensando en casos donde los bits anteriores se refactorizan a medida que se desarrollan más adelante). Más adelante en el proyecto, por otro lado, la funcionalidad completamente completa se vuelve más importante, especialmente durante el desarrollo / testing de integración. Una mitad de integración o medio arreglo no ayuda a nadie.

En cuanto a la verificación después de cada corrección de error: ¡a less que la solución sea trivial, absolutamente! No hay nada más doloroso que encontrar que un cheque contenía tres correcciones y una de ellas necesita ser revertida. En la mayoría de los casos, parece que en esa situación el desarrollador corrigió tres errores en un área y desentrañando qué cambio se debe a la corrección de errores que es una pesadilla.

Me gusta realizar cambios cada 30-60 minutos, siempre que se compile limpiamente y no haya regresiones en las testings unitarias.

Bueno, podrías tener tu propia sucursal a la que puedas comprometer tantas veces como quieras, y cuando hayas terminado con tu característica, podrías unirla al tronco principal.

En la frecuencia de Commits, lo pienso de esta manera, ¿cuánto me dolería si mi disco duro se bloqueara y no hubiera cometido algo? La cantidad de este algo para mí es de aproximadamente 2 horas de trabajo.

Por supuesto, nunca comprometo algo que no comstack.

Al less una vez al día.

No tengo un límite de time específico por compromiso, tiendo a comprometerme una vez que ha pasado una testing y estoy contento con el código. No me gustaría cometer un código que no se comstack o está en un estado que no me gustaría volver a consultar en caso de fallo.

Debe equilibrarse el compromiso entre la security y la capacidad de recuperación, por un lado, y la facilidad de gestión del cambio para todo el proyecto, por el otro.

El mejor esquema que he usado tiene dos respuestas a esa pregunta.

Usamos dos repositorys completamente separados: uno era el repository de todo el proyecto y el otro era nuestro repository personal (estábamos usando RC en ese momento).

Nos registramos en nuestro repository personal muy regularmente, casi cada vez que guardaba sus files abiertos. Como tal, el repository personal era básicamente un gran buffer de deshacer de largo scope.

Una vez que teníamos un trozo de código que comstackríamos, probáramos bien y se aceptara que estaba listo para uso general, se verificó en el repository del proyecto.

Desafortunadamente, este sistema se basó en el uso de diferentes tecnologías de VCS para que fuera viable. No he encontrado ningún método satisfactorio para lograr los mismos resultados al usar dos de VCS del mismo tipo (por ejemplo, dos repositorys de subversión)

Sin embargo, he tenido resultados aceptables al crear twigs de desarrollo "personales" en un repository de subversión, comprobando en la twig con regularidad y luego fundiéndome en el tronco al finalizar.

Si está trabajando en una sucursal que no se lanzará, una confirmación es siempre segura.

Sin embargo, si lo está compartiendo con otros desarrolladores, cometer un código que no funciona es probable que sea un poco molesto (especialmente si se trata de un lugar importante). Normalmente solo confío el código que efectivamente está "funcionando", no es que haya sido probado completamente, pero me he cerciorado de que realmente comstack y no falla inmediatamente.

Si está utilizando un rastreador de errores integrado, puede ser útil realizar confirmaciones por separado si ha solucionado dos errores, de modo que el logging de confirmación pueda ir contra los errores correctos. Pero, de nuevo, a veces un cambio de código soluciona dos errores, entonces solo tienes que elegir contra cuál ponerlo (a less que tu sistema permita que un compromiso se asocie con varios errores)

Todavía creo en la frase "cometer a menudo, comprometerse temprano". Prefiero el VCS descentralizado como Mercurial y no hay ningún problema para comprometer varias cosas y empujarlo aguas arriba más adelante.

Esta es realmente una pregunta común, pero la verdadera pregunta es: ¿Puedes cometer un código sin terminar?

Cada vez que termine un código que funcione y no molestará a nadie más si lo obtienen en una actualización.

Y por favor asegúrate de comentar correctamente.

También me gusta registrarme regularmente. Eso es cada vez que he completado un paso hacia mi objective.

Esto es típicamente cada par de horas .

Mi dificultad es encontrar a alguien dispuesto y capaz de realizar tantas revisiones de código .

La política de nuestra compañía es que tenemos que revisar el código antes de poder verificar algo, lo que tiene sentido, pero no siempre hay alguien en el departamento que tenga time para realizar inmediatamente una revisión del código. Soluciones posibles:

  1. Más trabajo por cheque; less checkins == less revisiones.
  2. Cambiar la política de logging de la compañía. Si acabo de hacer algunas refactorizaciones y las testings unitarias funcionan todas verdes, ¿tal vez pueda relajar la regla?
  3. Deje de lado el cambio hasta que alguien pueda realizar la revisión y continuar trabajando. Esto puede ser problemático si al revisor no le gusta el código y tiene que networkingiseñarlo. Hacer malabares con las diferentes etapas de una tarea mediante cambios de "estantería" puede volverse desorderado.