Aprendiendo GIT. Primeros pasos

Si hay alguna herramienta o tecnología que marca la diferencia en el trabajo diario de un desarrollador, y sobre todo de un equipo de desarrolladores, es el uso de un sistema de control de versiones.

Sistemas de control de versiones

Un sistema de control de versiones es un conjunto de herramientas que nos permite registrar los cambios que se producen en los archivos de un proyecto a lo largo del tiempo, y que por tanto nos permite volver a cualquier estado del mismo a nuestra voluntad.

Podemos encontrar distintos tipos de sistemas de control de versionnes:

• Sistemas locales, que sólo existen en nuestros propios equipos de trabajo. Un ejemplo de este tipo sería por ejemplo RCS.
• Sistemas centralizados, que dependen de un servidor centralizado que almacena toda la información, encargándose de distribuir distintas copias entre los distintos usuarios y guardar todos los cambios que se van produciendo. Algunos ejemplos de este tipo serían CVS, Subversion, o Perforce.
• Sistemas de control distribuido, en los que cada participante en el proyecto tiene una copia completa del mismo sin depender de un servidor que almacene toda la información. Algunos ejemplos serían GIT o Mercurial.

Por qué GIT

GIT es un sistema de control de versiones que surge tras la necesidad de dar soporte a la gran cantidad de cambios que se producían en el Kernel de Linux y tras las diversas discrepancias que se produjeron allá por el año 2005 con BitKeeper, herramienta que se usaba por aquel entonces para mantener todo el código.

Esta situación impulsó a la comunidad de desarrolladores de Linux y en especial a Lunis Torvalds a desarrollar su propio sistema de control de versiones. De esa iniciativa surgió GIT.

En la actualidad GIT es una de las mejores opciones que existen por las siguientes circunstancias:

• Tiene un diseño sencillo y prácticamente transparente para sus usuarios.
• Es veloz y sobre todo eficiente.
• Cuenta con un increíble sistema de ramificaciones convirtiéndolo en una fabulosa herramienta para el desarrollo no lineal de proyectos.
• Es completamente distribuido y por tanto capaz de manejar grandes proyectos.

Entendiendo el funcionamiento de GIT

GIT trata y almacena la información de nuestros proyectos de una forma bien diferente a como lo hacen otros sistemas de control de versiones. La mayoría de estos sitemas lo que hacen es guardar información acerca de los cambios que se van produciendo en los distintos archivos de un proyecto, con el propósito de poder volver a cualquier versión anterior.

En este sentido, lo que hace GIT es manejar la información del proyecto a través de un conjunto de snapshots del sistema de archivos, guardando las referencias entre dichos snapshots. Para ganar eficiencia, si GIT no detecta cambios en un fichero no lo almacena, pero sí una referencia hacia el fichero idéntico anterior. En última instancia lo que almacena es una secuencia de snapshots debidamente referenciados.

GIT mantiene la integridad a través de un checksum de comprobación. Esto implica que es imposible hacer cambios en los ficheros de un directorio sin que GIT se entere. Para ello git usa hash SHA-1 en las distintas operaciones que lleva a cabo para mantener nuestro sistema de control de versiones. Lo que hace es generar un grafo correctamente referenciado que contiene toda la información necesaria para pasar de una versión a otra con total integridad.

Los tres estados de GIT

Cuando trabajamos con GIT, nuestra información puede estar en una de las siguientes situaciones:

• Información modificada (modified). Este estado implica que hemos modificado nuestra información, pero aún no está siendo trackeada por GIT.
• Información preparada (staged). Este estado implica que hemos marcado nuestra información para posteriormente ser confirmada y por tanto trackeada como nueva versión.
• Información confirmada (committed). Este estado implica que nuestra información ha sido almacenada en la base de datos local de GIT.

Estas situaciones dan lugar a lo que se conoce como los tres estados de GIT, el working copy, el stagin area y el repositorio.

El working copy, que es nuestra área de trabajo en la que hacemos los cambios en nuestros ficheros.

El staging area, que es el espacio donde colocaremos aquellos ficheros listos para ser colocados en el repositorio.

Y el repositorio, que es el área donde GIT irá guardando las distintas versiones de nuestra información.

Todo nuestro trabajo con GIT se reduce a ir moviendo la información de un área a otra, gestionando de esa forma sus distintos estados. Para ello usaremos preferiblemente la línea de comandos de nuestro terminal aunque también existen utilidades gráficas que nos facilitan nuestro trabajo diario con GIT.

Configurando GIT

En primer lugar nos aseguraremos que lo tenemos instalado en nuestro equipo. Para verificar si está o no instalado, podemos ejecutar este comando git version. Si obtenemos respuesta nos indicará la versión de GIT que tenemos instalada, y en caso de que no lo esté, tendrás que instalarlo en tu equipo. Para no perder tiempo con ello, te recomiendo seguir esta sencilla guía.

Configuraciones básicas

Todas las operaciones en GIT van firmadas con la información básica del usuario, user.name y user.email.

Para configurar dicha información en GIT ejecutaremos los siguientes comandos en nuestro terminal:

git config --global user.name "name"
git config --global user.email "email"

El modificador --global indica a GIT que esta configuración se usará por defecto siempre que trabajemos con GIT. Estos parámetros de configuración podemos personalizarlos a nivel de proyecto tan sólo quitando el modificador --global del comando.

Si queremos conocer cuál es nuestra configuración actual podemos ejecutar los siguientes comandos:

git config user.name, o bien git config user.email

Otras configuraciones iniciales

Vamos a configurar un par de parámetros más de forma global:

git config --global color.ui true
git config --global core.editor "nano"

En la primera indicamos a GIT que use color para mostrarnos distintos tipos de información. La segunda configura el editor de texto por defecto que usará GIT cuando necesitemos por ejemplo, anotar información acerca de los cambios que se van a confirmar.

Podríamos hacer más configuraciones, pero en prinicpio para comenzar tenemos suficiente. Si queremos ver nuestra configuración global, ejecutaremos el comando git config --list.

Primeros pasos con GIT

Iniciando un nuevo repositorio para nuestro proyecto

Podemos iniciar el control de versiones de nuestro proyecto con GIT de dos formas:

git init, en el caso de que ya estemos dentro del directorio de nuestro proyecto.
git init <directory>, en el caso de que queramos crear directamente un nuevo directorio e iniciar GIT.

Inmediatamente recibiremos un mensaje de GIT indicándonos que se ha iniciado un repositorio vacío en el directorio.

Si entramos en el directorio o ya estamos en él, comprobaremos que no contiene nada, al menos nada visible. Lo que ha ocurrido es que GIT ha creado un directorio oculto denominado .git, donde guardará toda la información de nuestro repositorio local. Podemos comprobar la existencia de este directorio a través del comando, ls -a.

Como podemos observar en la captura anterior, aparece algo nuevo en la información de nuestro terminal, concretamente el indicador <master> al final de la línea de ruta. Esto nos está indicando que nos encontramos en la rama principal del repositorio. Más adelante veremos exactamente qué significa esto.

Con todos estos pasos ya hemos conseguido poner en marcha GIT en nuestro proyecto. Podemos comprobar el estado ejecutando el siguiente comando, git status, el cual nos mostrará cómo se encuentra GIT en el mismo instante de la petición.

git status es un comando que usaremos en multitud de ocasiones para conocer cómo está nuestro repositorio durante nuestras distintas sesiones de trabajo. Volveremos a él también más adelante.

En el próximo post, comenzaremos a ver cómo se trabaja con GIT y a profundizar sobre el uso de esta fantástica herramienta, que ya te apunto no sólo sirve para el desarrollo de software sino para gestionar las versiones de cualquier tipo de documento o directorio que tengamos en nuestro equipo.

Espero que te haya resultado útil esta pequeña introducción. Nos vemos pronto en el siguiente post, en el que veremos las operaciones básicas que suelen llevarse con GIT

He creado un repo en GitHub donde iré subiendo diferentes listados de comandos útiles para el trabajo diario con GIT. Espero que te resulte también útil y que contribuyas a su mejora.