Introducción a git
Tags: git, beginners
Published: 2020-03-17 02:23:54

*Todos los que hemos entrado al mundo de la informática y la programación alguna vez hemos escuchado el nombre de esta herramienta “Git” y aunque no es una tecnología nueva ha tomado mucha fuerza con el pasar de los años hasta llegar a tener la popularidad y la utilidad que tiene hoy en día.*

Git Es una herramienta que nos permite dar seguimiento a los cambios que ocurren en archivos de un proyecto, cada cambio crea una versión nueva de ese archivo la cual podemos recuperar en cualquier punto en el tiempo. Dicho en palabras llanas *“controlador de versiones”*.  Nosotros los programadores los utilizamos para salvaguardar nuestro código fuente, sin embargo no se limitan solo a eso, estas herramientas podemos usarlas con cualquier archivo en nuestra computadora  como por ejemplo: dar seguimiento a todos los cambios que sufra las ilustraciones de un diseñador gráfico, así en dado caso de disconformidad en un cambio simplemente retrocedemos a una versión más vieja. 

Todos alguna vez hemos trabajado  con un controlador de versiones. Como olvidar ese trabajo final de la universidad donde creábamos una versión nueva del documento cada vez poníamos o quitábamos algo, he incluso usábamos un sofisticado sistema para dar un identificador único a cada uno. :-D


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/831s854eq1gos6ji0s1o.png)

Este enfoque funciona de maravillas siempre y cuando los cambios no sean demasiados y no pretendamos dar un seguimiento continuo de cada cambio.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/gp39s4h768od205399jz.png)
Una locura sin duda alguna.


Ni hablar de trabajar en equipo, donde tenemos que manualmente unir todas las partes para obtener un solo resultado donde quizás muchos no estén al día con la última versión provocando un verdadero caos.

###Git es nuestro salvador! 

Ahora bien Git no es el único Controlador de versiones que existe: Subversion, CVS o Mercurial también son otras alternativas sin embargo hoy nos enfocaremos en Git.

####¿Cómo lo instalo?

Si eres usuario Linux es muy probable que ya lo tengas en tu sistema. Desde Windows debes descargar el instalador desde la página oficial y hacer una instalación que es bastante sencilla.

https://git-scm.com/download/win

También hay paquetes para tu distro de Linux o Mac en caso de no tenerlo instalado.
Puedes probar ejecutando el siguiente comando en una terminal para ver qué versión tienes instalada.

```
$ git --version
```


####¿Como Git Funciona?


Git es una herramienta que funciona totalmente desde la línea de comandos pero si bien no te sientes cómodo trabajando con una terminal puedes usar un cliente gráfico a pesar de en este artículo nos enfocaremos en el uso de terminal.

https://git-scm.com/downloads/guis

Una vez tenemos Git instalado podemos empezar hacer pruebas pero antes de ensuciarnos las manos vamos que conocer algunos conceptos básicos en los que Git se fundamenta así sacamos una idea de cómo funciona.
Repositorios: Un repositorio en Git es un espacio de trabajo donde registramos todos los cambios que hacemos. 

Git es un controlador de versiones distribuido que a diferencia de su contraparte “un controlador de versiones centralizado” o por su siglas CVCS, cada uno de los contribuyentes en ese espacio de trabajo tienen una copia del repositorio en su computadora local, que si bien existe un repositorio central donde los demás repositorios locales sincronizan los cambios, funcionan de forma independiente y no se ven afectados si el principal no está disponible en algún momento. 

De hecho una de las características más llamativas de git es la rapidez con la que podemos hacer la mayoría de las operaciones que brinda y es debido a casi todo lo que hacemos se ejecuta de forma local en nuestra base de datos, como resultado no tenemos problemas de latencia en la red o desconexión como sucede en el caso de los CVCS.


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/fqmd1m1mdd2u50fo5rrb.png)

Si bien no es necesario tener un repositorio remoto (central) utilizaremos uno para sincronizar nuestros cambios, esto nos permitirá poder trabajar con un equipo de personas y asegurar que no perderemos nuestro espacio de trabajo en caso de dañarse nuestro equipo o borramos accidentalmente todo nuestro directorio de trabajo. para estos propósitos utilizaremos Github que es un servicio en la nube que nos permite almacenar nuestro código, podemos crear todos los repositorios que queramos allí de forma gratuita con la condición de que deben ser públicos, es decir todo el mundo los puede verlos, también cuentan con una versión de paga que nos permite tener repositorios privados pero para nosotros la versión free es más que suficiente. existen más alternativas que ofrecen modelos de negocios distintos como gitlab o bitbucket en ellos si puedes tener “repos” privados de forma gratuita y el funcionamiento con respecto a github es bastante similar.
puedes crearte una cuenta de github mediante este enlace. 

https://github.com/join?source=header-home

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/8o5d08mkfjl545bd1z7x.png)

####Los 3 principales estados de nuestros archivos

Git cuenta con tres estados principales en los que los archivos pueden estar: Committed, Modified y Staged. Committed (comiteado) quiere decir que nuestros archivos ya están guardados en nuestra base de datos local, Modified (modificado) significa que modificaste el archivo y Staged (o estageado) que has marcado a uno o varios archivos como listos para ser guardados en la base de datos local.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/kkul3oq52muyb9xgae97.png)

En la imagen de arriba se encuentra el ciclo de vida más completo, aunque por el momento solo es necesario entender los 3 elementos anteriormente mencionados.

####¿Cómo utilizarlo?

Ya que tenemos a git instalado, tenemos una idea de su funcionamiento y tenemos nuestra cuenta de github lista, ya podemos versionar nuestro código.

Abrimos en linux/mac una terminal o en windows el bash de git y vamos a empezar a crear un directorio el cual será nuestro espacio de trabajo e inicializamos nuestro repositorio allí. 

```
$  mkdir my-wonderful-app
$  cd my-wonderful-app
$  git init
```

con el comando `git init` estamos generando un repositorio vacío. Se nos ha creado un directorio oculto .git este es usado por git para mantener un control.

Ahora vamos a Crear un archivo con extencion .java y vamos a escribir en el.

```
public class Sample {
        public static void main(String... args) { }
}
```

luego de hacer lo mencionado arriba vamos a verificar el status de nuestro archivo Sample.java utilizando el siguente comando.

```
$ git status
```
deberíamos tener el siguiente output

```
On branch master
No commits yet
Untracked files:
  (use "git add <file>..." to include in what will be committed)

	Sample.java

nothing added to commit but untracked files present (use "git add" to track)

```

Nuestro archivo se encuentra marcado como _Untracked file._ Significa que git no tiene ningún registro de ese archivo en su base de datos.
procedemos a agregarlo.

```
$ git add Sample.java
```

Si ejecutamos git status nuevamente vemos que nuestro archivo a cambiado de estado y ahora se encuentra Staged (Estageado).

```
On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

	new file:   Sample.java
```

Ahora procedemos a hacerle commit a nuestro archivo para así persistir los cambios de forma local.

```
$ git commit
```

luego de hacer commit se nos abre un editor de texto (por defecto vi), en él debemos escribir un comentario. Como la descripción más abajo indica; todo texto que inicia con # será ignorado y de no agregarse un comentario se aborta el commit.

también podemos obviar ese proceso definiendo directamente el mensaje del commit usando la opción -m.

```
$ git commit -m "initial commit"

[master (root-commit) 4ed73e2] initial commit
 1 file changed, 3 insertions(+)
 create mode 100644 Sample.java
```

_Nota: por lo regular los comentarios en un commit suelen ser cortos pero descriptivos._

Ya nuestro archivo se encuentra registrado en nuestra base de datos local, si volvemos a ejecutar un git status vemos que ya no tenemos ningún archivo que requiera una acción.
Ahora bien, vamos a modificar Nuestro archivo Sample.java para agregarle unas linueas.

```
public class Sample {
        public static void main(String... args) { 
                System.out.println("Hello World");
         }
}
```

guardamos el archivo (en vi presionamos Esc para salir del modo edición y luego y si revisamos el status de `Sample.java` vemos que ahora tiene el status de modificado.

```
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

	modified:   Sample.java

no changes added to commit (use "git add" and/or "git commit -a")
```

hacemos git add y luego git commit para volver a guardar los cambios.

```
$ git add Sample.java 

$ git commit -m 'Adding hello world output'
[master 48438a4] Adding hello world output
 1 file changed, 3 insertions(+), 1 deletion(-)
```
Ahora subiremos esos cambios a nuestro repositorio en github para eso tenemos que crear el repositorio allá primero.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/0ik8l3s7scqy87qo75su.png)

Solo agregamos el nombre de nuestro repo y las demás opciones la dejamos por defecto.

Luego de crear el repositorio nos da una url, esta es la ruta de nuestro repositorio en github procedemos a copiarla porque la necesitaremos para vincular nuestro repositorio local con el de github. 

https://github.com/new

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ss51q48iedwrl91juhra.png)

Volvemos a nuestra terminal y ejecutamos el siguiente comando.
`git remote add origin <repo_url>`

```
$ git remote add origin https://github.com/jmorla/my-wonderful-app.git
```

con el comando anterior vinculamos nuestro repositorio local con el repositorio de github. Por último hacemos:

```
$ git push -u origin master

Username for 'https://github.com': jmorla
Password for 'https://jmorla@github.com': 
Enumerating objects: 6, done.
Counting objects: 100% (6/6), done.
Delta compression using up to 4 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (6/6), 541 bytes | 180.00 KiB/s, done.
Total 6 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), done.
To https://github.com/jmorla/my-wonderful-app.git
 * [new branch]      master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

```

Con este último comando estamos enviando todos nuestros cambios al repositorio remoto, si revisamos nuestro github en el repo deberíamos ver nuestro `Sample.java`

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/f2gj9lpkh34v8wkmegil.png)

En la ilustración que está debajo podemos ver lo que acabamos de hacer; desde un repositorio local hemos enviado todos nuestros cambios a nuestro repositorio remoto en github.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/3s4mjoo65ejgdw5t2hio.png)

#####Resumen

_Los controladores de versiones son herramientas fantásticas y fundamentales que todo programador debe conocer, git es una de las más populares debido a su facilidad de uso y la rapidez que podemos versionar nuestro código, todas las operaciones se manejan de forma integral en nuestro repositorio local y solo es necesario sincronizar los cambios con nuestro repositorio en la nube. Github más que ser una web para depositar código es una comunidad, puedes dar un vistazo para ver todos los proyectos interesantes que hay allí. En otra entrega navegaremos más profundo en características muy poderosas que nos ofrece Git._

#####bibliografía

_Scott Chacon and Ben Straub (2005) Pro Git 2nd Edition.
https://git-scm.com/book/az/v2/Git-Basics-Recording-Changes-to-the-Repository_