Git y GitHub tutorial paso a paso

José Guerra Carmenate

hace 5 años

¿Qué es Git y GitHub? En este artículo vas a entender cómo utilizar Git y GitHub, la famosa red social del código basada en Git, orientada a programadores e ingenieros, aunque, me gusta aclarar que no se limita solo a este tipo de profesionales.

Con GitHub puedes publicar tus proyectos y crear un portafolio u hoja de vida que demostrará lo que sabes. Fundamental a la hora de hacer cualquier entrevista si quieres dedicarte al desarrollo del software.

Todo esto con la ayuda de Git un sistema de control de versiones, que ayuda a gestionar los archivos guardando el proyecto, los cambios y cada una de sus versiones.

Ponte cómodo y enciende el ordenador que cuando termines este tutorial, serás capaz de utilizar tanto Git como GitHub.

Indice de contenidos

1 ¿Qué es el control de versiones?
2 ¿Qué es Git?
3 ¿Qué es GitHub?
4 Resumen de comandos de Git
5 git status
6 Conclusión sobre Git y GitHub

¿Qué es el control de versiones?

Ya sea, realizando un proyecto Arduino, editando imágenes o escribiendo un informe, te has enterado de la cantidad de archivos diferentes que usan nombres como “proyectoControlWeb_final”, “proyectoControlWeb_final_2”, etc.

Lo mas probable es que, hayas tenido que gestionar cambios manualmente, creando varias copias del proyecto y renombrando a cada carpeta para recordar los cambios realizados.

Una situación compleja e ineficiente, con un gran problema «Perder datos».

Para solucionar el problema, se desarrollaron sistemas de control de versiones (VCS por sus siglas en inglés). no es más que un software capaz de registrar los cambios realizados en un archivo o conjunto de archivos a lo largo del tiempo, de modo que puedas recuperar versiones específicas más adelante.

Aunque, por lo general, los sistemas de control de versiones se asocian con proyectos de programación y grandes software, la verdad es que son válidos para todo tipo de archivos o proyectos. De hecho, su existencia está destinada a “archivos que sean modificados frecuentemente”, ya puede ser una librería de Arduino, un libro o una página web.

Por lo tanto, es un instrumento útil para un diseñador gráfico, desarrollador web, o ingeniera/o. Pues, si quieres mantener cada versión de una imagen, diseño web o informe, usar un sistema de control de versiones es una decisión acertada.

El sistema te permite regresar a versiones anteriores de tus archivos, comparar cambios a lo largo del tiempo, evaluar el progreso del proyecto completo, y mucho más.

Los CVS han sido claves en el desarrollo de muchos proyectos de software que hoy conocemos. Quizás el caso más famoso es el kernel de Linux, pero definitivamente, no es el único.

Se pueden destacar:

Los CVS brindan grandes facilidades para que varios desarrolladores trabajen de forma conjunta en un mismo proyecto. Además, la existencia de plataformas de desarrollo colaborativo (como Github, SourceForge, GitLab, etc.) simplifica aún más el proceso y fomenta el desarrollo de software libre.

Por ejemplo, el repositorio de Arduino IDE «es público». Significa que cualquier persona puede acceder a él, ver , clonar, modificar y distribuir su código fuente. Además, puedes contribuir al código o ayudar a solucionar bugs.

Existen tres tipos de sistemas de control de versiones:

Local.
Centralizado.
Distribuido.

A continuación, veras un repaso de cada uno.

¿Qué es un sistema de control de versiones local?

Este tipo de control de versiones, permite gestionar un proyecto en tu computadora de forma local. Un sistema de este tipo, es útil cuando trabajas en un proyecto independiente.

Puede ser, un trabajo de fin de curso, una tesis de grado o un proyecto personal con Arduino.

Sin embargo, presenta algunos inconvenientes:

Lo primero es que en caso de que se dañe el ordenador perderías todo el trabajo.
Y lo segundo es que no permite el trabajo en equipo. O, al menos, no de una forma factible.

¿Qué es un sistema de control de versiones centralizados?

Como puedes ver, un problema que puedes encontrar es la necesidad de realizar proyectos en equipo.

Por ejemplo, imagina que tú y un colega deciden realizar una biblioteca para Arduino juntos. Podrían trabajar por separado y después, cuando cada uno haya terminado su parte, unirlo todo.

Sin embargo, esta variante no permite conocer en todo momento, el estado del trabajo de tu compañero y tampoco permite solicitarle ayuda con tu código de forma eficiente.

Pues, los sistemas de control de versiones centralizados (CVCS por sus siglas en inglés) vienen a resolver el problema.

Estos sistemas tienen un único servidor que contiene todos los archivos versionados y varios clientes que descargan los archivos necesarios desde ese lugar central. Este fue el estándar para el control de versiones por muchos años y aún se utiliza bastante.

Esta configuración ofrece muchas ventajas. Por ejemplo, todas las personas, hasta cierto punto, saben en que está trabajando el resto de colaboradores del proyecto. Es mucho más fácil administrar un CVCS que tener que lidiar con proyectos locales en cada ordenador.

Pero, esta configuración tiene sus desventajas.

La más obvia es que, si por algún motivo, el servidor queda fuera de servicio nadie podrá guardar cambios durante ese tiempo.

Peor aún, si el servidor se estropea, puedes decir adiós a todo el trabajo realizado.

¿Qué es un sistema de control de versiones distribuido?

Los sistemas de control de versiones distribuidos (DVCS por sus siglas en inglés) vienen a resolver los problemas de los dos anteriores.

En un DVCS (como Git, Mercurial, Bazaar o Darcs), los clientes no solo descargan la última versión de los archivos, sino que replican completamente el repositorio.

De esta manera, si un servidor con DVCS deja de funcionar, cualquiera de los repositorios disponibles en los clientes puede ser copiado al servidor con el fin de restaurarlo.

Además, no es necesario estar conectado constantemente al servidor, ya que es posible realizar cambios y almacenarlos en la copia local para luego, cuando sea posible o necesario, actualizar los datos al servidor.

Cuando se utiliza un DVCS, lo usual es utilizar una plataforma de desarrollo colaborativo como servidor.

¿Qué es Git?

Git es un software de control de versiones distribuido desarrollado por Linus Torvalds, para optimizar el trabajo en proyectos que cuenten con un gran número de archivos.

Aunque, es posible utilizar Git como un CVS local, lo usual, es alojar los proyectos en un servidor para trabajar de forma colaborativa.

Existen un montón de plataformas de desarrollo colaborativo (también conocidas como forjas) que admiten el uso de Git como sistema de control de versiones. Entre estas destacan:

Más adelante veras cómo utilizar Git para trabajar en proyectos utilizando GitHub. Pero antes de eso, es necesario tener instalado Git en tu ordenador.

Instalación de Git en Linux

Instalar Git en Linux es realmente fácil. Necesitas utilizar la herramienta básica de administración de paquetes que trae tu distribución. Por ejemplo, si estás en Fedora puedes utilizar yum.

[$ yum install git]

1	[$ yum install git]

Si estás en una distribución basada en Debian como Ubuntu, puedes usar apt-get o apt.

[$ sudo apt-get install git]

1	[$ sudo apt-get install git]

En caso de que utilices otra distribución, puedes consultar la página de instrucciones de instalación de Git para Linux y Unix. Allí vas a encontrar un resumen con los comandos necesarios para cada distribución.

Instalación de Git en macOS

Para instalar Git en macOS simplemente es necesario descargar un instalador binario. La dirección del instalador la puedes obtener desde la página de descargas de Git para macOS.

Al hacer clic en el enlace redirige al sitio de descarga del instalador. Ahora solo resta hacer clic en el botón Download para iniciar la descarga.

Una vez la descarga concluya es necesario ejecutar el instalador y seguir los pasos del asistente para terminar la instalación.

Instalación de Git en Windows

Para instalar Git en Windows es necesario ir a la página de descargas para Windows en el sitio de Git. Aquí debes seleccionar el que se corresponda con la arquitectura de tu ordenador. En mi caso, he utilizado el instalador de 64 bits.

Una vez la descarga finaliza es necesario ejecutar el instalador.

La primera ventana que aparece muestra la licencia. Haces clic en “Next >” para continuar.

La próxima ventana permite establecer la localización donde se instalará Git, aunque mi recomendación es que dejes la ruta predeterminada. Haz clic en “Next >” para ir a la próxima ventana.

En esta ventana se pueden establecer algunos parámetros de la instalación.

Lo puedes dejar como viene y hacer clic en “Next >” directamente.

La próxima ventana te permite indicar en qué carpeta del menú inicio se crearán los accesos directos. No es necesario que modifiques esto, puedes hacer clic en “Next >” sin tocar más nada.

En esta ventana tienes que seleccionar el editor que utilizará Git de forma predeterminada. Una vez lo selecciones haz clic en “Next >”.

En esta ventana puedes especificar el nombre que Git utilizará para la rama principal cuando crees un repositorio. Una vez más, no necesitas modificar nada, simplemente haz clic en “Next >”.

Esta ventana permite ajustar la variable de entorno PATH de Windows. Lo mejor es marcar la opción recomendada y hacer clic en “Next >”.

Esta ventana permite ajustar el backend utilizado para HTTPS. No te preocupes por esto, simplemente deja la opción predeterminada y haz clic en “Next >”.

En esta ventana puedes indicar cómo debe tratar Git los caracteres de fin de línea. Como se indica en su descripción, para Windows, lo mejor es marcar la primera casilla.

En esta ventana tienes que determinar qué emulador de terminal utilizar para Git. Lo mejor es que utilices MinTTY, ya que el terminal de Windows presenta muchas limitaciones. Haz clic en “Next >” para continuar.

Ahora puedes escoger cuál es la acción predeterminada para el comando git pull. No te preocupes mucho por esto, deja marcada la opción predeterminada y haz clic en “Next >”.

Ahora tienes que escoger el asistente de credenciales. Marca la primera casilla y haz clic en “Next >” para continuar.

En esta ventana puedes configurar algunas opciones extra. Puedes dejarlas como están y hacer clic en “Next >”.

Ahora puedes activar algunas opciones experimentales, aunque mi consejo es que no las actives. Bueno ya solo te queda hacer clic en “Install” para comenzar la instalación.

Ahora tienes que esperar unos minutos para que la instalación finalice.

Una vez finalice la instalación haz clic en “Finish” para completar y cerrar el asistente.

Para comprobar que todo se ha instalado correctamente puedes ir al menú inicio y comprobar que la aplicación aparezca allí.

Filosofía de trabajo en Git

En Git, al igual que otros sistemas de control de versiones, los proyectos se almacenan en repositorios. Un repositorio es el lugar donde se almacenan los archivos del proyecto junto a todo el historial de cambios que Git gestiona.

A efectos prácticos no es más que la carpeta en la que vas a almacenar los archivos que quieres gestionar. Ten en cuenta que esa carpeta puede estar en tu ordenador o en un servidor remoto, pero eso se detalla mas adelante.

La mayoría de los CVS almacenan la información como una lista de cambios en los archivos, es decir, manejan la información que almacenan como un conjunto de archivos y las modificaciones hechas a cada uno de ellos a través del tiempo.

Git , por el contrario, almacena instantáneas del proyecto cada vez que confirmas algún cambio. Es como si, cada vez que confirmes un cambio, Git tome una fotografía de todos los archivos del proyecto y lo almacene tal cual.

Para entender el proceso veras un ejemplo.

Supón que tienes el siguiente código para una placa Arduino UNO.

void setup() {
  Serial.begin(9600);
}

void loop() {
  int analogValue = analogRead(A0);
  Serial.print("Lectura:");
  Serial.print(analogValue);
}

void setup() {

Serial.begin(9600);

}

void loop() {

int analogValue = analogRead(A0);

Serial.print("Lectura:");

Serial.print(analogValue);

}

Como puedes ver es un código muy simple que solo lee el valor del pin analógico A0 y lo envía al monitor serie.

No te distraigas con el código, la idea es que comprendas el principio de funcionamiento básico de Git.

Este sería nuestro proyecto inicial, es decir, la primera “fotografía” que Git tomará de nuestro proyecto.

Ahora vas a modificar el código para agregar una pantalla LCD y un retardo de 500 milisegundos. Quedaría algo así:

#include <LiquidCrystal.h>

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  Serial.begin(9600);
  lcd.begin(16,2);
  
}

void loop() {
  int analogValue = analogRead(A0);
  Serial.print("Lectura:");
  Serial.print(analogValue);
  lcd.clear();
  lcd.print("Lectura: ");
  lcd.print(analogValue);

  delay(500);
}

#include <LiquidCrystal.h>

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;

LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {

Serial.begin(9600);

lcd.begin(16,2);

}

void loop() {

int analogValue = analogRead(A0);

Serial.print("Lectura:");

Serial.print(analogValue);

lcd.clear();

lcd.print("Lectura: ");

lcd.print(analogValue);

delay(500);

}

Esta sería la segunda instantánea de nuestro proyecto. Así sucesivamente se irán almacenando instantáneas cada vez que le indiques a Git que has realizado cambios. En la siguiente figura puedes ver como luce el proyecto después de varios cambios.

Cada uno de los puntos representa un cambio confirmado (en inglés commit), es decir, “una instantánea” de nuestro proyecto.

A una sucesión de commits como esta se le conoce como rama (en inglés branch). En este caso tienes un proyecto de una sola rama, a esa rama se le denomina master (o main, ya que es la rama principal del proyecto).

Ahora, imagina que quieres agregar una nueva funcionalidad, pero no estás del todo seguro. Bien podrías continuar como hasta ahora y si después no te gusta el resultado regresar a una de las “instantáneas” anteriores.

Pero, existe un método más práctico y es el de ramificar el proyecto.

La idea es tomar el estado actual de la rama master y crear una nueva rama a partir de ese estado. De esta forma puedes hacer cambios en esta nueva rama y luego, si quieres, puedes combinarla con la rama master.

Al proceso de combinar dos ramas se le denomina “mezclar” (merge en inglés). Este proceso se encarga de hacer efectivos los cambios realizados en una rama sobre la otra.

En la figura, puedes ver el proceso completo.

Esto ocurre mucho en proyectos grandes. Donde lo usual es que cada colaborador cree una rama cuando va a realizar alguna modificación.

Luego, cuando sus cambios son comprobados (es decir, cuando sean validados mediante pruebas) se mezclan los resultados.

Estados de archivos en Git

Si quieres llegar a dominar Git esto es lo más importante que debes recordar. En Git un archivo puede estar en uno de tres estados:

Confirmado (commited): indica que los datos están almacenados de manera segura en tu base de datos local.
Modificado (modified): indica que has modificado el archivo, pero todavía no lo has confirmado a tu base de datos.
Preparado (staged): significa que has marcado un archivo modificado en su versión actual para que vaya en tu próxima confirmación.

Esto implica que en un proyecto de Git existan tres secciones principales:

Directorio .git: es donde se almacena la base de datos con toda la información que Git necesita para gestionar el proyecto.
Directorio de trabajo: no es más que una copia de una versión del proyecto. Estos archivos son extraídos de la base de datos del directorio .git y se colocan en la carpeta del proyecto para que puedas trabajar con ellos.
Área de preparación (Staging area): en sí es un fichero que indica que los archivos que irán en la siguiente confirmación.

Teniendo esto en cuenta, el flujo de trabajo en Git para una confirmación sería:

Modificar una serie de archivos en el directorio de trabajo.
Añadir los archivos modificados al área de preparación.
Confirmar los cambios. Esto toma los archivos tal y como están en tu área de preparación y los almacena en la base de datos del directorio .git.

No te preocupes si estás un poco perdido. Más adelante realizaremos este proceso paso por paso con un proyecto real.

¿Qué es GitHub?

GitHub es una compañía sin fines de lucro que ofrece un servicio de hosting de repositorios almacenados en la nube. Esencialmente, es una plataforma de desarrollo colaborativo (también denominadas “forja”) para alojar y gestionar proyectos utilizando el sistema de control de versiones Git.

Se utiliza principalmente para la creación de código fuente de programas, pero no se limita solo a eso.

De hecho, en esta plataforma te puedes encontrar proyectos de todo tipo, desde libros hasta tutoriales. Esto se debe a su interfaz clara y limpia que permite a cualquier persona utilizarlo fácilmente.

Además de esto, cualquier persona puede inscribirse y hospedar un repositorio público completamente gratuito. Esto hace que GitHub sea especialmente popular con proyectos de código abierto (open source).

Pero no acaba ahí, la verdad es que actualmente GitHub ofrece rasgos similares a los de una red social:

Permite seguir proyectos y personas.
Soporte para notificaciones.
Permite crear una página propia para cada proyecto.
Etc.

Teniendo en cuenta todo esto muchas son las compañías que han apostado por esta plataforma. Adafruit Industries es un ejemplo claro que cuenta con más de 1000 repositorios en GitHub. Entre estos destacan varias librerías de Arduino como son:

DHT-sensor-library: para el uso de sensores DHT11 y DHT22 con Arduino.
Adafruit_SSD1306: para el control de pantallas OLED basadas en el chip SSD1306.
TFTLCD-Library: para utilizar pantallas TFT con Arduino.

También otros proyectos, como el propio Arduino IDE que actualmente cuenta con más de 200 contribuyentes, se encuentra alojado en GitHub.

Todo esto se debe a que la plataforma permite que cualquier persona (incluso tú, si lo deseas) sea capaz visualizar el código y colaborar con su desarrollo. En fin, open source en su máxima expresión.

Ya sabes que es GitHub y su relevancia, así que ya es hora de dar los primeros pasos en esta plataforma.

Primeros pasos en GitHub

Si piensas utilizar esta plataforma para alojar tus proyectos, lo primero es crear una cuenta. Para esto es necesario ir a la página principal del sitio y hacer clic en el botón Sign Up.

Esto te envía a una nueva página donde debes ingresar tus datos para crear tu cuenta.

Antes de continuar es necesario que verifiques tu cuenta.

Una vez verificada has clic en el botón Create account.

GitHub te ofrece una serie de cuestionarios para que le indiques qué temas te interesan.

Estos cuestionarios le permitirán a la plataforma mostrar proyectos o personas con intereses similares a los tuyos (como si se tratase de una red social). Al finalizar el cuestionario haz clic en el botón Complete setup.

Ahora es momento de verificar tu dirección de correo. Para esto debes revisar tu bandeja y buscar un mensaje de la plataforma. El mensaje cuenta con un botón que es necesario presionar para validar la dirección de correo.

Listo, ya tienes creada tu cuenta en GitHub.

Cuando entres a GitHub tendrás una interfaz similar a la siguiente imagen.

A la izquierda se muestra un listado con tus repositorios. De momento solo te da la opción de crear uno nuevo, ya que tu cuenta es nueva.

A la derecha tienes el área de notificaciones. Aquí es donde GitHub mostrará las notificaciones relativas a proyectos o personas que sigas. Por el momento solo te muestra el acceso a la guía de iniciación en la plataforma.

En la parte superior tienes una barra en color oscuro que ofrece varias funcionalidades:

Cuadro de búsqueda: puedes escribir palabras claves para buscar personas o repositorios.

Pull requests e Issues: estas opciones están destinadas al trabajo en proyectos colaborativos y salen del marco de este artículo.
Marketplace: en esta sección puedes encontrar herramientas que te permiten expandir las funcionalidades de GitHub. Ten en cuenta que algunas son de pago.

Explore: aquí puedes explorar GitHub para encontrar proyectos y personas.

Indicador de notificaciones (ícono con forma de campanita): cuando se genere alguna notificación este ícono cambia de color para indicarlo. Además, haciendo clic en él te permite ir al evento que generó la notificación.
Nuevo (ícono de +): mediante este botón puedes crear un nuevo repositorio, proyecto o snippet.
Perfil de usuario: mediante este botón puedes acceder a todos los datos relacionados con tu usuario.

Ya conoces un poco la interfaz de GitHub. Si quieres puedes ir a tu perfil de usuario y ver las opciones que te ofrece la plataforma o explorar en busca de proyectos interesantes.

Crear repositorio en GitHub

Para crear un repositorio en GitHub lo primero es ir al botón Nuevo (en la esquina superior derecha) y seleccionar la opción New repository.

Esto lleva a un formulario donde es necesario indicar las siguientes opciones:

Nombre del repositorio (Repository name): es el nombre con el que será mostrado el repositorio.
Descripción (Description): aquí puedes incluir una breve descripción acerca de tu proyecto. Este campo es opcional.
Tipo de repositorio: el repositorio que estás creando puede ser público o privado. Un repositorio público puede ser visto por todo el mundo, por el contrario, un repositorio privado solo podrá ser visto por ti y las personas que elijas.
Adicionalmente, es posible crear algunos archivos con el repositorio, pero no es obligatorio. Sin embargo, es una buena idea agregar a nuestros proyectos un archivo README. En este archivo puedes escribir la descripción detallada de tu proyecto que será mostrada a otros usuarios al acceder a tu repositorio.

Una vez completes el formulario tienes que hacer clic en el botón Create repository. Esto crea el repositorio y te envía a su página principal, donde puedes seguir configurando otros aspectos relativos a tu repositorio.

Tutorial para subir un código a GitHub paso a paso y actualizar el código.

Ya tienes creado tu primer repositorio en GitHub. Ahora veras cómo se gestiona desde el ordenador utilizando Git.

Paso 0: configurar Git

Antes de comenzar a utilizar Git para gestionar tus proyectos de GitHub desde tu ordenador es necesario configurarlo. Esto se realiza solo una ves, ya que las configuraciones se mantienen ante actualizaciones y son comunes para varios proyectos.

Para establecer las configuraciones, Git cuenta con una herramienta llamada git config.

A continuación, veras cómo usarla:

Lo primero que debes hacer cuando instales Git es establecer tu nombre de usuario y dirección de correo electrónico. Esto es importante, ya que Git utiliza estos datos cuando realizas operaciones sobre un repositorio.

Para establecer el nombre de usuario y la dirección de correo se utilizan los siguientes comandos.

$ git config --global user.name "Jose Guerra Carmenate"
$ git config --global user.email joseguerracarmenate@gmail.com

$ git config --global user.name "Jose Guerra Carmenate"

$ git config --global user.email joseguerracarmenate@gmail.com

Por supuesto, en la primera línea iría tu nombre entre comillas, y en la segunda tu correo.

La opción —global le indica a Git que tiene que utilizar esta configuración para todo lo que hagas en el sistema. En caso de que quieras utilizar una identidad diferente para un proyecto en particular puedes ejecutar estos comandos desde la carpeta del proyecto sin la opción –global.

Para especificar el editor a utilizar puedes usar el siguiente comando.

$ git config --global core.editor [editor]

1	$ git config --global core.editor [editor]

Donde [editor] es el editor a utilizar.

Por ejemplo, si se desea utilizar el editor vim, lo puedes indicar mediante la siguiente instrucción:

$ git config --global core.editor vim

1	$ git config --global core.editor vim

Si quieres comprobar la configuración puedes emplear el comando git config –list para mostrar todas las propiedades establecidas.

Paso 1: obteniendo un repositorio de Git

Existen dos maneras de obtener un repositorio en Git. La primera es tomar un proyecto o carpeta existente y crear el repositorio a partir de aquí. La segunda es clonar un repositorio existente en Git desde otro servidor, como puede ser GitHub o GitLab.

Inicializando un repositorio en una carpeta existente

Si planeas comenzar a gestionar un proyecto con Git debes ir al directorio del proyecto y ejecutar el siguiente comando:

$ git init

1	$ git init

Esto crea una sub-carpeta llamada .git, la cual contiene la base de datos y los archivos necesarios para que Git sea capaz de gestionar tu proyecto.

Clonando un repositorio existente

Si deseas obtener una copia de un repositorio Git existente en un servidor remoto debes utilizar el comando git clone. Lo puedes utilizar para descargar un repositorio en el que desees contribuir o para comenzar a trabajar en un repositorio recién creado en GitHub.

Este comando crea una copia local del repositorio remoto, por lo tanto tendrás acceso a todo el historial de versiones de todos los archivos del proyecto.

La estructura del comando sería la siguiente:

$ git clone [url]

1	$ git clone [url]

Donde [url] es la dirección del repositorio en el servidor remoto.

Por ejemplo, para clonar el repositorio de Adafruit para sensores DHT se utilizaría el siguiente comando:

$ git clone https://github.com/adafruit/DHT-sensor-library

1	$ git clone https://github.com/adafruit/DHT-sensor-library

En la siguiente figura puedes ver el resultado obtenido en la consola.

Esto creará una carpeta llamada DHT-sensor-library dentro de la cual se almacenará una copia del proyecto remoto.

Como puedes apreciar, la carpeta contiene un directorio .git (donde está la base de datos del repositorio) y el área de trabajo con los archivos de la última versión del proyecto.

Importante: el área de trabajo de un repositorio es la propia carpeta donde se almacena el proyecto, sin incluir el directorio .git

De forma similar puedes clonar el repositorio que creaste en GitHub anteriormente, mediante el comando:

$ git clone https://github.com/arduino-fan/programarfacil-github

1 2	$ git clone https://github.com/arduino-fan/programarfacil-github

En este caso la carpeta se llamará programarfacil-github. Puedes utilizar el comando cd de la consola para entrar al directorio.

En la siguiente imagen puedes ver el resultado final.

Ya tienes un repositorio Git local con una copia de trabajo de los archivos del proyecto. Ahora solo queda realizar cambios en los archivos y confirmarlos para que Git almacene las instantáneas con dichos cambios.

Paso 2: revisar el estado de archivos

Los archivos en Git pueden o no estar bajo seguimiento. Los archivos bajo seguimiento o rastreados (en inglés tracked) son aquellos que estaban en la última instantánea del proyecto. Los archivos sin seguimiento o sin rastrear (en inglés untracked) son todos los otros, es decir, cualquier archivo nuevo que se agregue al directorio de trabajo.

Anteriormente has visto que los archivos rastreados pueden tener tres estados: sin modificar, modificados o preparados. Por ejemplo, cuando clonas un repositorio todos los archivos están rastreados y sin modificar. Al editar algunos archivos estos pasan al estado de modificado. Cuando termines las modificaciones tienes que poner los archivos en modo preparado para confirmar los cambios.

En la siguiente imagen puedes ver el ciclo de vida del estado de los archivos.

Para determinar en qué estado se encuentran los archivos de tu proyecto debes ejecutar el comando git status. Si ejecutas este comando en un repositorio recién clonado obtendrás un resultado similar al de la siguiente imagen.

Esto significa que no hay archivos modificados y tampoco sin rastrear. Esto es perfectamente lógico en un repositorio recién clonado en el que no se ha modificado nada.

También indica en qué rama te encuentras y el estado de esa rama con respecto a la existente en el servidor remoto. Como aún no has realizado modificaciones, muestra que está actualizada.

Paso 3: rastrear archivos nuevos

Ahora vas a agregar un nuevo archivo de texto plano llamado “hola_github.txt” a tu proyecto. La carpeta del proyecto ahora luce como esta imagen.

Si ejecutas ahora el comando git status obtendrás el siguiente resultado:

Como puedes ver, el archivo hola_github.txt aparece bajo la cabecera “Archivos sin seguimiento” (en inglés Untracked files). Bajo esta cabecera solo aparecen archivos nuevos y Git no los incluirá en el próximo commit a no ser que se le indique expresamente.

Para que Git comience a rastrear un nuevo archivo es necesario utilizar el comando git add. Por ejemplo, ejecutando el siguiente comando se comenzará a rastrear el archivo hola_github.txt

$ git add hola_github.txt

1	$ git add hola_github.txt

Si vuelves a revisar el estado de los archivos. Puedes ver que ahora el archivo hola_github.txt está siendo rastreado y está listo para ser confirmado en el próximo commit.

Paso 4: preparar archivos modificados

Ahora vas a editar un archivo que esté siendo rastreado, en este caso el archivo README.md. Puedes utilizar cualquier editor de texto plano para modificarlo. En mi caso he utilizado gedit y he añadido una línea de texto al final del archivo.

Ejecutando la instrucción git status se obtiene el siguiente resultado:

Como puedes apreciar, el archivo README.md aparece en la sección “Cambios no rastreados para el commit” (en inglés, Changes not staged for commit). Eso significa que es un archivo rastreado que ha sido modificado, pero aún no está preparado. Para ello, es necesario utilizar el comando git add. Si después ejecutas git status el resultado sería:

Esto indica que ambos archivos están preparados y formarán parte de tu próxima confirmación (commit).

git add es un comando que cumple varios propósitos. Es preferible pensar en él como un comando para “añadir este contenido a la próxima confirmación” más que para “añadir este archivo al proyecto”.

Paso 5: confirmar cambios

Una vez tienes el área de preparación con los archivos que quieres, puedes confirmar los cambios. Para esto es necesario ejecutar el comando:


$ git commit

$ git commit

Este comando ejecutará el editor seleccionado en la configuración inicial.

El texto muestra algunas instrucciones de cómo proceder, la salida de la última ejecución del comando git status y una línea en blanco encima. En esa línea en blanco debes comenzar a escribir un mensaje que describa la confirmación que estás realizando.

Una vez escribas el mensaje, lo guardes y cierres el editor, los cambios serán confirmados.

Con esto ya has creado el commit y puedes ver cómo la salida generada por el comando git commit muestra la rama en la que se ha realizado, así como otras estadísticas.

Como ejercicio práctico te propongo que agregues nuevos archivos, modifiques los existentes y realices varias confirmaciones (commits).

Paso 6: actualizar el repositorio remoto

Al iniciar este tutorial has clonado un repositorio de GitHub ya creado. Sin embargo, hasta ahora todos los cambios que te he comentado han sido locales. Es decir, que todas las modificaciones están en tu ordenador. De hecho, si ejecutas el comando git status obtendrás una salida que indica que tu rama está adelantada a la de origin por varios commits.

El término origin lo utiliza Git para referirse al servidor remoto del que has clonado tu repositorio.

El comando para enviar todos los cambios locales a un servidor remoto es git push, su estructura sería:

$ git push [nombre-remoto] [nombre-rama]

1	$ git push [nombre-remoto] [nombre-rama]

Donde:

[nombre-remoto]: es el servidor a actualizar.
[nombre-rama]: es la rama a actualizar.

Para el nombre del servidor puedes utilizar directamente la URL o el término origin. Por lo tanto, puedes utilizar cualquiera de estos comandos:

$ git push https://github.com/arduino-fan/programarfacil-github/ main

1	$ git push https://github.com/arduino-fan/programarfacil-github/ main

$ git push origin main

1	$ git push origin main

Al ejecutar el comando Git te pedirá que indiques el nombre de usuario y la contraseña para acceder al servidor remoto. Esos datos corresponden a los que utilizaste para crear tu cuenta de GitHub.

El resultado obtenido sería el siguiente:

Si ahora vas al navegador y abres el repositorio podrás ver los cambios efectuados en el repositorio remoto.

Ahora ya solo queda repetir los pasos del 2 al 6, en dependencia del curso que vaya tomando tu proyecto. Ten en cuenta que no es necesario seguir el orden esquemáticamente.

En la siguiente imagen puedes ver el proceso para agregar un sketch de Arduino al repositorio. Por supuesto, primero es necesario copiar el sketch a la carpeta del proyecto.

La vista del repositorio actualizado sería la siguiente:

Resumen de comandos de Git

Antes de terminar te dejo un resumen con los comandos más importantes que se han visto en el artículo y algunos más que también pueden resultar útiles.

Aclaro que Git tiene muchos más comandos y funcionalidades disponibles.

git clone

Este comando te permite obtener una copia local de un repositorio remoto. Para esto simplemente es necesario indicarle la dirección del repositorio remoto.

Ejemplo de uso:

git init

Este comando te permite inicializar un repositorio a partir de una carpeta donde tengas almacenados los archivos que quieres gestionar.

git status

Te permite conocer la rama en que te encuentras, el estado de tus archivos y si es necesario actualizar el servidor remoto. Es un comando tan simple como útil.

Ejemplo de uso:

git add

Este comando realiza varias acciones. De forma general lo que hace es adicionar uno o varios archivos al área de preparación para el próximo commit.

Ejemplo de uso:

git rm

Este comando permite borrar un archivo de Git. Esto no significa que simplemente lo borre del área de trabajo, sino que lo quita de los archivos rastreados.

Ejemplo de uso:

git mv

Este comando permite mover o cambiar el nombre a un archivo o un directorio.

Ejemplo de uso:

git commit

Este comando te permite confirmar los cambios realizados, es decir, que le indica a Git tomar una instantánea del estado actual del proyecto.

Al ejecutar el comando este abrirá el editor de texto para introducir un comentario que describa el motivo de la confirmación.

Ejemplo de uso:

git push

Este es el comando que te permite actualizar un repositorio remoto con los cambios realizados en la versión local. Es necesario indicar el repositorio y la rama a actualizar.

Ejemplo de uso:

git log

El comando git log te permite ver el historial de confirmaciones en orden cronológico inverso. Es decir, que comienza por el último commit realizado. Es posible pasarle algunas banderas para establecer el formato de la salida, en su página del manual de Git puedes ver todas estas opciones.

Ejemplo de uso:

Conclusión sobre Git y GitHub

Hasta aquí el tutorial de introducción a GitHub. Con lo aprendido, ya puedes crear y gestionar tus repositorios.

Ojo, que esto es solo el primer paso, si quieres aprender a colaborar en grandes proyectos o convertirte en un experto en Git y GitHub, queda un largo recorrido aún.

Y por eso aquí te dejo algunos enlaces que te pueden resultar de interés:

Pro Git book: un excelente libro sobre Git que incluye un capítulo dedicado a GitHub.
Referencia oficial de Git.
Guías para varios temas de Git y GitHub.

Si te gustó el contenido, puedes agradecer dejando tu comentario.

Gracias a Shutterstock por la cesión de las imágenes.