Universidad Católica del Uruguay

Facultad de Ingeniería y Tecnologías

Programación II

Desafío Git #1: Calculadora Colaborativa

Objetivo

Crear una aplicación de calculadora simple en C# donde cada estudiante del equipo contribuya con una operación diferente (suma, resta, multiplicación, división). Los estudiantes practicarán los siguientes comandos de Git: clone, checkout, pull, add, commit, stash, merge y push.

Note

El código provisto inicialmente en este repositorio no compila; los cambios que harás con tu equipo durante esta actividad lograrán que compile y funcione.

Pasos

1. Crear un repositorio a partir de esta plantilla

Para trabajar en un proyecto en Git debes tener un repositorio. Puedes crear localmente un repositorio y luego subirlo a un servidor para que tus compañeros lo usen, o puedes clonar un repositorio compartido en un servidor; en este ejercicio usaremos esta última opción, clonando este repositorio plantilla a tu propio repositorio.

• En este paso, todos los estudiantes leen todas estas instrucciones primero, luego sólo uno de ellos las ejecuta.
• Uno de los estudiantes hace clic en el botón Use this template que aparece arriba a la derecha en esta página; luego hace clic en la opción Create a new repository.
• En el cuadro de texto Repository name, ese estudiante escribe un nombre para el repositorio -puede usar el que quiera, incluso el que le sugiere GitHub, mientras sea único en la organización-; no cambien ninguna otra opción.
• Verán en el navegador el nuevo repositorio, con este mismo contenido. Compartan en el equipo el link al repositorio. Continúen con los pasos a continuación.

2. Clonar el repositorio

Tip

Te recomendamos que elijas una carpeta -o que crees una nueva- para todos los repositorios del curso. Recuerda cómo llegar a esa capeta desde la línea de comandos -puedes volver consultar este documento si fuera necesario-.

• Cada estudiante abre una terminal y se ubica en la carpeta que eligieron para tener todos sus repositorios.

• Luego clona el repositorio en su máquina local con git clone, ejecutando el siguiente comando en la terminal:

  git clone <url-del-repositorio>

  La <url-del-repositorio> es la dirección que aparece en el navegador luego del último de los pasos anteriores.

  Git muestra mensajes similares a estos; en lugar de <nombre-repositorio> aparecerá el nombre que eligieron al crear el repositorio en el paso 1:

  Cloning into '<nombre-repositorio>'...
  remote: Enumerating objects: 9, done.
  remote: Counting objects: 100% (9/9), done.
  remote: Compressing objects: 100% (8/8), done.
  remote: Total 9 (delta 0), reused 4 (delta 0), pack-reused 0
  Receiving objects: 100% (9/9), 9.54 KiB | 4.77 MiB/s, done.

  El comando git clone crea una copia local del repositorio en la URL indicada en una carpeta cuyo nombre coincide con el nombre del repositorio. Para moverte a esa carpeta, usa el siguiente comando:

  cd <nombre-repositorio>

  El es el que hayan elegido en el paso 1. Pueden ver todas las carpetas en el directorio actual con los comandos ls y o dir .

3. Crear ramas para cada uno

• Cada estudiante crea su propia rama para la operación que va a implementar con git checkout, ejecutando el siguiente comando en la terminal:

  git checkout -b <nombre-rama>

  El corresponde a la operación que cada estudiante va a implementar; es uno de los siguientes:

  • feature-addition
  • feature-subtraction
  • feature-multiplication
  • feature-division

  Git muestra un mensaje similar al siguiente:

  Switched to a new branch '<nombre-rama>'

4. Implementar la operación

• Cada estudiante abre el repositorio en Rider con el siguiente comando:

  rider .

  Noten que hay un punto, separado por un espacio, al final del comando.

  Rider les pedirá que confirmen si quieren abrir el proyecto en esa carpeta; elijan la opción Open. Eventualmente, Rider también les preguntará si es seguro abrir el proyecto; elijan la opción Trust and Open.

• Cada estudiante implementa su respectiva operación en una nueva clase en C#, agregando el código que aparece a continuación al final del archivo Program.cs que está en la carpeta src del proyecto.

  Estarás agregando nuevas clases en un mismo archivo Program.cs; en el futuro, cada clase se agregará en su propio archivo .cs -cuyo nombre coincidirá con el de la clase-, pero para este ejercicio todos agregarán sus clases en el mismo archivo. No te preocupes si no entiendes del todo el código que estás usando, el objetivo es que experimentes cómo es el desarrollo colaborativo -entre varios estudiantes- y concurrente -al mismo tiempo- en Git.

  Estudiante A (suma):

  public class Addition
  {
     public static int Add(int a, int b)
     {
         return a + b;
     }
  }

  Estudiante B (resta):

  public class Substraction
  {
     public static int Substract(int a, int b)
     {
         return a - b;
     }
  }

  Estudiante C (multiplicación):

  public class Multiplication
  {
     public static int Multiply(int a, int b)
     {
         return a * b;
     }
  }

  Estudiante D (división):

  public class Division
  {
     public static double Divide(int a, int b)
     {
         return (double)a / b;
     }
  }

5. Agregar y hacer commit de los cambios

En lugar de "hacer commit" a veces decimos "comitear". El verbo "comitear" no existe, pero los desarrolladores lo usamos igual y entre nosotros nos entendemos 😀.

• Después de implementar sus operaciones, los estudiantes agregan y comitean sus cambios con git add y git commit, ejecutando los siguientes comandos en la terminal; noten que hay un punto, precedido de un espacio, al final del comando:

  git add .
  git commit -m "Implementación de la operación <nombre de la operación>"

  Puedes ejecutar estos comandos en la terminal que venías usando. Rider incluye también una terminal a la que puedes acceder con el comando View | Tool Windows | Terminal o mediante el ícono que aparece abajo a la izquierda. De forma predeterminada, la terminal del Rider se abre en la carpeta raíz del proyecto que tienes abierto.

6. Guardar temporalmente los cambios

Vamos a suponer que mientras estás realizando cambios en el repositorio, sin haber finalizado tu trabajo, debes hacer modificaciones sin perder los cambios que has hecho hasta el momento —es decir, tienen que poder volver a recuperarlos—; como los cambios son temporales, tampoco quieres "comitearlos".

• Cada estudiante agrega la siguiente línea de comentario inmediatamente antes del código que agregaron en el paso anterior:

  // Esta clase implementa la operación <nombre-operación>

  Reemplaza <nombre-operación> según corresponda

  Por ejemplo, para la operación de la resta, el código debería quedar así:

  // Esta clase implementa la operación resta
  public class Resta
  {
      public static int Restar(int a, int b)
      {
          return a - b;
      }
  }

• Guarda estos cambios temporalmente con git stash, sin "comitearlos", para poder realizar otras modificaciones.

  git stash

  El código vuelva a quedar como estaba luego de ejecutar el comando git commit en el paso 5. Puede ser necesario cerrar y volver a abrir el archivo Program.cs para ver reflejados los cambios en Rider.

• Ejecuta el siguiente comando para volver al código que tenías al comienzo de este paso:

  git stash pop

  Nuevamente, puede ser necesario cerrar y volver a abrir el archivo Program.cs para ver reflejados los cambios en Rider.

Git muestra un mensaje similar al siguiente:

On branch '<nombre-rama>'
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   src/Program/Program.cs

Resolveremos esto a continuación.

7. Enviar los cambios

Hasta ahora estuvieron trabajando en la copia local del repositorio, es necesario enviar los cambios al repositorio que está en el servidor.

• Cada estudiante agrega y "comitea" los últimos cambios —el comentario que agregaron en el paso anterior-:

  git add .
  git commit -m "Comentario agregado"

  Noten que hay un espacio, seguido de un punto, al final del comando add.

• Cada estudiante envía sus cambios al repositorio remoto con git push, ejecutando el siguiente comando en la terminal:

  git push origin <nombre-rama>

  El <nombre-rama> es el que usaron antes; uno de los siguientes:

  • feature-addition
  • feature-subtraction
  • feature-multiplication
  • feature-division

  Deberías ver varios mensajes, similares, aunque no necesariamente iguales, a los siguientes:

  Enumerating objects: 14, done.
  Counting objects: 100% (14/14), done.
  Delta compression using up to 8 threads
  Compressing objects: 100% (8/8), done.
  Writing objects: 100% (10/10), 931 bytes | 931.00 KiB/s, done.
  Total 10 (delta 3), reused 0 (delta 0), pack-reused 0 (from 0)
  ...

8. Obtener cambios y hacer merge

En lugar de "hacer merge" a veces decimos "mergear". El verbo mergear tampoco existe, pero al igual que sucede con comitear, los desarrolladores lo usamos y nos entendemos entre nosotros 😀.

Ahora llegó el momento de hacer merge —combinar— los cambios en las ramas de trabajo con la rama principal. Antes de "mergear" sus cambios deben obtener los cambios de los compañeros. Dependiendo del orden en el que hagan el trabajo, puede haber conflictos, que deberán resolver.

• Antes de hacer merge de sus ramas, cada estudiante debe obtener los últimos cambios de la rama main. Usa git checkout para cambiar la rama actual a main; ejecuta los siguientes comandos en la terminal:

  git checkout main

  • Luego, de a un estudiante a la vez, obtengan los últimos cambios con git pull y luego "mergeen" esos cambios en la rama main con los de su propia rama, ejecutando los siguientes comandos:

    git pull
    git merge <nombre-rama>
    git push

  El <nombre-rama> es el que usaron antes; uno de los siguientes:

  • feature-addition
  • feature-subtraction
  • feature-multiplication
  • feature-division

  En caso de que no haya conflictos, aparecerá un texto como el que mostramos a continuación:

  Updating bdd7c4d..fb5eaa0
  Fast-forward
  src/Program/Program.cs | 9 +++++++++
  1 file changed, 9 insertions(+)

  En caso de que haya conflictos, verán un mensaje como el siguiente:

  Auto-merging src/Program/Program.cs
  CONFLICT (content): Merge conflict in src/Program/Program.cs
  Automatic merge failed; fix conflicts and then commit the result.

  El código en Program.cs luce similar al que aparece a continuación, con unos marcadores <<<<<<<, =======, y >>>>>>>:

  namespace Ucu.Poo.GitChallenge;
  
  public static class Program
  {
    public static void Main()
    {
    Console.WriteLine(Suma.Sumar(1, 2));
    Console.WriteLine(Resta.Restar(3, 4));
    Console.WriteLine(Multiplicacion.Multiplicar(5, 6));
    Console.WriteLine(Division.Dividir(7, 8));
    }
  }
  <<<<<<< HEAD
  ⋯
  =======
  ⋯
  >>>>>>>

  Lo que está entre <<<<<<< y ======= es lo que está en conflicto en la rama actual main; lo que está entre ======= y >>>>>>> es lo que está en conflicto en la rama que están "mergeando". Git no puede resolver el conflicto, deben hacerlo ustedes.

  En este caso, ambas modificaciones deben quedar en el archivo, por lo tanto, basta borrar los marcadores. En otros casos, la resolución del conflicto será diferente. En cualquier caso, el código final no debe incluir los marcadores. Puedes ver cómo debe quedar el código completo al final de esta página.

  Para terminar, "comiteen" y "pusheen" los cambios:

  git commit -m "Resolución de conflictos"
  git push

Ejemplo final de código

Después de hacer merge de todas las contribuciones de los miembros del equipo, el programa debería verse más o menos así:

Console.WriteLine(Addition.Add(7, 2));
Console.WriteLine(Substraction.Substract(10, 1));
Console.WriteLine(Multiplication.Multiply(3, 3));
Console.WriteLine(Division.Divide(18, 2));

public class Addition
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

public class Substraction
{
    public static int Substract(int a, int b)
    {
        return a - b;
    }
}

public class Multiplication
{
    public static int Multiply(int a, int b)
    {
        return a * b;
    }
}

public class Division
{
    public static double Divide(int a, int b)
    {
        return (double)a / b;
    }
}