Sistema de Control de Versiones

Un sistema de control de versiones (VCS) registra los cambios realizados en un conjunto de archivos a lo largo del tiempo para que puedas recuperar cualquier versión específica más adelante. Esta página explica qué es el control de versiones, por qué los equipos de software dependen de él, las tres familias de herramientas VCS (local, centralizado y distribuido) y los beneficios concretos que ofrece cada una. Esta es la base conceptual de todo lo demás en este libro: una vez que comprendas por qué existe el control de versiones, comandos como git init, git commit y git branch tendrán mucho más sentido.

¿Qué es el Control de Versiones?

El control de versiones es un sistema que registra los cambios en el código fuente (o en cualquier conjunto de archivos) para que un equipo pueda gestionar cómo evoluciona ese código a lo largo del tiempo. En lugar de sobrescribir archivos y perder el estado anterior, el sistema almacena cada cambio significativo como una revisión a la que puedes volver.

En términos concretos, el control de versiones te permite:

• Viajar en el tiempo — restaurar cualquier versión anterior de un archivo o de todo el proyecto.
• Ver quién cambió qué y por qué — cada revisión lleva un autor, una fecha y un mensaje.
• Trabajar en paralelo — separar líneas de trabajo independientes en ramas y combinarlas luego con una fusión.
• Comparar versiones — ver las diferencias exactas entre dos puntos del historial con un diff.

Por Qué Es Importante

El control de versiones es esencial en el momento en que más de una persona — o más de una máquina, o incluso solo tú a lo largo del tiempo — toca una base de código. Permite que varios desarrolladores trabajen por separado sin sobrescribir el trabajo de los demás, y luego integren esos cambios de forma trazable. También transforma "rompí algo y no sé qué fue" en una pregunta que puedes responder: puedes encontrar el cambio exacto que introdujo un error y deshacer solo ese cambio.

Incluso en un proyecto en solitario, el control de versiones te da una red de seguridad. Puedes experimentar libremente, sabiendo que cada estado funcional está guardado y es recuperable.

Sistemas de Control de Versiones (VCS)

Un Sistema de Control de Versiones (VCS) — también llamado Gestión de Código Fuente (SCM) o Sistema de Control de Revisiones (RCS) — es la herramienta de software que implementa el control de versiones: rastrea cambios, almacena el historial y coordina la colaboración.

Tres Tipos de Sistemas de Control de Versiones

Históricamente, las herramientas VCS se dividen en tres familias, cada una resolviendo un problema que la anterior dejaba pendiente.

1. Sistemas de Control de Versiones Locales

Un VCS local mantiene todo el historial en una simple base de datos en una sola máquina. Fue creado para prevenir errores cotidianos como editar el archivo equivocado o perder una versión anterior al copiar directorios manualmente. Una de las herramientas locales más populares es RCS (Revision Control System), que aún se distribuye hoy en día. RCS almacena conjuntos de parches (las diferencias entre versiones) para poder recrear cualquier archivo tal como lucía en cualquier momento.

La limitación es obvia: el historial vive en una sola computadora, por lo que no ofrece colaboración real ni protección si ese disco falla.

2. Sistemas de Control de Versiones Centralizados

Un VCS centralizado (CVCS) almacena todos los archivos versionados en un único servidor central, y los clientes "obtienen" archivos de ese único lugar. Esto resolvió la colaboración: todos podían ver, en cierta medida, lo que otros hacían, y los administradores tenían un único punto de control. Durante muchos años este fue el estándar. Ejemplos comunes son CVS, Subversion (SVN) y Perforce.

La contrapartida es el punto único de fallo. Si el servidor central se cae, nadie puede hacer commits ni colaborar; si su disco se pierde sin una copia de seguridad, todo el historial del proyecto puede perderse con él.

3. Sistemas de Control de Versiones Distribuidos

En un VCS distribuido (DVCS), cada cliente no solo obtiene los últimos archivos — realiza una copia completa del repositorio, incluyendo todo el historial. Si el servidor falla, el clon de cualquier cliente puede enviarse de vuelta para restaurarlo. Esto también hace que la mayoría de las operaciones sean rápidas y funcionen sin conexión, porque el historial completo es local. Los ejemplos incluyen Git, Mercurial, Bazaar y Darcs.

Este es el modelo que usa Git, y es por eso que puedes hacer commits, crear ramas, ver el historial y hacer diffs sin ninguna conexión de red. El resto de este libro cubre Git en profundidad — comienza con ¿Qué es Git? e instalando Git.

Beneficios de los Sistemas de Control de Versiones

Los principales beneficios de un VCS son:

1. Historial de cambios a largo plazo. Cada creación, modificación y eliminación de un archivo queda registrada durante la vida del proyecto. Esto te permite volver a una versión anterior para analizar errores y solucionar problemas.
2. Ramificación y fusión. La ramificación permite a los desarrolladores trabajar de forma independiente sin interferir entre sí. La fusión reúne ese trabajo y pone de manifiesto cualquier conflicto para que pueda resolverse de forma deliberada.
3. Trazabilidad. Puedes rastrear cada cambio, anotarlo con un mensaje que describa su propósito y conectarlo con herramientas de gestión de proyectos y seguimiento de errores.

Control de Versiones en Acción

No necesitas un servidor ni un equipo para ver el control de versiones en funcionamiento — Git rastrea el historial directamente en tu propia máquina. Los comandos a continuación se ejecutan completamente de forma local: crean un repositorio, registran dos versiones de un archivo y luego piden a Git el historial de ese archivo. Pruébalos en una terminal después de instalar Git.

# Create a fresh project and turn it into a Git repository
mkdir vcs-demo && cd vcs-demo
git init -q

# Tell Git who is making the changes (required for a commit)
git config user.email "[email protected]"
git config user.name "You"

# Record the first version
echo "line one" > notes.txt
git add notes.txt
git commit -q -m "Add notes.txt"

# Change the file and record a second version
echo "line two" >> notes.txt
git commit -q -am "Add a second line"

# Ask version control for the history of this file
git log --oneline

La salida de git log --oneline lista dos revisiones, la más reciente primero — cada una con un hash de commit corto y el mensaje que escribiste:

3f8a1c2 Add a second line
9b2e4d7 Add notes.txt

(Tus hashes serán diferentes, ya que se calculan a partir del contenido y la marca de tiempo.) Ese historial es el corazón del control de versiones: cada versión está guardada, etiquetada y es recuperable. Para profundizar más, consulta git log y git commit.

Práctica