¿Cuál es la forma más efectiva / eficiente de desarrollar una aplicación con varias personas sin control de fuente?

Introducción a mi situación.

Trabajo para una pequeña empresa de desarrollo web. Tenemos un equipo de cuatro desarrolladores de ASP.NET, incluido yo. Casi todos nuestros proyectos (> 98%) son proyectos de una sola persona que demoran entre 1 y 4 semanas en completarse. No utilizamos fuente o control de versiones. Lo único que tenemos es una carpeta compartida en un servidor local que contiene la última fuente (== la fuente de la aplicación en vivo) de todos los proyectos.

En las raras ocasiones en que necesitamos trabajar en el mismo proyecto con más de una persona, usamos ... Más allá de comparar. Una o dos veces al día, los desarrolladores se preguntan si tienen una versión que compila y luego sincronizan su código con Beyond Compare. Cuando solo dos personas están trabajando en un proyecto, esto funciona "bastante bien", pero tan pronto como un tercer desarrollador ingresa al proceso, se convierte en una basura inmanejable. Especialmente cuando todos comienzan a hacer cambios en la base de datos.

Yo (y uno o dos de mis colegas desarrolladores) ya le hemos dicho a mi jefe varias veces que deberíamos comenzar a usar alguna forma de control de fuente y versión como Git, Mercurial o TFS (nuestro jefe tiene una mentalidad de Microsoft). Desafortunadamente, mi jefe no ve la ventaja de cambiar a un sistema de control de fuente y versión, porque a sus ojos todo funciona bien ahora y no quiere invertir tiempo y dinero en establecer un nuevo sistema y asegurarse de que todos sabe cómo usarlo. Incluso después de explicarle las ventajas (como la colaboración simplificada, las diferentes versiones de una aplicación, la forma más segura de cambiar el código, ...) para él, todavía no cree que sea algo que necesitamos.

De los cuatro desarrolladores, solo dos (incluido yo) tienen experiencia con el control de código fuente (Git). Y esa experiencia es muy limitada. Sé cómo clonar un repositorio de Github en mi computadora, hacer algunos cambios, confirmarlos y devolverlos a Github. Eso es.

Explicación de mi problema / inquietud

En unas pocas semanas vamos a comenzar a trabajar en un proyecto bastante grande para nuestros estándares. Probablemente le tomará de 2 a 3 desarrolladores unos meses completarlo. Seré el líder del proyecto (gerente de proyecto y desarrollador principal) y seré responsable de todo. He tenido muchos problemas con nuestro enfoque Beyond Compare y no quiero tomar este camino con este gran proyecto que será mi responsabilidad.

Como dudo que podamos

• configurar nuestro propio servidor Git,
• enseñar a todos a trabajar con Git y
• emplear a Git con éxito en este gran proyecto,

Me interesa si alguno de ustedes conoce algunas buenas maneras de permitir que varias personas colaboren en el mismo proyecto sin usar el control de fuente o versión.

Actualizar

Agradecería a todos por sus respuestas y comentarios. Aquí está el plan:

1. Tenga una reunión con los desarrolladores para asegurarse de que todas las personas técnicas sientan lo mismo sobre la implementación del control de código fuente. Haremos un punto más fuerte cuando todos estén detrás de él.
2. Presente la idea al jefe y dígale que realmente necesitamos control de fuente.
3. Impleméntelo lo antes posible.

Tómese un día para instalar el control de versiones y enseñe a todos en el proyecto a usarlo. No es tan dificil. Personalmente, no he usado Git, pero he configurado y usado otros sistemas de control de versiones y no son tan difíciles de conseguir. Asegúrese de elegir uno que se integre con su entorno de desarrollo. Esto hará que su uso sea prácticamente perfecto.

Esto no será tiempo perdido.

El tiempo que se perderá cuando se sobrescribe alguien o eliminaciones algún código que le costará mucho más.

Si no tiene control de versión, también pasará una cantidad excesiva de tiempo haciendo una copia de seguridad de su proyecto y preocupándose por la versión que tienen todos y qué versión está en el servidor, etc.

Si necesita convencer a su jefe, haga una estimación del tiempo que le llevará configurar y monitorear cualquier solución de control que no sea de versión y agregar el costo de reescribir algunos días de trabajo perdido. No olvide agregar el costo de fusionar manualmente las ediciones de 3 desarrolladores que trabajan en el mismo archivo fuente y el costo adicional de hacer que esa fusión sea incorrecta. Un buen control de versión te da esto gratis

Luego, compárelo con el costo de obtener el control de la versión: nulo (si va a código abierto) y configurarlo: 3 días hábiles.

No olvide que un error más adelante en el proyecto costará más de uno al principio. Si tiene que rehacer todo el proyecto debido a un error, cualquiera puede cometer que esto costará mucho más que el tiempo de reescritura, podría costarle a su jefe la reputación de su empresa.

Si comparte la fuente en una carpeta, también podría compartir repositorios allí. El jefe no lo sabrá, excepto que hay una carpeta .git allí.

Nunca deberías tener que pedir permiso para hacer tu trabajo correctamente: Seth Godin.

Configure el control de fuente, aprenda a usarlo y no se lo diga a su jefe. Normalmente no abogo por desobedecer a la gerencia, pero en este caso tu jefe es estúpido. Si realmente cree que git tardará demasiado en aprender, comience con un sistema de control de versiones más simplificado como svn: no hace todas las cosas geniales que hace git, pero es aún más fácil obtener una comprensión básica.

No espere hasta que esté en el medio y tenga serios problemas antes de implementar algo. Solo hazlo y haz el trabajo.

Editado para agregar: lo que su pregunta realmente pregunta es "¿cómo hago el control de fuente sin usar un sistema de control de fuente". Has reconocido la necesidad, y creo que todos aquí realmente te están diciendo lo mismo: no hay una forma sensata de hacer un control de fuente sin un sistema de control de fuente.

Solo tengo su resumen, pero parece que su jefe está haciendo un argumento de tiempo y dinero, y usted está haciendo un argumento de superioridad técnica. Debes estar haciendo un argumento de tiempo y dinero. Aprenda la manera ingeniosa de hacer las cosas y haga un seguimiento del tiempo que podría ahorrar, luego presente un registro a su jefe con entradas como "28/03/2011 tuvo que esperar 30 minutos para que Joe volviera a una compilación compilable para que pudiéramos hacer una fusión, el comando git merge contra su último commit habría sido de aproximadamente 5 segundos "con un buen total en la parte inferior.

Si la capacitación y la configuración de un servidor son obstáculos de negocios, existen infinitas formas de configurar un flujo de trabajo de git, incluido el hecho de que solo un miembro del equipo use git, con carpetas compartidas para el "servidor".

Indique a sus colegas que copien su código en una carpeta compartida determinada siempre que sea un buen punto para compartir. Puede mantener un repositorio para cada uno de ellos y hacer todo el control de la fuente usted mismo, y lentamente pasarles más y más responsabilidades de control de la fuente a medida que tenga la confianza suficiente para entrenarlos. Eso está lejos de ser la forma ideal de hacerlo, pero en comparación con lo que tiene ahora, incluso eso le ahorrará tiempo en las fusiones. Es más fácil convencer a tu jefe con menos curva de aprendizaje en equipo, y obtienes todos los beneficios de reversión y versiones que deseas.

No hago mucho trabajo en la base de datos, pero que yo sepa, la fusión de los cambios en el esquema de la base de datos no se maneja muy bien con el control de origen. Si esas fusiones son difíciles, es posible que desee considerar un cambio de proceso donde todos los cambios de la base de datos pasan por un único controlador de acceso.

Esto es una locura. Debe usar un VCS incluso si trabaja por su cuenta. No se debe prohibir el uso de un VCS en una empresa. Simplemente hazlo. ¡Ahora mismo! Realmente ... No necesitas cosas avanzadas desde el principio. GitHub y GitLab son muy fáciles de usar, pero estoy seguro de que puedes encontrar más servicios de alojamiento compatibles con Windows si tu jefe insiste (aunque no es difícil configurar y usar Git en Windows).

El pensar que preguntas es imposible . Si varias personas están trabajando en el mismo proyecto sin utilizar ningún control de origen, tendrá rápidamente una gran cantidad de problemas, y ya que será el desarrollador principal, que tendrá que lidiar con ellos.

Desde mi experiencia personal, trabajar en un proyecto sin control de fuente se vuelve imposible para dos desarrolladores . No tres No cuatro. Dos. Es probable que pueda gestionar la situación con dos desarrolladores en algunas circunstancias excepcionales : si esos desarrolladores son muy organizados y profesionales, si interactúan bien, si pueden intercambiar fácilmente (por lo que se encuentran en la misma habitación a las mismas horas, cada tiempo) y si pueden evitar errores humanos (modificando por error el archivo que fue modificado por otra persona en el mismo momento, y luego borrando los cambios realizados por esta persona).

En mi caso, siempre fue más o menos un desastre cuando se trataba de hacer que dos personas participaran en un proyecto sin control de versiones. En el mejor de los casos, una persona estaba enviando archivos modificados a la segunda, y esta segunda utilizaba una herramienta de diferencias para aplicar los cambios manualmente. En el peor de los casos, una persona rastreó los cambios que estaba haciendo y luego los volvió a aplicar cada vez que la segunda persona modificó el código fuente. Resultado: una gran pérdida de tiempo, dinero y productividad.

Ahora, desde mi punto de vista y mi propia experiencia, veo tres soluciones al problema que tiene:

• Instale un control de versión que sea fácil de usar . Solía ​​instalar CollabNetSubversion como el servidor SVN, es bastante rápido y fácil de configurar, si no le importa en absoluto la seguridad . Si usa Visual Studio, AnkhSvn puede instalarse para permitir a los desarrolladores actualizar / confirmar el código fuente fácilmente desde Visual Studio.

• Convence a tu jefe de que la prueba de Joel está escrita por una persona que conoce muy bien su trabajo, y si la prueba de Joel sugiere tener un control de versión, hay una buena razón para ello. Después de todo, también puede decidir que los desarrolladores no necesitan herramientas de resaltado de sintaxis / IDE para escribir código. El Bloc de notas de Windows está bien, ¿no? Y también, ¿por qué tener acceso a internet? Todo lo que necesitamos es una PC muy, muy antigua con Windows 3.1.

• Salga de esta compañía , ya que tengo algunas dudas de que todo, excepto el control de versiones, sea perfecto y profesional allí.

No usar un VCS en un proyecto más grande porque no quieres invertir el tiempo de configurar uno es como hacer un largo viaje descalzo, porque no quieres invertir el tiempo de ponerte los zapatos.

Cualquier VCS es un orden de magnitud mejor que no tener ninguno.

Una manera fácil de configurar un VCS es obtener TortoiseSVN (dado que parece estar usando C #, supongo que está en Windows). Puede crear un repositorio en la carpeta local que elija (vaya a él, haga clic con el botón derecho> TortoiseSVN> Crear repositorio aquí). Comparta esta carpeta en su red (preferiblemente debe estar en una máquina, que siempre está disponible) y realice los pagos con la URL file://computername/path/to/that/repository. Descarga excluida, esto no demora más de un minuto en configurarse.

Su respuesta es un simple enlace a su jefe ... envíele esta página por correo y resalte la cantidad de veces que las palabras "dejar de fumar" aparecen de los profesionales.

Si bien la palabra "tonto" aparece probablemente tantas veces, estoy seguro de que su jefe no lo es. Simplemente no le queda claro el valor absoluto de esto. La pregunta que debe hacerle es qué pregunta relacionada con el negocio daría como resultado la misma respuesta (tal vez un contador sugiera "¡Más bien no asegure a este edificio que está vinculado al máximo, le ahorrará unos pocos dólares!")

El control de código fuente solo es necesario cuando el número de desarrolladores en un proyecto es> 0. Estoy empezando a pensar que uno podría decir lo mismo sobre la integración continua ...

(-:

Como ustedes son desarrolladores de ASP.NET, les sugiero que quieran usar uno de Subversion, TFS o Mercurial, pero para ser honesto, no importa cuál de ellos siempre que usen algo. Desarrollar sin control de versiones no tiene ningún sentido, incluso menos cuando las herramientas son más o menos libres de implementar y la sobrecarga para usarlas es mínima.

TFS le brindará un nivel de integración sorprendente. DVCS (mercurial o git) probablemente le brindará la mayor flexibilidad y capacidad. No hay una buena razón para NO hacer esto.

Si comenzara desde cero, seguramente sería con Mercurial.

Una vez que tenga el control de versiones, puede avanzar a un servidor de compilación (TFS, TeamCity) y, a partir de ahí, a una integración continua y, en ese momento, comenzará a ganar mano a mano.

Para volver a su punto de partida:

Seré el líder del proyecto (gerente de proyecto y desarrollador principal) y seré responsable de todo

Derecha, usted es responsable por lo que decide que necesita el control de versiones (porque lo hace), que decide que necesita un servidor de compilación (porque lo hace), que decide que es necesario tener la salida de despliegue de su proyecto desde el primer día (porque si siempre puede implementarlo y, por lo tanto, facilitar más pruebas) y que la implementación será altamente automatizada, estos son los pasos que está tomando para garantizar el éxito de su proyecto (del cual usted es responsable ...)

Como se mencionó anteriormente, puede colocar un repositorio en la carpeta compartida que ya tiene. No necesita perder tiempo configurando un servidor si utiliza un sistema de control de fuente distribuido, como Git, Mercurial o Bazaar.

Te sugiero que uses Git, ya que tienes algo de experiencia con él, o Mercurial, que tiene una buena integración en Visual Studio.

Si en el futuro su jefe le dirá que cambie a TFS, eso es mejor que no tener ningún control de versión.

En mis días de Powerbuilder, teníamos un equipo completo trabajando en un conjunto de aplicaciones sin usar el control de código fuente. Oh, Powerbuilder tenía control de fuente, pero en realidad usarlo era una trampa: si PB fallaba mientras tenía un archivo desprotegido (y se bloqueaba MUCHO), ese archivo de código fuente binario propio ahora era inaccesible. Se colocó alguna bandera en el archivo, y ninguna otra copia de PB pudo cargarla, ni siquiera la misma persona que la retiró.

Entonces, lo que hicimos fue bastante simple. "Hola, Tom, voy a trabajar en xyz.pbl. Así que no hagas ningún cambio". En el gran esquema de las cosas, rara vez tuvimos problemas.

Suponiendo que no pueda convencer a su equipo para que adopte el control de versiones o que su jefe se entere del subterfugio e insista en que el equipo se detenga, puede adoptar un enfoque menos que óptimo.

Instale Git o Mercurial en su propia máquina. Versión tu propio trabajo. Cuando el equipo sincronice su trabajo a través del proceso Beyond Compare, agregue los cambios a su repositorio local como una nueva confirmación. Siempre podrá recuperar una versión de trabajo anterior de su repositorio local en caso de que la sincronización del equipo rompa algo.

El uso de un DVCS asegura que no se requiera tener un servidor y que no haya un proceso de configuración complejo. Instalar Mercurial y comenzar a usar lo básico no debería llevar más de 30 minutos.

No es una solución ideal, pero es mejor que nada.

Mi reacción inicial a esto fue que ya tienes un proceso de trabajo ideal sin control de versiones. Todos parecen tener una buena forma de gestionar la fusión, etc. Desde una perspectiva gerencial, esta es aparentemente una buena situación. Conocí equipos que usan el control de versiones, pero tienen que luchar con el proceso de desarrollo en sí.

Por lo tanto, convencer a su jefe de basar su argumento únicamente en que el control de versión produciría "un mejor proceso" no tiene sentido. Sin embargo, hay otro argumento mucho más importante sobre por qué necesita usar la versión o el control de fuente en primer lugar, que se puede calcular fácilmente con dinero. Y eso es:

Riesgo

El problema no es que el uso del control de código fuente mejore su proceso de desarrollo. Es más un problema lo que sucedería si no tienes el control de la fuente en absoluto. Cuales son los riesgos?

¿Digamos que alguien borra por error una función en el código o un archivo completo? ¿Cuánto costaría repararlo? Esperemos que alguien tenga eso cubierto, por lo que la solución es marginal.

Pero, ¿qué sucede si ningún cuerpo tiene una copia de seguridad del archivo perdido? ¿Cuántas horas hombre costaría arreglar eso? Eso podría llevar días, y eso se calcula fácilmente en promedio de horas hombre. ¿Sería demasiado para la empresa? ¿Podría esto remediarse de alguna manera más rápido?

Sí, con algún tipo de control de fuente. En contraste: ¿cuánto tiempo tomaría configurar el control de versión y hacer una copia de seguridad? La mayoría de los de código abierto como git o mercurial no requieren mucho tiempo para configurarse. Enseñar a las personas cómo usarlo no sería tan difícil, teniendo en cuenta que ya sabe cómo fusionarse con Beyond Compare y "registrarse" en una carpeta compartida. Este es un costo de configuración único. ¿Serían estas horas hombre menos que las que tienen los riesgos? Si esto es cierto, entonces el uso del control de fuente debería ser una prioridad.

Siempre que pueda mostrar una razón comercial por la que es útil tener control de fuente, y la gestión de riesgos sería un factor tan importante que convencería a la mayoría de los jefes.

Use un Sistema de control de versiones distribuido como git y use su máquina de carpetas compartidas para almacenar el repositorio de referencia. Este es el por qué:

Cada clon es una copia de seguridad

Si el disco duro del servidor falla, todos tienen una copia, lista para ser implementada en una nueva unidad o servidor. Como su empresa no se toma en serio el control de versiones, supongo que puede ser más o menos lo mismo con las copias de seguridad.

Referencia común

Tener un repositorio principal con una rama maestra permite conocer la versión que tiene la última palabra. Esto resuelve el "Usted ha probado sus cambios con la versión de Franck, pero ¿también tenía la de John? ¿Y cómo los fusionó?".

Entregar más cómodamente

¿El cliente quiere una versión alfa hoy? Bueno, puedes probar si el maestro es lo suficientemente estable y enviarlo. Si no es así y no tiene tiempo para arreglarlo, simplemente retroceda en el tiempo y obtenga una versión anterior pero más estable. No puede hacer eso si solo tiene la última versión.

Retrocede en el tiempo y corrige tus errores

Su fusión manual tuvo problemas que solo vio después de unos días, pero ¿ya ha sobrescrito el contenido de sus carpetas compartidas? Sin un VSC no tiene historial, por lo que no puede volver fácilmente a un punto en el que pueda verificar los errores que cometió y corregirlos. El código no es como una imagen, es como una película: evoluciona con el tiempo. Puedes extraer una imagen de una película. No se puede extraer una película de una imagen.

Localiza errores más fácilmente

Apareció un error pero realmente no lo notó en el momento en que se introdujo, por lo que no pudo solucionarlo mientras el código estaba "activo". Ahora no sabe realmente qué cambio lo introdujo, por lo que podría provenir de varias ubicaciones diferentes en el código. Tomará horas solo encontrar dónde buscar. Con git, podría haber desarrollado una prueba para decir si el error ocurre en una versión específica y usarlo git bissectpara encontrar la confirmación exacta que introdujo el error. En lugar de buscar miles de líneas de código, ahora sabe que está ubicado en ese cambio de 10 líneas, y puede mantener la prueba en su conjunto de pruebas para asegurarse de que el error no se vuelva a introducir.

Cada desarrollador es responsable de su propio trabajo.

Si eres el líder del equipo y no tienes VCS, lo más probable es que tengas que hacer el trabajo sucio, las fusiones. Si lo hace por su cuenta, probablemente no sepa todo acerca de todos los cambios y puede introducir errores. Por el contrario, si siempre le pide a las personas que escribieron el código que se reúnan con usted cada vez que haya un código para fusionar, entonces es hora de que no lo usen para producir un nuevo código.

Con un VCS, en un flujo de trabajo simple, el desarrollador solo tiene que ocuparse de su trabajo y una fuente externa de cambios: la rama maestra. Puede haber 1 o 100 personas comprometiéndose en la rama maestra, eso es lo mismo. Para poder impulsar sus cambios, tendrá que adaptarlos a los últimos cambios realizados por otros. Puede parecer que lleva más tiempo insertar el código, pero eso se debe a que también está haciendo la fusión, lo que de todos modos habría llevado tiempo.

La diferencia es que la fusión la realiza la persona que realizó los cambios, que conoce mejor ese código porque lo ha escrito.

¿Quién escribió ese código?

Hay ese error aquí, pero ¿quién ha escrito esa línea de código en particular? Es difícil de recordar, especialmente si el proyecto dura varios meses. git blamete habría dicho quién y cuándo se escribió esa línea, para que puedas preguntarle a la persona correcta, y no hay un "No recuerdo haber escrito eso".

El proyecto se está haciendo más grande.

El cliente quiere más funciones y usted es un equipo demasiado pequeño, necesitará otro desarrollador. ¿Cómo gestiona la mayor complejidad de fusión sin un VSC?

Cambios urgentes

El cliente llamó y solicitó una corrección crítica de errores para la producción, pero actualmente estaba trabajando en una nueva función. Solo git stashpara dejar de lado sus cambios, o comprometerlos en una nueva sucursal e impulsar los cambios y estará listo para comenzar a trabajar en la solución urgente, sin temor a perder su trabajo pendiente.

Funcionó hace 10 minutos

Estás haciendo algunos cambios localmente y algo que funcionó hace 10 minutos dejó de funcionar. Sin un VCS, puede mirar el código o, en el mejor de los casos, hacer una copia de la versión de referencia y ver qué cambia. Oh, espera, la referencia cambió desde que empecé a trabajar, así que ya no puedo diferir. Y no pensé en mantener una copia prístina del código en el que basé mis cambios.

Con un VCS, simplemente hace algo como de git diffinmediato, y cambia su versión en comparación con la versión correcta del código en el que se basa.

Tengo que mantener mis registros de depuración

¿Entonces eres un mal tipo y no usas el registro? ¿Tuviste que rociar printfs en toda tu base de código hasta que encontraste todas esas piezas de ese desagradable error? Ahora encontró uno, lo arregló, pero desea mantener su código de depuración cuidadosamente diseñado para solucionar los problemas restantes.

Sin un VCS, debe copiar los archivos, expurgar el código de depuración (que puede agregar algunos errores de edición), empujar eso y volver a colocar los archivos respaldados. Ah, pero parece que de todos modos entró un código de depuración.

Con git, solo debes git add --patchseleccionar las pocas líneas de código que deseas incluir en tu commit, y solo puedes hacerlo . Luego reanuda su trabajo y aún tiene su código de depuración. No tuvo que tocar el código, por lo que no hubo errores de copia / pegado.

La gran bola de barro

Sin un VCS, las personas trabajan de su lado y le dan un montón de cambios, a veces no relacionados. Cuando hay demasiado código para verificar, es difícil encontrar un error.

Un VCS le permitirá hacer pequeños cambios incrementales y le dará un registro de cambios. El registro de cambios es esencial: las personas deben decir por qué están haciendo el cambio, no cuál es el cambio ( qué pregunta ya es respondida por el cambio de código en sí). Esto significa que cuando está inspeccionando algún código de una nueva característica, por ejemplo, no tendrá que leer muchos cambios mixtos no relacionados, como correcciones de errores no relacionadas. Esto ayuda a centrarse en el código que le importa.

Si te doy 100 papas 1 por 1, y una está podrida, la encontrarás de inmediato. Ahora, si arrojo 100 papas frente a ti y te pido que encuentres la podrida, esa no es la misma tarea.

Sangría

Espero que tenga una buena política de estilo de codificación, de lo contrario, los cambios de sangría lo volverán loco si se fusiona a mano. Claro, puede ignorar los espacios en blanco en los cambios (pero no en los idiomas cuando la sangría cuenta, como Python). Pero luego obtendrá un código de aspecto extraño difícil de leer.

Eres el lider del proyecto

Si eres el líder, esto significa que tendrás la culpa si las cosas no funcionan. Si no puede sentirse cómodo con la situación porque su jefe todavía no puede entender que valga la pena usar la herramienta adecuada para el trabajo correcto, entonces, al menos, me negaría a convertirme en el líder de un fracaso predecible.

Use Dropbox, tiene un historial de versiones automático. Puede compartir la carpeta dropbox entre múltiples usuarios.

Editar

También puede descargar TortoiseSVN-client y crear un "repositorio local" en la unidad de red. Luego, las personas pueden verificar el código fuente por ubicación de carpeta de red.