Problema de las copias de seguridad

Imagina que tienes un proyecto grande. En algún momento, al desarrollarlo, alcanzas un cierto nivel de completitud lógica y lanzas la versión 1.0, que los usuarios comienzan a utilizar.

Sin embargo, el trabajo no termina ahí y lanzas la versión 1.1 corrigiendo errores y con adiciones, luego la versión 1.2, después 1.3, y luego reescribes todo de nuevo y anuncias el lanzamiento de la versión 2.0. Y así sucesivamente - el trabajo en el proyecto generalmente nunca termina.

Sin embargo, durante el desarrollo, existe el riesgo de romper algo en el código, o accidentalmente eliminar el proyecto o parte de él. Para no perder todo el trabajo, guardas periódicamente el código del proyecto en una carpeta separada. Simplemente numeras tus guardados en orden, indicando algún comentario en el guardado, sobre qué cambios introdujiste o qué funcionalidad habías implementado hasta ese momento del guardado.

Sin embargo, de repente resulta que no puedes simplemente lanzar la versión 2.0, porque los usuarios de la primera versión se quejan - no están listos para migrar a la segunda. De acuerdo, dices, y comienzas a trabajar en la segunda versión, paralelamente lanzando actualizaciones para la primera. Tu proyecto se divide en dos carpetas: una para la primera versión y otra para la segunda. También se divide la carpeta para la copia de seguridad. Al mismo tiempo, parte del código de la primera y segunda versión es idéntico. Al hacer correcciones en este código en una versión del proyecto, debes recordar hacer las correcciones también en la otra versión. Sin embargo, a veces olvidas hacerlo. Aparecen errores extraños. El trabajo se detiene.

Durante el trabajo en la versión 2.0 decidiste añadir una nueva funcionalidad. Sin embargo, hacerla lleva mucho tiempo y decides dividir la segunda versión en dos carpetas, duplicando el código. En la primera carpeta continuarás el desarrollo de tu proyecto, y en la segunda harás la funcionalidad ideada. Finalmente, la funcionalidad está terminada. Durante este tiempo el proyecto principal ya se convirtió en la versión 2.3. Ahora necesitas fusionar el código con la funcionalidad con el código principal del proyecto. Comienzas a copiar archivos con código a la carpeta principal, resolviendo al mismo tiempo conflictos entre el código nuevo y el antiguo. Esto te lleva tres días de trabajo. El trabajo se detiene.

El proyecto creció. Decides pedir ayuda a un amigo. Le das a tu amigo una tarea y le envías un archivo comprimido con el proyecto. Tu amigo realiza la tarea y te devuelve un archivo con los nuevos archivos, así como con los antiguos, en los cuales hizo cambios. Dedicas medio día a separar los archivos nuevos de los antiguos. Luego dedicas otro día a integrar los cambios en tus archivos.

Pides ayuda a dos amigos más. Ahora sois cuatro. Diariamente te envían archivos comprimidos con el trabajo realizado. Integras las nuevas partes en el proyecto y envías a todos archivos del proyecto con los cambios. El trabajo avanza lentamente, ya que mientras integras un cambio, tus amigos esperan a que les envíes la nueva versión del proyecto y no pueden trabajar más, para no desincronizarse por completo.

En la carpeta con las copias de seguridad ya hay gigabytes de código. Al mismo tiempo, principalmente hay duplicados, ya que al cambiar una pequeña parte del código, igual guardas todo el proyecto completo. Decides limpiar esta carpeta, eliminando las primeras cien versiones. Una semana después, resulta que en las versiones eliminadas estaba el código de una funcionalidad separada, de la cual habías renunciado en ese entonces, y ahora decidiste recuperar. Pero el código con esa funcionalidad ya está eliminado, y no está en ninguna parte. Vuelves a escribir esa funcionalidad. El trabajo se detiene.

No suena muy bien, ¿verdad? Sin embargo, los desarrolladores realmente trabajaban así antes, como describí anteriormente. Por supuesto, era muy incómodo. Por eso apareció un sistema especial llamado Git, sobre cuyas capacidades hablaremos en la siguiente lección.