S01E02 — La terminal no muerde: comandos que todo dev debe dominar

Intro: la terminal no muerde (pero sí exhibe)

La terminal no está ahí para verte sufrir. Está para que hagas en 10 segundos lo que en una UI te toma 3 menús, 2 clicks mal dados y un “¿por qué no aparece?”. La diferencia entre “soy dev” y “soy dev que resuelve” muchas veces es saber moverte en CLI sin pánico.

Y sí: la terminal puede romper cosas… pero casi siempre porque ejecutaste algo sin entenderlo. Este episodio es para que dejes de copiar/pegar hechizos y empieces a operar como adulto funcional.

Qué vas a aprender

• Navegar y entender tu sistema de archivos desde la terminal.
• Inspeccionar, crear, mover y borrar archivos sin “accidentes creativos”.
• Buscar texto y archivos como si fueras detective.
• Entender permisos (y por qué sudo no es una solución emocional).
• Redirecciones/pipes para encadenar comandos como pro.
• Trucos prácticos: historial, autocompletado, aliases y “no me acuerdo del comando”.

Contexto práctico (por qué te importa en la vida real)

Situaciones reales donde esto paga renta:

• Un build falló en CI y necesitas reproducirlo local con logs y variables.
• Te llega un bug “en producción” y solo tienes SSH.
• Estás migrando un proyecto y necesitas encontrar referencias, secrets hardcodeados o archivos enormes.
• Necesitas limpiar node_modules, caches, artefactos y volver a estado “sano”.
• Quieres moverte rápido entre repos, ramas, configs, y scripts.

Nota rápida de compatibilidad: los comandos aquí aplican tal cual en Linux y macOS (bash/zsh). En Windows puedes usar WSL (recomendado), Git Bash, o PowerShell (varía un poco). Donde cambie, lo marco.

Guía principal: comandos que sí o sí debes dominar

1) ¿Dónde estoy y qué hay aquí?

Moverte sin perderte.

pwd
ls
ls -la
cd /ruta
cd ..
cd ~

• pwd: imprime el directorio actual.
• ls -la: lista TODO (incluye ocultos) con detalles.
• cd ~: tu home. Cuando estés perdido, regresa a base.

Ejemplo real:

cd ~/projects/mi-app
ls -la

Si ves un package.json o pyproject.toml, ya sabes dónde estás parado.

Tip pro: usa tab para autocompletar rutas:

cd ~/pro<TAB>

2) Crear archivos/carpetas sin drama

mkdir logs
mkdir -p tmp/cache
touch README.md

• -p crea toda la ruta aunque falten carpetas intermedias.

Ejemplo:

mkdir -p scripts/local
touch scripts/local/run.sh

3) Copiar, mover, renombrar

cp origen.txt copia.txt
cp -r carpetaA carpetaB
mv viejo.txt nuevo.txt
mv archivo.txt ./destino/

Ejemplo típico en proyectos:

cp .env.example .env

4) Ver contenido sin abrir un editor

cat archivo.txt
less archivo_grande.log
head -n 50 archivo.log
tail -n 50 archivo.log
tail -f app.log

• less es para explorar. Con /texto buscas dentro. Con q sales.
• tail -f es para “seguir” logs en tiempo real.

Ejemplo para debugging:

tail -f logs/dev.log

5) Buscar archivos (por nombre) y buscar texto (dentro)

Para archivos:

find . -name "*.log"
find . -maxdepth 2 -type f -name "*.env*"

Para texto dentro de archivos:

grep -R "API_KEY" .
grep -RIn "TODO" src/

• -R: recursivo
• -I: ignora binarios
• -n: número de línea

Ejemplo real (cazar secretos hardcodeados):

grep -RIn "password" .

Si tienes ripgrep (recomendado):

rg "password" .

6) Pipes y redirecciones: el superpoder real

Esto es lo que hace que la terminal sea “LEGO”.

• Pipe | manda la salida de un comando al siguiente.
• > escribe (sobrescribe) a un archivo.
• >> agrega (append).
• 2> captura errores.

Ejemplos útiles:

ls -la | less

grep -RIn "ERROR" logs/ > errores.txt

comando_que_falla 2> errores_only.txt

Ejemplo “quiero top 20 de líneas más repetidas” (logs):

grep -R "timeout" logs/ | sort | uniq -c | sort -nr | head -n 20

No necesitas memorizarlo hoy, pero sí entender el patrón.

7) Procesos: cuando algo se queda colgado

ps aux | grep node
kill 12345
kill -9 12345

• kill -9 es el “ya estuvo” (fuerza bruta). Úsalo cuando el proceso no responde.

En macOS/Linux puedes identificar puertos ocupados:

lsof -i :3000

Luego matas el PID:

kill 12345

8) Permisos (y por qué sudo no es magia)

Checa permisos:

ls -la

Cambiar permisos (con cuidado):

chmod +x scripts/local/run.sh

Cambiar dueño (normalmente en servers/containers):

sudo chown -R usuario:grupo carpeta/

Regla de oro: si te pide sudo, primero pregunta “¿por qué?”

• ¿Es un archivo del sistema?
• ¿Mi usuario no tiene permisos en ese directorio?
• ¿Estoy en un contenedor con volúmenes?

9) Descargas rápidas y requests (debug de APIs)

curl -I https://example.com
curl -s https://api.example.com/health

Con headers JSON:

curl -s \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  https://api.example.com/v1/me

Tip: si tienes jq:

curl -s https://api.example.com/v1/me | jq

10) El kit anti-amnesia: history, reverse search y aliases

Historial:

history | tail -n 20

Búsqueda inversa (la más útil):

• Presiona Ctrl + R y escribe parte del comando. Enter para ejecutarlo.

Alias básico (temporal):

alias gs="git status"

Persistente: agrégalo a ~/.zshrc o ~/.bashrc.

Screenshots sugeridos (para que el post se sienta “hands-on”)

1. Terminal mostrando pwd, ls -la y navegación con cd.
2. Ejemplo de tail -f siguiendo un log mientras corre un servidor.
3. grep -RIn encontrando una cadena en el repo (con números de línea).
4. Ejemplo de pipe: grep ... | sort | uniq -c | sort -nr | head.
5. lsof -i :3000 y kill para liberar un puerto.

Errores comunes + solución (los golpes clásicos del origen)

Error 1: “Borré algo que no era” con rm

Síntoma: ejecutaste rm -rf como si fuera “limpiar”.

Solución / prevención:

• Antes de borrar, lista:

  ls -la ruta/
  

• Usa modo interactivo cuando tengas dudas:

  rm -i archivo.txt
  rm -ri carpeta/
  

• Evita rm -rf /algo si no estás 200% seguro de la ruta.

Error 2: “Permission denied” y tu primer impulso es sudo

Síntoma: no puedes escribir/ejecutar.

Solución:

• Verifica permisos:

  ls -la
  

• Si es un script, tal vez solo falta +x:

  chmod +x script.sh
  

• Si es una carpeta de proyecto, revisa dueño:

  ls -ld .
  

  y corrige con chown (solo si aplica y entiendes el impacto).

Error 3: grep no encuentra nada (pero “seguro existe”)

Causas típicas:

• Estás buscando en el directorio equivocado.
• Mayúsculas/minúsculas.
• El archivo es binario o está ignorado.

Solución:

pwd
ls

grep -RIn "texto" .
# o sin distinguir mayúsculas
grep -RIni "texto" .

Error 4: Mi puerto está ocupado (3000/8080) y no sé por qué

Solución rápida (macOS/Linux):

lsof -i :3000
kill <PID>

En Windows PowerShell (por si acaso):

netstat -ano | findstr :3000
taskkill /PID <PID> /F

Error 5: cd a una ruta con espacios truena

Solución: comillas o escapar espacios.

cd "Mi Carpeta"
# o
cd Mi\ Carpeta

Checklist final (si puedes hacer esto, ya subiste de nivel)

• Sé dónde estoy (pwd) y puedo listar a detalle (ls -la).
• Puedo navegar rápido con cd, .. y ~.
• Creo carpetas/archivos (mkdir -p, touch).
• Copio y muevo sin perder cosas (cp, mv).
• Leo logs con less, tail -f.
• Busco archivos y texto (find, grep -RIn / rg).
• Entiendo pipes y redirecciones (|, >, >>, 2>).
• Puedo matar procesos y liberar puertos (ps, lsof, kill).
• No uso sudo como curita; primero diagnóstico permisos.
• Uso Ctrl+R para revivir comandos y hago aliases básicos.

FAQ

1) ¿Qué terminal debería usar en macOS, Linux y Windows?

• macOS: Terminal o iTerm2 + zsh.
• Linux: tu terminal favorita (GNOME Terminal, Kitty, Alacritty).
• Windows: WSL2 (Ubuntu) es la ruta más cercana a “vida real” dev.

2) ¿Bash o zsh? ¿Cuál aprendo?

Aprende los conceptos (comandos, pipes, permisos). Bash y zsh se parecen muchísimo para el día a día. Si estás en macOS moderno, probablemente ya estás en zsh.

3) ¿Cómo sé qué hace un comando antes de ejecutarlo?

Lee el manual:

man ls
man grep

Y la ayuda rápida:

ls --help

Tip: si el comando viene de un blog random, sospecha y valida.

4) ¿Qué significa ./script.sh?

./ indica “ejecuta el archivo desde el directorio actual”. Si haces script.sh a secas, el sistema lo busca en tu PATH.

5) ¿Cuáles son los comandos “prohibidos” para principiantes?

No son prohibidos, pero sí de alto riesgo si no entiendes:

• rm -rf (especialmente con rutas absolutas o variables)
• chmod -R 777 (abre demasiado)
• sudo en cadena sin saber por qué
• Pegar comandos que modifican disco/particiones (dd, mkfs, etc.)

Siguiente episodio

En el S01E03 vamos a subir el juego: Git sin lágrimas. Lo mínimo para trabajar en equipo, revertir errores y sobrevivir a un merge conflict sin invocar a Cthulhu.