A todos nos gusta simplificarnos la vida. Si eres de los míos y te apasiona cacharrear con tu ordenador, seguro que pasas una buena parte del día frente a esa ventana oscura llena de letras llamada terminal. Y si es así, también te habrás dado cuenta de que, casi sin querer, acabas haciendo exactamente las mismas cosas una y otra vez. Escribir el comando para levantar tus contenedores de Docker, teclear los parámetros exactos de esa copia de seguridad que haces los domingos, o incluso el clásico comando para actualizar todo el sistema operativo. Son tareas que hacemos mecánicamente, pero que nos roban tiempo, energía y paciencia. Para solucionar esto, muchos de nosotros recurrimos a crear pequeños scripts de texto que guardamos en cualquier carpeta o añadimos alias extraños en la configuración de nuestra terminal. Sin embargo, al cabo de unas semanas, ya no nos acordamos de qué hacía cada cosa o dónde guardamos aquel archivo tan útil. Hoy te quiero hablar de la herramienta definitiva para poner orden en este caos: se trata de Just.
La fatiga de la terminal y por qué los humanos somos tan malos recordando cosas
El cerebro humano es una máquina maravillosa para el pensamiento creativo, la resolución de problemas abstractos y la toma de decisiones complejas, pero es terriblemente ineficiente para memorizar cadenas exactas de caracteres y parámetros de consola. Quien te diga que se acuerda de todos los parámetros de rsync o de los comandos detallados de administración de bases de datos sin recurrir a la ayuda del buscador, probablemente te esté mintiendo.
En nuestro día a día con Linux, solemos caer en el hábito de recopilar comandos útiles en un archivo de notas que llamamos con nombres tan genéricos como comandos_utiles.txt o chuleta.txt. El problema con este enfoque es que estas notas son estáticas. Para usarlas, tienes que abrir el archivo, buscar la línea que necesitas, seleccionarla con el ratón, copiarla, volver a la ventana activa de tu terminal, pegarla y luego, con un poco de suerte y habiendo modificado las rutas pertinentes, pulsar la tecla de retorno. Es un proceso tedioso que interrumpe tu flujo de trabajo de forma constante.
Otra alternativa muy habitual es el uso de alias en nuestro archivo de configuración del intérprete de comandos, como el conocido .bashrc o .zshrc. Aunque los alias son geniales para atajos muy sencillos de una sola palabra, se vuelven insostenibles cuando necesitas ejecutar secuencias de comandos complejas, añadir lógica condicional o compartir esas mismas automatizaciones con otras personas de tu equipo o de tu comunidad. Además, si cambias de ordenador, tienes que preocuparte de migrar todos esos archivos de configuración personales si no quieres volver a sentirte completamente desarmado frente a la pantalla.
¿Qué es Just y por qué ha venido a salvar nuestras terminales?
Para romper con este círculo vicioso de la repetición y el olvido nace Just. No estamos hablando del último éxito musical del momento, sino de un excelente ejecutor de comandos o command runner moderno. Está escrito en Rust, lo que significa que es absurdamente rápido, seguro y ligero. Se distribuye como un único archivo ejecutable binario que no requiere de engorrosos entornos de ejecución para funcionar, a diferencia de otras herramientas escritas en lenguajes como Python o Node.js que a menudo te obligan a lidiar con versiones de librerías y dependencias rotas.
Lo más importante que debes entender es que Just no es un sistema de construcción de software o build system. Su única y exclusiva misión es ser un libro de recetas para tus comandos favoritos de la terminal. Lee un archivo de configuración muy simple llamado justfile y ejecuta exactamente lo que tú le indicas, sin inventarse reglas extrañas de fondo ni intentar adivinar dependencias implícitas entre archivos.
Comparativa directa: Por qué prefiero Just frente a Make y Task
Si llevas algún tiempo en esto del desarrollo de software o la administración de sistemas, es muy probable que te estés preguntando por qué necesitas otra herramienta más si ya existen alternativas consolidadas de toda la vida. Vamos a poner las cartas sobre la mesa y analizar cómo se comporta Just frente a sus dos competidores más directos: Make y Task.
El clásico Make
Desarrollado originalmente en los años setenta, Make es el rey indiscutible de la compilación de proyectos en C y C++. Su objetivo es analizar qué archivos de código fuente han cambiado para compilar únicamente lo necesario, ahorrando valiosos minutos en ordenadores antiguos. Sin embargo, usarlo simplemente para automatizar tareas rutinarias de mantenimiento es como matar moscas a cañonazos.
Make tiene una sintaxis muy peculiar y estricta. Si por error pones espacios en lugar de un tabulador real al principio de una línea de comando, el sistema fallará con un mensaje de error críptico que te dejará rascándote la cabeza. Además, Make asume que cada tarea que defines corresponde a un archivo físico en el disco duro. Si tienes una receta llamada clean para borrar temporales y por casualidad existe una carpeta llamada clean en ese mismo directorio, Make decidirá que no hay nada que hacer porque la tarea ya está actualizada, obligándote a usar trucos raros como declarar la tarea como .PHONY para saltarte este comportamiento.
La alternativa Task
Task es otro gran ejecutor de comandos moderno, escrito en Go, que ha ganado mucha popularidad en los últimos tiempos. Su principal característica es que utiliza archivos de configuración en formato YAML.
Aunque YAML es un estándar muy extendido en el mundo de la tecnología, puede volverse increíblemente verboso y estructurado para tareas sencillas. Si lo único que quieres es asociar una etiqueta a un comando de una línea, tener que anidar llaves, guiones, sangrías estrictas de espacios y parámetros estructurados de YAML acaba resultando pesado y poco natural.
La sencillez de Just
Just coge lo mejor de ambos mundos. Ofrece una sintaxis limpia, natural y muy similar a la de un archivo de configuración simplificado. No requiere tabuladores obligatorios (puedes usar los espacios que quieras), no se confunde con archivos físicos del disco duro y es capaz de ejecutar tus comandos de forma inmediata y sin rodeos.
Manos a la obra: Cómo se instala Just en tu sistema
La instalación de Just es sumamente sencilla y está soportada en prácticamente cualquier sistema operativo moderno, ya sea que utilices Linux, macOS o Windows.
Si utilizas una distribución basada en Debian o Ubuntu, puedes instalarlo directamente desde los repositorios oficiales abriendo tu consola y ejecutando:
sudo apt install justPara los usuarios de Arch Linux, el paquete está disponible en los repositorios principales y se puede instalar con:
sudo pacman -S justEn el caso de que utilices el gestor de paquetes de Rust, conocido como Cargo, o si quieres asegurarte de tener la versión más reciente del software con todas sus novedades actualizadas, puedes compilarlo e instalarlo de forma directa con un solo comando:
cargo install justTambién tienes la opción de descargar los binarios precompilados directamente desde su sección de lanzamientos en su repositorio oficial de GitHub, lo que te permite empezar a usarlo en un segundo sin necesidad de instalar herramientas de compilación adicionales en tu máquina.
Anatomía de un archivo justfile y tus primeras recetas
Para empezar a utilizar esta herramienta, el único requisito es crear un archivo de texto plano con el nombre justfile (o .justfile) en la raíz de la carpeta del proyecto en el que vayas a trabajar.
Vamos a ver un ejemplo muy didáctico de cómo estructurar tus primeras recetas básicas para familiarizarte con su funcionamiento:
# Este es mi primer recetario de Just
default:
@just --list
up:
docker compose up -d
down:
docker compose down
status:
docker compose psEchemos un vistazo detallado a lo que está ocurriendo en este archivo de configuración:
En primer lugar, los comentarios se declaran utilizando el símbolo de la almohadilla, igual que harías en cualquier script tradicional de terminal. Esto te permite documentar qué hace cada receta para que tú o cualquiera que lea el archivo entienda perfectamente su propósito.
La primera receta que se define en el archivo (en este caso, la hemos llamado default) tiene un significado especial. Si ejecutas el comando just a secas en tu terminal sin especificar ningún parámetro adicional, se ejecutará automáticamente esta primera tarea. En nuestro ejemplo, hemos utilizado la llamada @just –list. El símbolo de la arroba al principio le indica a Just que no queremos que muestre el comando que está ejecutando en pantalla, sino solo su resultado directo. El parámetro –list le pide a la herramienta que muestre un menú interactivo con todas las recetas disponibles en el archivo y sus correspondientes comentarios explicativos.
Las recetas restantes son directas y muy descriptivas. En lugar de tener que recordar la sintaxis completa de docker compose up -d o docker compose down, simplemente tendrás que teclear en tu consola just up o just down para controlar tus servicios contenedores favoritos en un abrir y cerrar de ojos.
Gestión avanzada de variables y parámetros para recetas dinámicas
Las recetas estáticas son de gran ayuda, pero el verdadero poder de Just se despliega cuando necesitas trabajar con datos dinámicos que cambian en cada ejecución de la tarea.
Definiendo variables básicas
Puedes declarar variables al principio de tu archivo justfile de una forma muy limpia, usando el operador de asignación de dos puntos e igual:
version := "1.0.0"
directorio_destino := "/var/www/html"
backup:
tar -czf copia-{{version}}.tar.gz {{directorio_destino}}Como ves, para utilizar una variable dentro de un comando, solo tienes que envolver su nombre con una doble llave, imitando el sistema de plantillas de herramientas populares como Jinja o Ansible.
Recibiendo argumentos desde la terminal
¿Qué pasa si quieres que la receta se adapte a un valor que tú le pasas al vuelo cuando la invocas en tu consola? Just te permite definir argumentos en tus recetas como si fueran funciones de un lenguaje de programación:
saludar nombre="Mundo":
echo "¡Hola, {{nombre}}!"En este caso, si ejecutas simplemente just saludar, el argumento nombre tomará el valor predeterminado de Mundo y la salida será ¡Hola, Mundo!. Pero si decides ejecutar just saludar Lorenzo, la variable se actualizará al vuelo con el nombre proporcionado y la salida cambiará a ¡Hola, Lorenzo!.
Si necesitas capturar un número indeterminado de argumentos o una ruta con espacios complejos, puedes utilizar un asterisco antes del nombre del parámetro para capturarlo todo:
buscar *terminos:
grep -rn "{{terminos}}" ./srcAtributos de receta: Personalización fina y seguridad
Just te ofrece un abanico muy completo de atributos que puedes colocar justo encima de la definición de tus recetas para modificar drásticamente la forma en la que se ejecutan o se muestran al usuario.
El atributo de confirmación de seguridad
Uno de mis atributos preferidos es [confirm]. Es una medida de seguridad fantástica para evitar accidentes fatales en tus servidores:
[confirm]
limpiar-base-datos:
psql -U admin -d produccion -c "DROP DATABASE clientes;"Cuando intentas ejecutar just limpiar-base-datos, el sistema se detendrá de inmediato y te preguntará de forma interactiva en la pantalla si estás completamente seguro de que deseas continuar con el proceso. Solo si pulsas la tecla adecuada se llevará a cabo el comando, protegiendo tus datos más sensibles de un borrado accidental por un despiste de teclado.
Ocultando recetas auxiliares
A veces necesitas crear recetas internas que sirven como pasos intermedios para otras tareas, pero que no quieres que aparezcan visibles en el menú general cuando listas los comandos disponibles. Para lograr esto, basta con utilizar el atributo [private]:
[private]
preparar-entorno:
mkdir -p /tmp/datos
ejecutar-proceso: preparar-entorno
python3 procesar.pyAl hacerlo, la receta preparar-entorno se ejecutará siempre antes de ejecutar-proceso de forma automática gracias a las dependencias, pero permanecerá oculta y no afeará tu listado general de comandos públicos.
Adaptando recetas según el sistema operativo
Si trabajas en entornos mixtos donde colaboras con personas que utilizan diferentes plataformas, puedes limitar la ejecución de ciertas recetas utilizando atributos de sistema operativo como [linux], [macos] o [windows]:
[linux]
actualizar:
sudo apt update && sudo apt upgrade -y[macos]
actualizar: brew update && brew upgrade
De esta forma, puedes tener una única receta llamada actualizar que se comportará de forma inteligente según el ordenador de la persona que la ejecute, ahorrando tiempo de configuración a todo tu equipo.
La regla de oro de Just: Líneas independientes frente a Shebangs
Este es el punto clave que todo usuario que se inicia en Just debe comprender a la perfección para no llevarse sorpresas desagradables al ejecutar sus tareas.
El problema de los subprocesos individuales
Por defecto, Just ejecuta cada una de las líneas que componen una receta en una sesión de terminal o subshell completamente independiente de la anterior. Vamos a verlo con un ejemplo de lo que no debes hacer:
# Esta receta fallará en su propósito
mi_receta_fallida:
cd /var/log
tail -n 10 syslogAunque a primera vista parezca un script correcto, cuando ejecutas esta tarea, la primera línea inicia una sesión de terminal, cambia el directorio de trabajo a /var/log y se cierra. La segunda línea inicia una sesión de terminal completamente nueva que arranca desde el directorio donde está guardado el archivo justfile (es decir, ignora por completo el cambio de directorio de la línea superior) e intenta buscar el archivo syslog, arrojando un error de archivo no encontrado.
La solución definitiva: Los Shebangs
Para solucionar esto sin tener que concatenar todos tus comandos con operadores lógicos en una única línea infinita, Just ofrece soporte nativo para Shebangs. Si la primera línea de tu receta comienza con los símbolos de la almohadilla y la exclamación, la herramienta empaquetará todo el contenido de la receta en un script temporal y lo ejecutará completo bajo el intérprete que tú hayas elegido.
# Esta receta funcionará a la perfección
mi_receta_correcta:
#!/usr/bin/env bash
cd /var/log
echo "Mostrando las últimas líneas del registro del sistema:"
tail -n 10 syslogEsta característica es un auténtico superpoder. Significa que no estás limitado en absoluto a usar la shell por defecto del sistema operativo. Puedes escribir recetas utilizando scripts de Python, tareas automatizadas con Node.js o incluso pequeños scripts en Ruby o Perl, todo perfectamente integrado y ordenado dentro de un único archivo de configuración unificado.
Características premium: Módulos, autocompletado y búsqueda difusa
Si tu colección de tareas empieza a crecer y a volverse inmanejable, no te preocupes, porque los desarrolladores de esta fantástica herramienta han pensado en todo lo necesario para escalar tus proyectos de forma cómoda.
Modularización con importaciones
Just te permite importar archivos de configuración externos para mantener tu justfile principal lo más limpio y estructurado posible. Puedes tener módulos separados especializados en diferentes áreas del proyecto:
# Archivo justfile principal
import "módulos/docker.just"
import "módulos/sysadmin.just"
default:
@just --listCada módulo mantiene sus propias variables, dependencias y recetas de forma aislada, permitiéndote estructurar tu espacio de trabajo como si fuera un proyecto de programación profesional.
La búsqueda difusa interactiva con just choose
Cuando tienes decenas de recetas acumuladas en tu archivo y no recuerdas exactamente el nombre de la que necesitas ejecutar en ese momento, puedes invocar la búsqueda difusa interactiva utilizando el comando:
just --chooseSi tienes instalado el popular filtro de búsqueda difusa fzf en tu ordenador, Just lo utilizará para mostrarte un menú visual en tu terminal. Podrás empezar a escribir letras sueltas y el sistema irá filtrando en tiempo real entre todos tus comandos disponibles, permitiéndote seleccionar y ejecutar el comando adecuado con un simple retorno de carro.
El día en que mi IA (Hermes) se volvió perezosa y me olvidó
Como bien sabes, en los últimos meses estoy dedicando mucho tiempo y cariño a desarrollar y exprimir a fondo a Hermes, mi asistente de inteligencia artificial local. Con Hermes gestiono y automatizo prácticamente todo en mi vida, desde la revisión y formateo de artículos en mi blog personal hasta la administración de mis propios servidores.
Pero las inteligencias artificiales, por muy avanzadas y sorprendentes que parezcan, a veces sufren de una alarmante falta de constancia operativa. Son extremadamente creativas y capaces, pero no son metódicas por naturaleza cuando interactúan con un sistema operativo real.
Déjame que te cuente mi momento de máxima pereza de esta semana. Normalmente, cuando salgo a correr por las tardes, me gusta llevar un registro exacto de mis marcas físicas: los kilómetros recorridos, las pulsaciones medias, el ritmo por kilómetro, la elevación acumulada, etc. Al volver a casa, cansado y sudoroso, solía sentarme frente al ordenador y dictarle un archivo de audio a Hermes contándole cómo había ido el entrenamiento de carrera. Él se encargaba de transcribir mi voz, extraer las variables y guardarlas en una hoja de registro.
Pero el otro día me pudo la vagancia absoluta. No tenía fuerzas ni para hablar. Así que decidí hacer algo diferente: le saqué una captura de pantalla directa a la aplicación de mi reloj inteligente deportivo donde aparecía todo el resumen gráfico de la carrera y se la envié a Hermes directamente a través de nuestro canal privado de Telegram.
Para mi grata sorpresa, Hermes analizó la imagen, detectó que se trataba de un entrenamiento deportivo, buscó en su entorno la herramienta de reconocimiento de caracteres Tesseract para llevar a cabo un proceso de OCR, leyó a la perfección cada número del gráfico y guardó los datos de la carrera sin fallar ni una sola cifra. Me quedé maravillado y pensé que ya no tendría que dictar nunca más mis marcas.
Al día siguiente, tras otra dura sesión de carrera, repito exactamente la misma operación con toda la ilusión del mundo. Hago la captura de pantalla y se la envío por Telegram esperando ver la magia de nuevo. ¿Y cuál fue la respuesta de mi asistente de inteligencia artificial? Un escueto: Oye Lorenzo, me has enviado una imagen de un entrenamiento deportivo. ¿Qué quieres que haga con ella?.
Me quedé estupefacto. Le recordé pacientemente que el día anterior había realizado un reconocimiento de texto para extraer las marcas de mi carrera. Su respuesta de vuelta fue para echarse a llorar: ¡Ay, de veras lo lamento mucho! He estado buscando en mi entorno del sistema y no encuentro ninguna herramienta de lectura instalada para procesar la captura de pantalla.
Se había olvidado de cómo encontrar la ruta del binario de Tesseract, cómo estructurar el script temporal para el reconocimiento de imágenes y cómo mapear las variables. En definitiva, su memoria operativa se había disipado de un día para otro debido al contexto variable del modelo de lenguaje.
Fue en ese preciso momento cuando se me encendió la bombilla y comprendí el verdadero valor de Just en el ecosistema moderno de la inteligencia artificial. Las IA y los agentes virtuales necesitan una capa intermedia estable y rígida para interactuar con nuestro hardware. No podemos confiar en que recuerden flujos de trabajo de terminal complejos y con muchos pasos.
La solución definitiva consistió en crear un archivo justfile dedicado en el directorio de trabajo de Hermes con recetas bien estructuradas para cada una de sus tareas habituales de mantenimiento y procesamiento. Ahora, cuando le pido a mi asistente que procese una imagen o que actualice mis servicios, él no tiene que inventar los comandos de consola al vuelo; simplemente llama a la receta de Just pertinente en segundo plano y todo se ejecuta con una precisión matemática.
Conclusiones: El valor de la documentación viva y ejecutable
Automatizar no es solo una forma de ahorrar un puñado de segundos en tu rutina de trabajo diario; es, ante todo, una manera inteligente de documentar tus propios procesos de tal modo que sean directamente ejecutables por cualquiera (ya sea un compañero de equipo, tu yo del futuro dentro de un año, o tu asistente virtual de inteligencia artificial despistado).
Cuando acostumbras a acompañar tus proyectos con un archivo justfile bien estructurado, estás creando un mapa interactivo de todo lo que tu sistema es capaz de hacer. Se acabó el tener que rebuscar en antiguos manuales de texto plano o probar comandos peligrosos a ciegas en tu terminal con el temor de romper algo importante.
Anímate a instalar Just hoy mismo en tu ordenador de trabajo. Empieza creando un par de recetas muy sencillas para tus comandos más habituales y ya verás cómo, en muy poco tiempo, se convierte en una herramienta totalmente imprescindible en tu flujo diario de cacharreo tecnológico.