subversion source software easiest control best version-control

version-control - source - subversion vs git 2018



¿Con qué frecuencia para cometer cambios al control de la fuente? (26)

Al menos una vez al día.

¿Con qué frecuencia debo realizar cambios en el control de código fuente? ¿Después de cada pequeña característica, o solo para grandes características?

Estoy trabajando en un proyecto y tengo una característica a largo plazo para implementar. Actualmente, me comprometo después de cada parte del trabajo, es decir, cada subcaracterística implementada y la corrección de errores. Incluso me comprometo después de haber agregado una nueva parte de las pruebas para alguna característica 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 compromisos. Dado que estoy usando Subversion, estos compromisos afectan a todo el repositorio, así que me pregunto si es realmente una buena práctica hacer tantos.

Bueno, podría tener su propia rama con la que puede comprometerse con la frecuencia que desee y, cuando haya terminado con su función, podría fusionarla con el tronco principal.

En la frecuencia de los Compromisos, pienso de esta manera, cuánto dolor tendría para mí si mi disco duro se estrellara y no hubiera cometido algo. La cantidad de este algo para mí es aproximadamente 2 horas de trabajo.

Por supuesto, nunca cometo algo que no compile.

Cada vez que completo un "pensamiento completo" del código que compila y ejecuta, me registro. Esto usualmente termina siendo entre 15-60 minutos. A veces puede ser más largo, pero siempre trato de verificar si tengo muchos cambios de código que no querría reescribir en caso de falla. Por lo general, también me aseguro de que mi código se compile y que me registre al final del día laboral antes de irme a casa.

No me preocuparía hacer "demasiados" confirmaciones / registros. Realmente apesta cuando tienes que reescribir algo, y es bueno poder revertir en pequeños incrementos por si acaso.

Como han dicho otros, intente enviar un fragmento lógico que esté "completo" lo suficiente como para que no se vea afectado por otros desarrolladores (por ejemplo, construye y pasa pruebas automatizadas).

Cada equipo / compañía de desarrollo debe definir qué es "lo suficientemente completo" para cada sucursal. Por ejemplo, puede tener ramas de características que solo requieren el código para construirse, un Tronco que también requiere que el código pase las pruebas automatizadas y etiquetas que indiquen que algo pasó la prueba de control de calidad ... o algo por el estilo.

No estoy diciendo que este es un buen patrón a seguir; Solo estoy señalando que la forma en que se hace "depende" de las políticas de su equipo / compañía.

Cuando dice que le preocupa que sus "confirmaciones afecten a todo el repositorio", ¿se refiere al hecho de que el número de revisión de todo el repositorio aumenta? No sé cuántos bits de Subversion utiliza para almacenarlo, pero estoy bastante seguro de que no te quedarás sin números de revisión. Muchas confirmaciones no son un problema. Puede comprometerse diez veces más seguido que el chico de al lado y no aumentará su huella de carbono en absoluto.

Una sola función o método debe ser nombrado por lo que hace, y si el nombre es demasiado largo, está haciendo demasiado. Intento aplicar la misma regla a los registros: el comentario de registro debe describir exactamente lo que logra el cambio, y si el comentario es demasiado largo, es probable que esté cambiando demasiado a la vez.

Debe equilibrar el compromiso entre seguridad y capacidad de recuperación por un lado y la facilidad de gestión de cambios para todo el proyecto por otro.

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

Utilizamos 2 repositorios completamente separados: uno era el repositorio de todo el proyecto y el otro era nuestro propio repositorio personal (estábamos usando rcs en ese momento).

Nos registraríamos en nuestro repositorio personal con mucha frecuencia, casi cada vez que guardara sus archivos abiertos. Como tal, el repositorio personal era básicamente un gran búfer de deshacer de largo alcance.

Una vez que tuvimos un trozo de código que se compilaba, se probó bien y se aceptó que estaba listo para su uso general y se registró en el repositorio del proyecto.

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

Sin embargo, he tenido resultados aceptables al crear sucursales de desarrollo "personal" en un repositorio de subversion: me registré en la sucursal regularmente y luego me fusioné con el tronco al finalizar.

Depende de su sistema de código fuente y de lo que tenga instalado. Si estás usando Git, confía cuando termines un paso. Uso SVN y me gusta comprometerme cuando finalizo una función completa, por lo tanto, cada una a cinco horas. Si estuviera usando CVS, haría lo mismo.

El momento en que lo piensas.

(Siempre y cuando lo que se registra sea seguro)

Estoy de acuerdo con varias de las respuestas: no ingrese el código que no se compilará; use una sucursal o repositorio personal si su inquietud es tener una "copia de seguridad" del código o sus cambios; comprobar cuando las unidades lógicas están completas.

Otra cosa que agregaría es que dependiendo de su entorno, la tasa de registro puede variar con el tiempo. Por ejemplo, al inicio de un proyecto, el registro después de que se complete cada pieza funcional de un componente tiene sentido tanto para la seguridad como para tener un historial de revisión (estoy pensando en casos en que los bits anteriores se refactan a medida que se desarrollan los posteriores). Más adelante en el proyecto, por otra parte, la funcionalidad completamente completa se vuelve más importante, especialmente durante el desarrollo / prueba de la integración. Una media integración o media corrección no ayuda a nadie.

En cuanto al control después de cada corrección de errores: a menos que la corrección sea trivial, ¡absolutamente! Nada es más doloroso que encontrar que un cheque contenía tres correcciones y que una de ellas debe ser revertida. La mayoría de las veces, parece que en esa situación el desarrollador corrigió tres errores en un área y descubrió qué cambio se dirige a qué corrección de errores es una pesadilla.

La regla de oro, que yo uso, es el registro cuando el grupo de archivos que se están registrando puede ser cubierto por un solo comentario de registro.

Esto generalmente se hace para asegurar que los registros de entrada sean atómicos y que los comentarios puedan ser fácilmente digeridos por otros desarrolladores.

Es especialmente cierto cuando los cambios afectan a un archivo de configuración (como un archivo de contexto de Spring o un archivo de configuración de struts) que tiene un amplio alcance de aplicación. Si realiza varios ''grupos'' de cambios antes de registrarse, su impacto se superpone en el archivo de configuración, lo que hace que los 2 grupos se fusionen entre sí.

Me comprometo cada vez que termino con una tarea. Por lo general, toma 30 minutos a 1 hora.

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

No cometas código que en realidad no funciona. No utilice su repositorio como una solución de copia de seguridad.

En su lugar, haga una copia de seguridad de su código incompleto localmente de manera automatizada. Time Machine me cuida, y hay muchos programas gratuitos para otras plataformas.

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

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

[...] Si está realizando muchos cambios en un proyecto al mismo tiempo, divídalos en partes lógicas y confírmelos en varias sesiones. Esto hace que sea mucho más fácil rastrear el historial de cambios individuales, lo que le ahorrará mucho tiempo cuando intente encontrar y corregir errores más adelante. Por ejemplo, si está implementando las características A, B y C y corrigiendo los errores 1, 2 y 3, esto debería dar como resultado un total de al menos seis confirmaciones, una para cada característica y una para cada error. Si está trabajando en una función grande o haciendo una refactorización extensa, considere dividir su trabajo en partes aún más pequeñas, y haga un compromiso después de que se complete cada parte. Además, cuando se implementan cambios independientes en múltiples módulos lógicos, confirme los cambios en cada módulo por separado, incluso si son parte de un cambio mayor.

Lo ideal es que nunca salga de su oficina con cambios no comprometidos en su disco duro. Si está trabajando en proyectos donde los cambios afectarán a otras personas, considere usar una rama para implementar sus cambios y fusionarlos nuevamente en el tronco cuando haya terminado. Al realizar cambios en bibliotecas o proyectos que dependen de otros proyectos y, por lo tanto, de otras personas, asegúrese de no romper sus compilaciones al cometer código que no se compilará. Sin embargo, tener un código que no se compile no es una excusa para evitar cometer. Use ramas en su lugar. [...]

No tengo un límite de tiempo específico por compromiso, tiendo a cometer una vez que una prueba ha pasado y estoy contento con el código. No cometería ningún código que no compile o esté de otra manera en un estado en el que no me sentiría bien en volver en caso de fallo

Personalmente confío cada grupo lógico de código que está terminado / estable / compila y trato de no salir del día sin cometer lo que hice ese día.

Si está realizando cambios importantes y le preocupa afectar a otras personas que trabajan en el código, puede crear una nueva rama y luego fusionarse nuevamente en el tronco una vez que se completen los cambios.

Si está trabajando en una sucursal que no se lanzará, un compromiso siempre es seguro.

Sin embargo, si lo está compartiendo con otros desarrolladores, es probable que cometer un código que no funciona sea un poco molesto (especialmente si se encuentra en un lugar importante). Normalmente solo confirmo un código que efectivamente está "funcionando", no que se haya probado completamente, sino que he comprobado que realmente se compila y no falla de inmediato.

Si está utilizando un rastreador de errores integrado, puede ser útil hacer confirmaciones separadas si ha solucionado dos errores, de modo que el registro de confirmación pueda ir en contra de los errores correctos. Pero, de nuevo, a veces, un cambio de código corrige dos errores, por lo que solo tiene que elegir en cuál de ellos (a menos que su sistema permita que un compromiso se asocie con varios errores)

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

Siempre que termines un código que funcione y no arruine a nadie más si lo consiguen en una actualización.

Y por favor asegúrese de comentar correctamente.

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

Básicamente siempre que pienso que he agregado una funcionalidad útil (aunque pequeña) sin presentar problemas para otros miembros del equipo.

Esta estrategia de compromiso frecuente es particularmente útil en entornos de integración continua, ya que permite realizar pruebas de integración frente a otros esfuerzos de desarrollo, lo que proporciona una detección temprana de problemas.

También me gusta comprometerme después de terminar una parte del trabajo, que a menudo es varias veces al día. Creo que es más fácil ver lo que está pasando en los compromisos pequeños que en los grandes. Si está preocupado por demasiadas confirmaciones, puede considerar crear una rama y fusionarla de nuevo con el tronco cuando haya finalizado toda la función.

Aquí hay una publicación relacionada con el blog: Codificación del horror: check in temprano, check in a menudo

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

Esto suele ser cada dos horas .

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

Nuestra política de la compañía es que necesitamos tener una revisión del código antes de que podamos registrar algo, lo que tiene sentido, pero no siempre hay alguien en el departamento que tenga tiempo para realizar una revisión del código de inmediato. Soluciones posibles:

  1. Más trabajo por check in; menos registros == menos comentarios.
  2. Cambiar la política de registro de la empresa. Si acabo de hacer un poco de refactorización y las pruebas de la unidad se ejecutan en verde, ¿tal vez pueda relajar la regla?
  3. Determine el cambio hasta que alguien pueda realizar la revisión y continúe trabajando. Esto puede ser problemático si al revisor no le gusta el código y tiene que rediseñar. Hacer malabarismos con las diferentes etapas de una tarea mediante cambios de "estantería" puede volverse desordenado.

Todavía creo en la frase ''cometer a menudo, cometer temprano''. Prefiero VCS descentralizado como Mercurial y no hay problema para cometer varias cosas y empujarlas hacia arriba más adelante.

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

Tu patrón actual tiene sentido. Tenga en cuenta cómo usa este control de origen: ¿qué sucede si tiene que revertir o si desea realizar una diferencia? Los fragmentos que describe parecen ser exactamente el diferencial correcto en esos casos: el diff le mostrará exactamente qué cambió al implementar el número de error (especificado en el registro de registro), o exactamente cuál fue el nuevo código para implementar una función. La reversión, de manera similar, solo tocará una cosa a la vez.