La terminal: tu nueva mejor amiga

La terminal parece cosa de hackers de película. Pantalla negra, texto verde, comandos crípticos. Pero la realidad es mucho más simple: la terminal es solo otra forma de hablarle a tu computadora. En vez de hacer clic en íconos, escribes instrucciones. Y una vez que le pierdes el miedo, es más rápida que cualquier interfaz gráfica.

En esta guía vas a aprender los comandos esenciales, cómo moverte por tu sistema de archivos, manipular archivos y empezar a automatizar tareas repetitivas.

---

¿Qué es la terminal?

La terminal (también llamada “consola”, “línea de comandos” o “shell”) es un programa que te permite ejecutar comandos de texto. El shell es el intérprete que lee lo que escribes y lo traduce en acciones.

En macOS y Linux, el shell por defecto es zsh (antes era bash). En Windows, tienes PowerShell o puedes usar Git Bash (que viene con Git) o WSL (Windows Subsystem for Linux) para tener un entorno Linux real.

Abrir la terminal

• macOS: Cmd + Espacio, escribe “Terminal”, presiona Enter
• Linux: Ctrl + Alt + T (en la mayoría de distribuciones)
• Windows: Busca “PowerShell” o “Git Bash” en el menú inicio

La terminal en tres sistemas operativos: la misma idea, diferentes apariencias.

---

El prompt y tu primer comando

Cuando abres la terminal, ves algo como esto:

~ %

Esto se llama el prompt. Te dice dónde estás. El ~ significa tu directorio home (tu carpeta personal). El % o $ indica que la terminal está lista para recibir comandos.

Escribe tu primer comando:

pwd

pwd significa print working directory. Te dice en qué carpeta estás:

/Users/tu-nombre

---

Navegar por el sistema de archivos

Ver qué hay en el directorio actual

ls              # Lista archivos del directorio actual
ls -l           # Lista con detalles (permisos, tamaño, fecha)
ls -a           # Incluye archivos ocultos (los que empiezan con .)
ls -la          # Combina ambos: detalles + ocultos

El sistema de archivos como un árbol: directorios como ramas, archivos como hojas.

Moverse entre directorios

cd proyectos            # Entra al directorio 'proyectos'
cd ..                   # Sube un nivel (al directorio padre)
cd ~                    # Vuelve a tu home
cd /                    # Ve a la raíz del sistema
cd -                    # Vuelve al último directorio donde estuviste

Truco: usa Tab para autocompletar nombres de archivos y directorios. Si escribes cd pro y presionas Tab, la terminal completa a cd proyectos/ si no hay ambigüedad.

Crear y eliminar directorios

mkdir mi-proyecto           # Crea un directorio
mkdir -p a/b/c              # Crea directorios anidados
rmdir directorio-vacio      # Elimina un directorio vacío
rm -rf directorio-con-cosas # Elimina un directorio con todo su contenido

Cuidado con rm -rf: elimina sin preguntar y sin enviar a la papelera. No hay “deshacer”.

---

Trabajar con archivos

Crear archivos

touch notas.txt             # Crea un archivo vacío
echo "Hola, mundo" > hola.txt  # Crea un archivo con contenido

Ver contenido de archivos

cat archivo.txt             # Muestra todo el contenido
less archivo.txt            # Muestra página por página (q para salir)
head archivo.txt            # Muestra las primeras 10 líneas
head -20 archivo.txt        # Muestra las primeras 20 líneas
tail archivo.txt            # Muestra las últimas 10 líneas
tail -f log.txt             # Sigue el archivo en tiempo real (útil para logs)

Copiar, mover y renombrar

cp original.txt copia.txt       # Copiar archivo
cp -r carpeta/ copia-carpeta/   # Copiar directorio recursivamente
mv archivo.txt nuevo-nombre.txt # Renombrar
mv archivo.txt otra-carpeta/    # Mover a otro directorio
rm archivo.txt                  # Eliminar archivo

Nota: mv sirve tanto para renombrar como para mover. En el fondo, es lo mismo: cambiar la ruta del archivo.

Buscar archivos

find . -name "*.py"             # Busca archivos .py en el directorio actual y subdirectorios
find . -type d                  # Busca solo directorios
find . -name "*.py" -mtime -7   # Archivos .py modificados en los últimos 7 días

---

Comandos útiles del día a día

Información del sistema

whoami              # Tu nombre de usuario
date                # Fecha y hora actual
uname -a            # Información del sistema operativo
df -h               # Espacio en disco disponible
free -h             # Memoria RAM disponible (Linux)
top                 # Procesos activos (usa q para salir)

Redes básicas

ping google.com         # Verifica conectividad
curl https://api.example.com    # Hace una petición HTTP y muestra la respuesta
wget https://ejemplo.com/archivo.zip   # Descarga un archivo

Permisos de archivos

ls -l archivo.txt       # Ver permisos: -rw-r--r--
chmod +x script.sh      # Hacer ejecutable
chmod 755 script.sh     # Permisos específicos (rwxr-xr-x)

Los permisos se leen así:

• r = read (lectura)
• w = write (escritura)
• x = execute (ejecución)

-rwxr-xr--
│  │  │
│  │  └── Otros: solo lectura
│  └── Grupo: lectura y ejecución
└── Dueño: lectura, escritura y ejecución

---

Redirecciones y pipes: la magia de la terminal

Redirección de output

Por defecto, los comandos muestran su resultado en pantalla. Pero puedes redirigirlo:

ls > lista.txt              # El output de ls va al archivo lista.txt
ls >> lista.txt             # Agrega al final del archivo (no lo sobrescribe)
sort < nombres.txt          # Lee nombres.txt como input

Pipes: conectar comandos

El pipe (|) conecta la salida de un comando con la entrada de otro:

ls -la | grep ".py"             # Lista archivos y filtra solo los .py
cat log.txt | grep "error"      # Busca 'error' en el log
cat datos.txt | sort | uniq     # Ordena y elimina duplicados
ps aux | grep python | wc -l    # Cuenta cuántos procesos de Python hay

Pipes de Unix: la salida de un comando se convierte en la entrada del siguiente.

Buscar en archivos

grep "error" log.txt            # Busca 'error' en log.txt
grep -r "funcion" src/          # Busca 'funcion' recursivamente en src/
grep -n "import" archivo.py     # Muestra el número de línea
grep -i "hola" archivo.txt      # Ignora mayúsculas/minúsculas

---

Variables de entorno

Las variables de entorno son valores que el sistema y los programas usan para configurarse:

echo $HOME          # Tu directorio home
echo $PATH          # Dónde busca el sistema los ejecutables
echo $USER          # Tu nombre de usuario
env                 # Lista todas las variables de entorno

Establecer variables

export NOMBRE="Ada"     # Crea una variable para esta sesión
echo $NOMBRE            # Ada

Para que una variable persista entre sesiones, agrégala a tu archivo de configuración (~/.zshrc en macOS/Linux o ~/.bashrc en Linux con bash):

# En ~/.zshrc
export PATH="$HOME/.local/bin:$PATH"
export EDITOR="code"

---

Alias: atajos personalizados

Los alias te permiten crear comandos cortos para comandos largos:

# En ~/.zshrc o ~/.bashrc
alias ll="ls -la"
alias ..="cd .."
alias gs="git status"
alias gc="git commit"
alias gp="git push"
alias python="python3"

Después de agregarlos, recarga la configuración:

source ~/.zshrc

---

Scripts de bash: automatizar tareas

Puedes escribir una secuencia de comandos en un archivo y ejecutarlo:

#!/bin/bash
# mi-script.sh — Un script simple

echo "Iniciando backup..."
mkdir -p backups
cp -r proyecto/ backups/proyecto-$(date +%Y%m%d)/
echo "Backup completado en $(date)"

Hazlo ejecutable y ejecútalo:

chmod +x mi-script.sh
./mi-script.sh

El #!/bin/bash al inicio se llama shebang y le dice al sistema qué intérprete usar.

---

Un poco de historia: de dónde viene la terminal

La terminal tiene sus raíces en los teletipos (TTY) de los años 60 — máquinas electromecánicas que imprimían texto en papel rollo. Cuando las computadoras eran enormes y costaban millones, no tenías una pantalla personal. Tenías una terminal conectada a un mainframe compartido.

El teletipo ASR-33: el ancestro de la terminal moderna, imprimiendo comandos en papel rollo.

En 1971, Ken Thompson y Dennis Ritchie crearon Unix en Bell Labs, y con él la filosofía que sigue vigente hoy: programas pequeños que hacen una cosa bien y se pueden combinar. Los pipes (|) fueron inventados por Doug McIlroy en 1973, y esa idea de conectar comandos como piezas de Lego es lo que hace a la terminal tan poderosa.

La terminal moderna que usas hoy es descendiente directa de esas ideas. El shell bash fue creado por Brian Fox en 1989 para el proyecto GNU, y zsh (el default de macOS desde 2019) fue creado por Paul Falstad en 1990.

---

Por qué importa

La terminal no es solo una alternativa a la interfaz gráfica. Es más poderosa porque:

• Automatiza: un comando puede hacer lo que te tomaría 20 clics.
• Componibilidad: puedes combinar comandos simples en pipelines complejos.
• Remoto: cuando trabajas con servidores, la terminal es tu única interfaz.
• Reproducibilidad: puedes guardar comandos en scripts y repetirlos exactamente.
• Velocidad: una vez que conoces los comandos, es más rápido que navegar con el mouse.

Todo programador profesional usa la terminal a diario. No es opcional.

---

La IA y la terminal

Lo bueno

• Generar comandos: describe lo que quieres hacer y la IA te da el comando exacto. “¿Cómo encuentro todos los archivos .log mayores a 100MB?”
• Explicar comandos complejos: pega un comando que no entiendes y la IA lo desglosa parte por parte.
• Crear scripts: describe una tarea repetitiva y la IA genera el script de bash.
• Debuggear errores de terminal: pega el error y la IA te dice qué significa y cómo resolverlo.

Lo que no debes hacer

• No ejecutes comandos que no entiendes solo porque la IA los sugirió. Un rm -rf mal puesto puede borrar tu disco entero.
• No le pegues output de terminal con datos sensibles (tokens, paths con nombres reales de tu empresa, IPs internas).
• No delegues la verificación. Siempre revisa qué va a hacer un comando antes de ejecutarlo, especialmente si tiene rm, mv o redirecciones (>).

---

Desafío: organiza tu proyecto desde la terminal

Objetivo: demostrar que puedes navegar y manipular archivos sin interfaz gráfica.

Tu tarea:

1. Abre la terminal y navega a tu home
2. Crea una estructura de directorios para un proyecto:

   mi-proyecto/
   ├── src/
   │   ├── main.py
   │   └── utils/
   │       └── helpers.py
   ├── tests/
   │   └── test_main.py
   ├── docs/
   │   └── README.md
   └── .gitignore

3. Crea los archivos con contenido mínimo usando echo y >
4. Usa find para listar todos los archivos .py
5. Usa grep para buscar una palabra en todos los archivos
6. Usa wc -l para contar cuántas líneas tiene cada archivo
7. Crea un alias ll para ls -la en tu configuración de shell

Bonus: escribe un script setup.sh que cree toda la estructura automáticamente con un solo comando.

---

Para seguir explorando

• The Command Line Crash Course — tutorial de Mozilla para principiantes.
• Explainshell — pega cualquier comando y te explica cada parte visualmente.
• Bash Academy — el manual oficial de bash.
• OverSimplified — The History of Unix — video entretenido sobre la historia de Unix.

---

Resumen

• La terminal es una interfaz de texto para hablarle a tu computadora. El shell interpreta tus comandos.
• pwd, ls, cd son los comandos básicos para navegar el sistema de archivos.
• mkdir, touch, cp, mv, rm manipulan archivos y directorios.
• Los pipes (|) conectan comandos: la salida de uno es la entrada del siguiente.
• grep busca texto, find busca archivos, cat muestra contenido.
• Las variables de entorno ($HOME, $PATH) configuran el comportamiento del sistema.
• Los alias crean atajos para comandos largos.
• Los scripts de bash automatizan tareas repetitivas.
• La terminal viene de los teletipos de los 60 y la filosofía Unix de programas pequeños combinables.

En la próxima guía vamos a explorar introducción a la IA: LLMs, asistentes y cómo usarlos bien — qué son los modelos de lenguaje, cómo funcionan por dentro y cómo sacarles provecho sin perder tu criterio como programador.