[Sugerencia] Creando una branch | Alura Latam

Para organizar el código de un proyecto en Alura por aulas y conservar el código antiguo después de una refactorización, podriamos usar las ramas de Git para cada aula o etapa del curso. Aquí te explico cómo podrías hacerlo:

Crear una rama para cada aula: Cada vez que comiences una nueva aula, puedes crear una rama en Git. Esto te permitirá mantener el código anterior intacto mientras trabajas en la nueva etapa del proyecto.
```
git checkout -b aula-01
```
Este comando crea una nueva rama llamada aula-01 y cambia a esa rama. A partir de aquí, todos los cambios que hagas estarán aislados en esta rama.
Desarrollar en la nueva rama: Continúa con el desarrollo en la rama específica de esa aula. Cuando completes el aula, puedes hacer un commit para guardar tu trabajo.
```
git add .
git commit -m "Finaliza la implementación de la aula 01"
```
Cambiar a una nueva rama para la siguiente aula: Cuando estés listo para comenzar la siguiente aula, crea una nueva rama basada en la rama anterior o en la rama principal (main o master), dependiendo de tu flujo de trabajo:
```
git checkout main
git checkout -b aula-02
```
Revisar el código anterior y comparar: Para revisar tu evolución, puedes comparar las diferencias entre las ramas de las distintas aulas:
```
git diff aula-01 aula-02
```
Esto te mostrará las diferencias entre el código de la aula-01 y la aula-02.
Mantener todas las ramas para historial: De esta manera, mantendrás un historial claro de tu progreso a través de las aulas. En cualquier momento, puedes volver a una rama anterior para ver cómo estaba el código en ese punto:
```
git checkout aula-01
```
Fusionar ramas (opcional): Si decides que los cambios realizados en una rama deben integrarse en la rama principal, puedes fusionarlos:
```
git checkout main
git merge aula-02
```

Este enfoque te permitirá organizar el proyecto por etapas o aulas y te dará la posibilidad de revisar cómo ha evolucionado tu código a lo largo del curso, manteniendo versiones anteriores sin perderlas después de una refactorización.