Introducción a Git

el


¿Qué es Git?

  • Sistema distribuido de control de versiones.
  • Software libre y de código abierto.
  • Cada clon es un repositorio completo.
  • No depende de un repositorio central.
  • Crear branch's y fusionarlos con un merge es rápido y fácil.
  • Cada commit registrado es una revisión.
  • Creado por Linus Torvalds.

Sistema de control de versiones (RCS)

  • Permite llevar cuenta de los cambios de un conjunto de archivos digitales en el tiempo.
  • Cada versión registrada en el tiempo es una "revisión".
  • Muy utilizado para la gestión de código fuente.
  • Permite tanto a un desarrollador individual como a un grupo de programadores gestionar el código de un proyecto.
  • Especializados en archivos de texto (generalmente).

¿Qué otros sistemas de control de versiones hay?

  • RCS (el original, de Pardue University luego GNU)
  • CVS
  • Subversion (SVN)
  • Mercurial (hg)
  • Bazaar (bzr)
  • Visual SourceSafe (Microsoft)

¿Por qué es "distribuido"?

  • No requiere de un repositorio central (como svn).
  • Cada copia o "clon" es autosuficiente y completa.
  • Cualquier copia se puede actualizar contra otra.

Breve Historia

  • El Kernel Linux es el proyecto de código abierto más grande y con más actividad que existe en el mundo.
  • En el 2002 Linus Torvalds encontró en BitKeeper, un producto comercial de la empresa BitMover un RCS superior y decidió usarlo.
  • Stallman lo criticó, Alan Cox (Kernel 2.2) se opuso pero igual se utilizó gracias a una licencia especial para proyectos libres extendida por Larry McVoy.
  • En el 2005 se eliminó la licencia gratuita de BitKeeper señalando a Andrew Tridgell (TRAC) de haber hecho ingeniería reversa (cosa que el desmintió).
  • Linus Torvalds tomó el toro por las astas y escribió él mismo un sistema RCS con lo mejor de SVN, BitKeeper y las mejoras necesarias para el kernel.
  • Luego de 2 semanas de no trabajar en el kernel, Linus crea "GIT" y comienza la historia...

¿Por qué Linus tuvo que crear Git?

  • Ni siquiera BitKeeper era lo suficientemente rápido para las necesidades del kernel como proyecto.
  • Muchos parches complicados tomaban hasta 30 segundos en aplicarse.
  • Sincronizar las versiones entre Linus Torvalds y Andrew Morton (mantenedor de la rama 2.6, demoraba 2 horas!).
  • Se necesitaba algo veloz y distribuído, nace Git.

Pequeña analogía

  • Guardar cambios en Git, es como cuando jugabas partidas en algún juego, para luego retomarlas desde ese punto.
  • Pero esto no quiere decir que se use como backup de código, Git es mucho más que eso.

Comandos Básicos

Clonar un repositorio
$ git clone git@ip_del_server:nombre_repo.git

Agregar un archivo
$ git add archivo.txt

Guardar el archivo
$ git commit -a -m "comentario"

Traer los cambios
$ git pull origin nombre_rama

Enviar cambios al servidor
$ git push origin nombre_rama

Cambiar de branch
$ git checkout nombre_rama

Ver en que branch estamos
$ git branch

Hacer merge
$ git merge nombre_rama

Ejemplo práctico


  • Se requiere de una pc, y seguir paso a paso.
  • Veremos temas como uso de: branch's, merge, commit, status, log, etc.
  • Al final hay un resumen de cada punto tocado.
  • Se mostrará como crear un repositorio central con git.
  • Crear carpeta vacía "myproject", e iniciamos

Crear carpeta vacía "myproject", e iniciamos
$ git init


Crear archivo1.txt y archivo2.txt y agregarlos
$ git add .

Guardando la primera revisión
$ git commit -m "Iniciando proyecto"

Crear archivo3.txt y archivo4.txt, ver estado
$ git status

Agregando los nuevos archivos
$ git add archivo3.txt archivo4.txt

Guardamos una nueva revisión
$ git commit -m "Segunda revisión"

Ver el historial detallado
$ git log --stat

Crear un nueva rama
$ git checkout -b nueva_rama

Crear carpeta demo y dentro archivo5.txt y agregarlos
$ git add demo/

Guardar cambios
$ git commit -m "Tercera revisión"

Regresar a master
$ git checkout master

Fusionar con nueva_rama
$ git merge nueva_rama

Salimos de la carpeta y creamos un repo
$ git clone --bare myproject mirepo.git

Clonamos otro proyecto a partir del repo
$ git clone mirepo.git newporject

Entramos en newproject, creamos archivo6.txt y lo agregamos
$ git add archivo6.txt

Guardamos los cambios
$ git commit -m "Agregado archivo6.txt"

Nos aseguramos de tener la última versión del repo
$ git pull origin master

Ahora enviaremos nuestros cambios al repo
$ git push origin master

Salimos de newproject y clonamos otro
$ git clone mirepo.git miproyecto

Nos fijamos el historial
$ git log

Creamos una nueva rama
$ git checkout -b nuevos_cambios

Creamos archivo7.txt, lo agregamos y guardamos
$ git add archivo7.txt
$ git commit -m "Agregando archivo7.txt"

Regresamos a master y comparamos
$ git checkout master
$ git diff master nuevos_cambios

Hacemos merge y enviamos los cambios
$ git merge nuevos_cambios
$ git push origin master

Eliminamos la rama que ya no nos sirve
$ git branch -d nuevos_cambios

Nos vamos a newproject y traemos los nuevos cambios
$ git pull origin master

Resumen

  • Primero se creó un repositorio git local "myproject" y se guardaron revisiones.
  • Luego se creó un branch llamado "nueva_rama" y se guardaron revisiones.
  • Fusionamos los cambios del branch "nueva_rama" con "master".
  • Creamos un repositorio central llamado "mirepo.git" a partir de "myproject".
  • Clonamos "mirepo.git" con nombre "newproject".
  • Hicimos cambios, guardamos y luego enviamos al repositorio central "mirepo.git".
  • Clonamos otra vez de "mirepo.git" llamado "miproyecto" y nos fijamos el historial de revisiones.
  • Creamos una nueva rama, hicimos cambios, comparamos y fusionamos, finalmente enviamos los cambios al repositorio "mirepo.git".
  • Por último fuimos a "newproject" a actualizar con pull.

Otros comandos útiles

Por ejemplo para revisar el trabajo realizado:

Ver el historial de cambios.
$ git log

Ver solo las últimas 3 revisiones.
$ git log -n 3

Ver cambios de forma detallada.
$ git log --stat --sumary

Comandos para corregir errores

Descartar todos los cambios hechos desde la última revisión
$ git reset --hard

Descartar cambios en eun archivo individual (actualizar a la última revisión conocida)
$ git checkout archivo

Corrigiendo la descripción de la última revisión (el último commit)
$ git commit --amend

Incluir algo que debió estar en la última revisión creada
$ git reset --soft HEAD^
$ git add olvidado1 olvidado2
$ git commit

Trabajando con un repositorio remoto

Crear un "clon" de un repositorio remoto
$ git clone git://servidor.com/ruta/proyecto.git

Agregar el origen remoto
$ git remote add origin git://servidor.com/ruta/proyecto.git

Hacer cambios y agregar los archivos modificados a una nueva revisión
$ git add archivo1 archivo2 carpeta1 carpeta2
$ git commit -m "Nueva revision"

Enviar los cambios de vuelta al repositorio remoto
$ git push origin master

Conclusiones

  • Git es una herramienta rápida, eficiente y moderna para el control de versiones de proyectos con archivos digitales que sean o no código fuente.
  • Git permite flujos de trabajo distribuidos en los que no tiene porque existir un repositorio central.
  • Linus Torvalds creó Git de acuerdo a las necesidades del kernel pero ofreció una gran herramienta a la comunidad en general.

Recomendaciones

  • Traer siempre la última versión con un pull, y correr los test's, para evitar conflictos de archivos e incosistencia en el proyecto.
  • Nunca dejar cambios sin guardar al termino del horario de trabajo.
  • Realizar commit's con comentarios significativos, a fin de mantener el repositorio limpio y ordenado.
  • Resolver todos los conflictos al hacer un merge antes de enviar los cambios con push.
  • Darle una repasada al libro Pro Git.

Comentarios

Publicar un comentario