Git y la terminal: el control de versiones por dentro

Commits, ramas, merges y remotos, construidos a mano para que dejen de dar miedo.

13 aulas · 9 horas de práctica · en el navegador, sin instalar nada

Temario

  1. Por qué versionar — Qué problema resuelve el control de versiones, qué es un commit —una foto completa, no una lista de cambios— y el modelo mental de los tres lugares donde vive tu código.
  2. La terminal mínima — Los comandos de navegación que vas a usar en cada aula que sigue —pwd, ls, cd, cat, mkdir—, la diferencia entre una ruta relativa y una absoluta, y cómo arranca un repositorio con git init y git config.
  3. El repositorio por dentro — Qué hay adentro de `.git`: objetos con hash SHA-1, la diferencia entre blob, tree y commit, y el grafo donde cada commit apunta a su padre.
  4. Primer parcial — Integra por qué versionar (snapshots, no diffs, y los tres lugares), la terminal mínima con git init y git config, y qué hay adentro de .git: objetos con hash, blob/tree/commit y el grafo de commits.
  5. Commit paso a paso — El ciclo diario: git status para ver dónde está cada archivo, git add para preparar, git diff y git diff --staged para revisar exactamente qué cambió, git commit -m con un mensaje que sirve, y git log para leer la historia.
  6. Ramas — Qué es realmente una rama —un puntero con nombre, no una copia del proyecto—, cómo moverse entre ramas con git switch, qué es HEAD, y qué significa que dos ramas diverjan.
  7. Merge — Fast-forward contra merge commit, qué es un conflicto y por qué Git no lo resuelve solo, los marcadores <<<<<<< ======= >>>>>>>, y cómo resolverlos bloque por bloque hasta cerrar el merge.
  8. Rebase y reescribir — Qué hace git rebase y en qué se diferencia de merge, la regla de oro de nunca reescribir commits publicados, git commit --amend, y juntar commits de borrador en uno con rebase interactivo.
  9. Segundo parcial — Integra el ciclo diario de commit (status, add, diff, log y mensajes que sirven), qué es una rama por dentro y cómo moverse entre ellas, cuándo un merge es fast-forward y cuándo necesita un commit propio, y qué hace rebase de verdad con la regla de nunca reescribir lo compartido.
  10. Remotos — git clone y git remote, la diferencia entre fetch (trae, sin tocar tu rama) y pull (trae y mezcla), git push y por qué el servidor puede rechazarlo, y la diferencia entre origin/main y tu main local.
  11. Trabajo en equipo — Qué es un pull request y qué aporta una revisión de código, convenciones de nombres de rama y de mensajes de commit, el .gitignore, qué nunca se sube (secretos, dependencias, logs), y por qué un secreto filtrado sigue en la historia aunque se borre.
  12. Deshacer sin miedo — git restore y restore --staged, los tres modos de git reset (soft, mixed, hard), git revert para historia compartida, git reflog para recuperar lo que parecía perdido, git stash para guardar trabajo a un costado, y una tabla de qué comando usar según qué rompiste.
  13. Examen final — Integra la carrera entera: por qué versionar y qué es un commit, la terminal y git init, objetos y el grafo, el ciclo de commit, ramas, merge, rebase, remotos, trabajo en equipo y cómo deshacer sin miedo.

Es parte de