Anotaciones por Pablo Caro

ku: Kubernetes desde la terminal como un ninja

2026-08-03T00:00:00+02:00

He vuelto a trabajar con Kubernetes. Tengo desplegada en local una arquitectura de micrositios — varios namespaces, deployments, servicios, ingresses — y necesitaba una forma rápida de moverme por todo sin estar constantemente tirando de kubectl get y kubectl describe a mano. La memoria muscular del kubectl está bien, pero para navegar un cluster con soltura necesitas ver el panorama completo.

Entré a GitHub y encontré ku, una TUI para Kubernetes de un desarrollador noruego. Es rápida, va solo con teclado y está claramente inspirada en k9s, Lens y lazygit. Me gustó desde el primer ku.

Instalación¶

curl -fsSL https://raw.githubusercontent.com/bjarneo/ku/main/install.sh | sh

O con Go:

go install github.com/bjarneo/ku@latest

Lo que me ha convencido¶

Read-only por defecto. Arrancas y no puedes romper nada. Para editar, borrar o escalar tienes que activar el modo edición con Shift+E. El header muestra un chip verde ● READ-ONLY o rojo ● EDIT para que siempre sepas en qué modo estás. Para los que tenemos dedos de mantequilla, esto es paz mental.
Cockpit al arrancar. Una vista general del cluster: versión del server, estado de los nodos, gauges de CPU y memoria en vivo, pods por fase, deployments listos y warnings recientes (deduplicados, con contador de recurrencia). Se refresca solo cada pocos segundos.
Tablas con las columnas correctas. Usa la misma representación Table de la API que kubectl get, así que las columnas son exactamente las que esperas para cada recurso. Los CRDs también funcionan. Las celdas tienen color semántico: verde sano, amarillo transitorio, rojo roto. La columna ordenada muestra la dirección.
Layout lazygit: panel izquierdo con la navegación de recursos, Tab para cambiar entre paneles, barra de estado inferior que muestra solo las teclas relevantes para lo que tienes seleccionado.
Resúmenes curados. Enter sobre un objeto abre un resumen específico para ese tipo: los pods muestran uso live, health, requests/limits; los servicios, ingress, configmaps y secrets tienen vistas adaptadas. d o y abre el YAML completo con syntax highlighting.
Logs con follow. l sobre un pod streamea los logs. Puedes filtrar con regex, copiar líneas, cambiar entre instancia actual y anterior, y hacer toggle de auto-scroll. Todo dentro de la TUI.
Shell en pods y nodos. s sobre un pod abre una shell interactiva (bash o sh) en un overlay con terminal virtual. Sobre un nodo, levanta un pod de debug privilegiado con chroot /host. Ctrl+\ detacha.
Port-forward de servicios. p sobre un Service y eliges el puerto. Puedes mapear 8080:http o 18080:80. Los forwards activos se ven en el header y los gestionas desde la paleta de comandos.
Comando kubectl equivalente. C te muestra el comando kubectl que replica la vista actual. Ideal para aprender o para copiarlo a un script.
Documentación de Kubernetes integrada. O abre la doc upstream del recurso seleccionado en el navegador.
Sidebar configurable. Con ku config init generas un ~/.config/ku/config.yaml donde puedes añadir CRDs al menú lateral. Soporta recursos con grupo (scaledobjects.keda.sh, certificates.cert-manager.io).
Modo desarrollador. ku --dev oculta recursos de administración del cluster (nodos, PVs, namespaces, eventos) y desactiva operaciones de nodo. Para cuando solo gestionas tus propias apps.
Recuerda contexto y namespace. Los persiste en ~/.config/ku/state.json entre sesiones.

Lo que no tiene (aún)¶

No hay vista de gráficos de dependencias ni topología.
El port-forward es solo para Services, no para pods individuales.
No tiene integración con Helm.

Es un proyecto joven (~500 estrellas, ~100 commits) pero muy bien pensado. La sensación al usarlo es la de una herramienta que entiende cómo trabajas con Kubernetes y te quita fricción en cada paso. Para mi caso actual — una arquitectura de micrositios con varios namespaces — me permite saltar entre recursos, seguir logs y ver el estado general del cluster sin salir de la terminal.

Fuente original: github.com/bjarneo/ku

Pluggy — Un framework de plugins para usar en tus proyectos

2026-06-15T00:00:00+02:00

Los dos usos que más conozco de Pluggy son pytest y Datasette. pytest tiene posiblemente el ecosistema de plugins más rico de todo el ecosistema Python, y todo ese sistema — los conftest.py, los markers, los fixtures, los reporters — funciona sobre Pluggy. Datasette es el otro ejemplo que sigo de cerca: Simon Willison lo usa para que cualquiera pueda extender Datasette con nuevos hooks sin tocar el core. De hecho, Pluggy nació extrayendo el sistema de plugins de pytest para que otros proyectos como Datasette pudieran reutilizarlo.

Hace poco cayó en mis manos un artículo de Eli Bendersky — de esos que escribe cada cierto tiempo y que merecen la pena — donde analiza Pluggy como caso de estudio de sistemas de plugins. Eli tiene toda una serie sobre fundamentos de plugins y aquí aplica su framework conceptual a Pluggy.

¿Es Pluggy una shallow API?¶

Eli es bastante claro en su veredicto, y estoy de acuerdo:

Plugin frameworks are very easy to create, and the functionality they provide is relatively small compared to their large surface area. In other words, this is a shallow API.

O sea: los frameworks de plugins son fáciles de crear, y la funcionalidad que aportan es pequeña en comparación con su superficie de API. Una API shallow — poca profundidad para mucho interfaz. Tiene razón. Hacer un sistema de plugins cutre en Python son cuatro líneas con __init_subclass__ o entry_points. Pero la cuestión es qué necesitas exactamente.

Lo que realmente aporta Pluggy¶

Donde Pluggy marca la diferencia es cuando necesitas algunas de estas funcionalidades:

Registro automático via entry points — si lo necesitas
Validación de firmas de los hooks
Recolección consistente de resultados entre múltiples hooks en un mismo plugin y entre varios plugins
Ordenación de plugins con firstresult, tryfirst, trylast, etc.
Hook "wrappers" para casos de uso avanzados

Las dos que más me interesan son la validación de firmas y la ordenación de plugins. La validación de firmas te evita el clásico bug de que tu plugin tenga una función con parámetros incorrectos y el sistema lo ignore silenciosamente. Y la ordenación es clave cuando tienes varios plugins compitiendo por el mismo hook; poder decir "este va primero" o "este va al final" sin tener que implementar un priority system tú mismo ahorra mucho.

Eli concluye con la pregunta correcta:

Are these worthwhile for your project? It really depends on the project, and it's always worth keeping the tradeoff between dependencies and project effort in mind.

Pluggy es una dependencia ligera, pero sigue siendo una dependencia. Si tu sistema de plugins tiene tres hooks y dos plugins, probablemente no la necesites. Si tienes un ecosistema de plugins abierto como Datasette o pytest, tiene todo el sentido.

Cómo se usa Pluggy en tests¶

Simon Willison tiene dos TILs prácticos sobre Pluggy que merecen ser guardados aquí como referencia.

Registrar plugins temporales en tests¶

En Registering temporary pluggy plugins inside tests, Simon muestra cómo registrar un plugin de Datasette para la duración de un test concreto usando pm.register() y pm.unregister():

from datasette import hookimpl
from datasette.plugins import pm
import pytest

def test_using_test_plugin():
    class TestPlugin:
        __name__ = "TestPlugin"

        @hookimpl
        def permission_allowed(self, datasette, actor, action):
            if action.startswith("insert-api:"):
                return permissions.get(action.replace("insert-api:", ""))

    pm.register(TestPlugin(), name="undo")
    try:
        # Rest of test goes here
    finally:
        pm.unregister(name="undo")

El patrón try/finally es la clave para no dejar el plugin registrado después del test. También se puede hacer con un fixture de pytest:

@pytest.fixture
def unsafe():
    class UnsafeInsertAll:
        __name__ = "UnsafeInsertAll"

        @hookimpl
        def permission_allowed(self, action):
            if action == "insert:all":
                return True

    pm.register(UnsafeInsertAll(), name="undo")
    yield
    pm.unregister(name="undo")

Esto es muy potente para tests de integración donde necesitas mockear comportamientos de plugins sin tener que crear un plugin real.

Registrar múltiples hooks en un mismo fichero¶

En Registering the same Pluggy hook multiple times in a single file, Simon explica cómo registrar dos implementaciones del mismo hook en un solo módulo usando specname:

from datasette import hookimpl

@hookimpl(specname="menu_links", tryfirst=True)
def menu_links_1(datasette):
    return [
        {"href": datasette.urls.path("/"), "label": "Home"},
    ]

@hookimpl(specname="menu_links", trylast=True)
def menu_links_2():
    return [
        {
            "href": "http://www.example.com/",
            "label": "Link at the end",
        },
    ]

La función no se llama menu_links sino menu_links_1 y menu_links_2, y el parámetro specname le dice a Pluggy qué hook implementa cada una. Esto requiere Pluggy 1.0.0+ (que tiene ya unos años, así que probablemente lo tengas si usas algo moderno). Combinado con tryfirst/trylast, es una forma limpia de aportar múltiples contribuciones al mismo hook desde un único plugin.

Fuente original: Plugins case study: Pluggy — Eli Bendersky

Unsloth docs: la documentación más clara sobre requisitos hardware para LLMs locales

2026-06-14T00:00:00+02:00

Cuando te empiezas a interesar por ejecutar LLMs en local, la primera pregunta es siempre la misma: ¿qué hardware necesito? Y no es fácil encontrar una respuesta clara. Cada modelo publica sus requisitos en su Hugging Face, en blogs, en papers... La documentación de Unsloth hace un trabajo excelente centralizando y organizando esta información.

Tablas de VRAM para fine-tuning¶

Una de las páginas más útiles es la de requisitos del sistema, que incluye una tabla directa con VRAM necesaria para fine-tuning según el tamaño del modelo:

Parámetros	QLoRA (4-bit)	LoRA (16-bit)
3B	3.5 GB	8 GB
7B	5 GB	19 GB
8B	6 GB	22 GB
14B	8.5 GB	33 GB
27B	22 GB	64 GB
32B	26 GB	76 GB
70B	41 GB	164 GB
405B	237 GB	950 GB

Esto te permite hacer cálculos rápidos: con una RTX 3090/4090 de 24 GB puedes hacer QLoRA de modelos de hasta ~27B parámetros.

Recomiendan mantener el batch size en 1, 2 o 3 para no OOMear. Y aquí tienen benchmarks de context length.

Guías por modelo con requisitos específicos¶

Cada modelo que soportan tiene su propia guía con requisitos detallados. Algunos ejemplos:

Gemma 4: la 12B corre en 8 GB RAM (4-bit), la 26B-A4B necesita 18 GB y la 31B necesita 20 GB.
Qwen3.5: la serie Small (hasta 9B) funciona con 12 GB de RAM/VRAM. La 35B-A3B cabe en 22 GB.
Qwen3.6: la 27B corre en 18 GB, la 35B-A3B en 22 GB.
Kimi K2.5: necesitas ~240 GB+ para 10+ tokens/s con cuantización 4-bit. El modelo completo en FP16 ocupa 630 GB.
Kimi K2.6: la cuantización 2-bit dinámica necesita 350 GB+.
MiniMax M3: mínimo 133 GB RAM para la cuantización más ligera, recomendado 159 GB.
GLM-4.6 (355B): recomiendan 205 GB+ para 5 tokens/s.

Lo que hace buena esta documentación¶

Varias cosas que la hacen especialmente útil:

Tablas directas: sin rodeos. Necesitas saber VRAM para un modelo de X parámetros con Y método de fine-tuning? La tabla está ahí.
Guías por modelo: cada modelo tiene su página con tabla de requisitos, instrucciones de instalación con llama.cpp y ejemplos de uso.
Cubre inferencia y fine-tuning: no solo para entrenar, también para ejecutar modelos.
Multiplataforma: requisitos específicos para Windows (con y sin WSL), macOS (Intel y Apple Silicon), Linux, y CPU-only.
Cuantizaciones: explican qué tamaño ocupa cada cuantización (GGUF) y qué hardware necesitas para cada una. Consejo recurrente: tu RAM + VRAM combinada debe superar el tamaño del archivo cuantizado que descargues.
MTP (Multi-Token Prediction): incluyen requisitos específicos para esta técnica que predice varios tokens futuros en paralelo (~1 GB extra sobre la GGUF normal).

Todo está en unsloth.ai/docs. Si estás mirando hardware para montar un equipo de inferencia local, es la primera página que deberías visitar.

Fuente original: Unsloth Documentation

AgentsView: analíticas locales para tus coding agents

2026-06-10T00:00:00+02:00

Si usas varios coding agents (Claude Code, Codex, Pi, Cursor...) sabes lo que es perder el hilo de cuánto has gastado, qué herramientas usas más o en qué proyecto pasas más horas. Cada agente guarda sus sesiones en su propio formato y directorio, y hasta ahora no había una forma unificada de verlo todo junto.

AgentsView resuelve esto. Es una herramienta open-source (Go + Svelte 5, MIT) que indexa todas tus sesiones de coding agents en una SQLite local y te da dashboards de analíticas, tracking de costes y búsqueda full-text. Sin cuentas, sin telemetría, sin que los datos salgan de tu máquina.

Instalación¶

# macOS / Linux
curl -fsSL https://agentsview.io/install.sh | bash

# O con Homebrew (app de escritorio)
brew install --cask agentsview

Una vez instalado, arrancas el servidor y abre el dashboard en http://127.0.0.1:8080:

agentsview serve

En el primer arranque descubre automáticamente las sesiones de todos los agentes que tengas instalados.

Qué te muestra¶

Dashboard de costes: gasto diario por agente y por modelo, con precios vía LiteLLM. Calcula también los cache tokens (tanto de creación como de lectura).
Mapa de calor de actividad: visualiza tus días y horas más productivos.
Búsqueda full-text (FTS5): busca en el contenido de todas tus sesiones pasadas. Ideal para recuperar ese comando o solución que usaste hace semanas.
Visor de sesiones: navega sesión por sesión, exporta a HTML o publícala como GitHub Gist.
Estadísticas por proyecto: tokens usados, herramientas más frecuentes, duración media de sesión.
Live updates vía SSE: si tienes sesiones activas, el dashboard se actualiza solo.

CLI para costes¶

Además del dashboard web, tiene una CLI muy rápida que reemplaza a ccusage:

# Resumen diario de costes (últimos 30 días)
agentsview usage daily

# Desglose por modelo
agentsview usage daily --breakdown

# Filtrar por agente y fechas
agentsview usage daily --agent claude --since 2026-05-01

# Salida JSON para scripts
agentsview usage daily --json

Como los datos ya están indexados en SQLite, las consultas son mucho más rápidas que reparsear los archivos de sesión cada vez.

Agentes soportados¶

AgentsView auto-detecta sesiones de más de 20 agentes: Claude Code, Codex, Pi, Cursor, Copilot CLI, Gemini CLI, OpenCode, OpenHands, Qwen Code, Kimi, Warp, Forge, Zencoder y varios más. La lista completa está en el README.

PostgreSQL para equipos¶

Si trabajas en equipo, puedes sincronizar los datos a una PostgreSQL compartida:

agentsview pg push --watch   # sincronización continua
agentsview pg serve           # servir UI desde PostgreSQL

La UI en modo PostgreSQL es read-only, así que cualquiera del equipo puede ver los dashboards sin modificar datos.

Lo que no hace¶

No envía datos a ningún servidor externo. El único tráfico saliente opcional es un check de actualizaciones al arrancar (se desactiva con --no-update-check).
No requiere cuenta ni login.
No es un reemplazo del agente en sí. Es una capa de analíticas sobre lo que ya tienes.

AgentsView cubre un vacío real en el ecosistema de coding agents: tener visibilidad unificada sobre cómo y cuánto usas estas herramientas. Si usas más de un agente, merece la pena.

Detectando secretos en git con gitleaks

2026-05-28T00:00:00+02:00

gitleaks es una herramienta que escanea repositorios git —incluyendo todo el historial— en busca de secretos: claves API, contraseñas, tokens de AWS, credenciales de base de datos y más de 150 patrones predefinidos.

Instalación con gah¶

La forma más rápida de instalarlo en Linux es con gah, un descargador de assets de GitHub releases:

$ gah install gitleaks/gitleaks
Fetching release info for: gitleaks/gitleaks [latest]
Found release: v8.30.1
Downloading: gitleaks_8.30.1_linux_x64.tar.gz
############################################### 100.0%
Verifying digest sha256 551f6fc8... ...
Digest verification succeeded!
Extracting: gitleaks_8.30.1_linux_x64.tar.gz
Installing: gitleaks
Done!

Binario único, sin dependencias, listo en segundos.

Uso básico¶

Para escanear un repo local, incluyendo todo el historial de commits:

$ gitleaks git --verbose -v /ruta/al/repo

Esto rastrea cada commit y te muestra qué secretos encontró, en qué archivo y en qué línea.

Algunas flags útiles:

--no-banner: quita el banner ASCII al inicio.
--exit-code 0: no devuelve error si encuentra leaks (útil en CI).
--config .gitleaks.toml: usa una configuración personalizada con reglas propias.
--gitleaks-ignore-path .: respeta el archivo .gitleaksignore para falsos positivos.
--redact: oculta los secretos en la salida (útil en logs públicos).

También puedes escanear directorios sueltos con gitleaks dir o pipear contenido con gitleaks stdin.

¿Cuándo usarlo?¶

Antes de hacer público un repo: escanea el historial completo para asegurarte de que no hay claves coladas.
En CI/CD: añádelo como paso en GitHub Actions para que falle el build si alguien commitea un secreto.
Auditorías de seguridad: ideal para revisar repos viejos que han pasado por muchas manos.

Pre-commit hook¶

La forma más efectiva de usarlo es como hook de pre-commit para que bloquee automáticamente cualquier commit que contenga secretos:

#!/usr/bin/env bash
set -euo pipefail

if [[ "${SKIP_GITLEAKS:-}" == "1" || "${SKIP_GITLEAKS:-}" == "true" ]]; then
  echo "Skipping gitleaks pre-commit scan because SKIP_GITLEAKS=${SKIP_GITLEAKS}." >&2
  exit 0
fi

if ! command -v gitleaks >/dev/null 2>&1; then
  cat >&2 <<'EOF'
gitleaks is required by this repository's pre-commit hook but was not found.
Install gitleaks, or set SKIP_GITLEAKS=1 for an intentional one-off bypass.
EOF
  exit 1
fi

echo "Running gitleaks on staged changes..." >&2
gitleaks protect --staged --source . --redact --no-banner

Guarda esto en .githooks/pre-commit, hazlo ejecutable (chmod +x) y configura git para que use esa carpeta:

git config core.hooksPath .githooks

A partir de ahí, cada git commit escaneará los cambios en busca de secretos. Si necesitas saltártelo puntualmente, SKIP_GITLEAKS=1 git commit.

Es de esas herramientas que no necesitas hasta que la necesitas. Y cuando la necesitas, te alegras de tenerla a un gah install de distancia.

Limpiando la caché escondida de npx

2026-05-28T00:00:00+02:00

Ejecutas npx howcode para probar una herramienta, no te convence y sigues con tu vida. Repites esto unas cuantas veces y, sin darte cuenta, tienes cientos de megas acumulados en una caché que ni siquiera sabías que existía.

El problema¶

Cada vez que haces npx <paquete>, npm descarga el paquete y lo guarda en ~/.npm/_npx/. No es como npm install — aquí no hay un package.json ni un node_modules que puedas inspeccionar. Es una caché opaca que va creciendo sin que te des cuenta.

En mi caso, después de trastear con varias herramientas, tenía esto:

$ npm cache npx ls
06d0829110b3b93f: skill
135b94ef511a5b29: pi-kanban
1bf0be162bc0d832: @mvanhorn/printing-press
483d2954a4c5190c: madge
69c381f8ad94b576: vitest
7439c0f00f94bc1a: snipgrapher
9126f0a380537b3d: howcode   # 237 MB solo este

La trampa¶

El primer impulso es hacer npm cache npx rm vitest howcode y ya está. Pero no:

$ npm cache npx rm vitest snipgrapher howcode
npm error code EUSAGE
npm error Invalid npx key vitest

npm cache npx rm solo acepta el hash hexadecimal, no el nombre del paquete. Tienes que copiar la clave de la primera columna:

$ npm cache npx rm 9126f0a380537b3d 7439c0f00f94bc1a 69c381f8ad94b576
Removing npx key at /home/pcaro/.npm/_npx/9126f0a380537b3d
Removing npx key at /home/pcaro/.npm/_npx/7439c0f00f94bc1a
Removing npx key at /home/pcaro/.npm/_npx/69c381f8ad94b576

Si quieres borrarlo todo de golpe, npm cache clean vacía la caché entera de npm (incluyendo la de npx). Más drástico pero más rápido.

Las extensiones de pi que uso en mi día a día

2026-05-21T00:00:00+02:00

Tercera y última entrega de la serie sobre pi. En la primera parte expliqué qué es pi y lo comparé con otros agents. En la segunda hice una guía completa de uso. Ahora toca lo que realmente diferencia a pi de todo lo demás: las extensiones.

Tengo más de 20 paquetes instalados, skills de varios repositorios, y mis propias extensiones en pcaropi. Aquí desgloso lo que uso realmente en el día a día.

Subagentes — pi-subagents¶

El pi-subagents de NicoBailon es la extensión que más uso. Es un orquestador completo de subagentes con tres modos: single, chain y parallel.

pi install npm:pi-subagents

Viene con 8 agentes incorporados (scout, researcher, planner, worker, reviewer…) y una TUI de preview donde puedes editar los pasos antes de lanzarlos. El modelo fallback en cascada es muy útil: si un modelo falla por quota, prueba el siguiente automáticamente.

Ya comparé esta extensión con otras alternativas (TintinWeb y Taskplane), pero mi elección diaria es NicoBailon sin duda.

Utilidades del sistema¶

pi-processes¶

pi install npm:@aliou/pi-processes

Gestiona procesos en segundo plano: servidores de desarrollo, watchers de tests, logs. El agente puede arrancar npm run dev en background, seguir trabajando, y recibir una alerta si el proceso falla. Esencial para cualquier flujo de desarrollo.

pi-inspect¶

pi install npm:pi-inspect

Consola de depuración para pi. Muestra el estado interno, las herramientas registradas, los eventos que se están disparando. Útil cuando desarrollas tus propias extensiones o cuando algo no funciona como esperas.

pi-slim¶

pi install npm:pi-slim

Reduce el tamaño del prompt de sistema eliminando descripciones que el modelo no necesita. Cada token cuenta, y esta extensión recorta silenciosamente lo superfluo.

Gestión de sesiones¶

pi-smart-sessions (HazAT)¶

pi install git:github.com/HazAT/pi-smart-sessions

Añade gestión inteligente de sesiones: compactación automática, nombrado inteligente, y resumen de ramas abandonadas. Hace que trabajar con sesiones largas sea mucho más llevadero.

pi-slopchop¶

pi install npm:pi-slopchop

Compresión agresiva de contexto. Reduce el uso de tokens hasta un 98% comprimiendo mensajes antiguos sin perder información crítica. Cuando trabajas con sesiones de días, esto es un salvavidas.

pi-add-dir (itisbryan)¶

pi install https://github.com/itisbryan/pi-add-dir

Añade un directorio externo a la sesión para que el agente pueda trabajar con archivos fuera del directorio actual. Imprescindible cuando tienes que tocar código en varios repositorios.

Búsqueda y navegación web¶

@aliou/pi-linkup¶

pi install npm:@aliou/pi-linkup

Tres herramientas de búsqueda web: linkup_web_search para descubrir fuentes, linkup_web_answer para respuestas sintetizadas con citas, y linkup_web_fetch para extraer contenido de URLs concretas. Lo uso constantemente para consultar documentación, investigar APIs, o verificar información durante una sesión de código.

agent-browser skill¶

Instalado como skill desde el repositorio de Vercel Labs. Permite al agente navegar por páginas web como un humano: hacer clic, rellenar formularios, tomar capturas. Ya escribí sobre ello.

chrome-cdp skill¶

pi install git:github.com/pasky/chrome-cdp-skill@v1.0.1

Alternativa a agent-browser usando Chrome DevTools Protocol directamente. Más ligero y con control más granular sobre el navegador.

Productividad y UI¶

pi install npm:pi-powerline-footer

Personaliza la barra de estado de pi con información adicional: estado de CI, rama de git, tiempo de sesión. Lo tengo configurado con ítems personalizados:

{
  "powerline": {
    "preset": "default",
    "customItems": [
      { "id": "ci", "statusKey": "ci", "position": "right", "color": "success" }
    ]
  }
}

@tmustier/pi-code-actions¶

pi install npm:@tmustier/pi-code-actions

Añade acciones de código rápidas: formatear archivo, organizar imports, ejecutar linter. El agente puede dispararlas sin tener que escribir comandos Bash manualmente.

@aliou/pi-guardrails¶

pi install npm:@aliou/pi-guardrails

Guarda raíles de seguridad: bloquea comandos peligrosos (rm -rf, sudo), protege archivos sensibles (.env, node_modules/), y confirma antes de operaciones destructivas. Tranquilidad mental cuando el agente trabaja autónomamente.

pi-ask-user y pi-schedule-prompt¶

pi install npm:pi-ask-user
pi install npm:pi-schedule-prompt

pi-ask-user permite al agente hacer preguntas al usuario con opciones estructuradas. pi-schedule-prompt programa ejecuciones periódicas (cada hora, cada día) para tareas de mantenimiento.

pi-interactive-shell¶

pi install npm:pi-interactive-shell

Lanza agentes CLI interactivos (Claude Code, Cursor, Gemini CLI) desde dentro de pi. Modos dispatch, hands-free, monitor. Útil para delegar tareas específicas a otros agentes sin salir de pi.

Skills que uso todos los días¶

Del repositorio oficial de pi¶

commit: Misión crítica. Cada commit que hago pasa por este skill, que genera mensajes descriptivos y bien estructurados. Lo tengo activado siempre.
brainstorm: Para sesiones de diseño estructurado. Sigue una cadena completa: investigar → clarificar → explorar → validar diseño → escribir plan → crear TODOs.
learn-codebase: Cuando entro en un proyecto nuevo, este skill escanea convenciones, agent config files y posibles problemas de seguridad.
uv, ruff, ty: El trío Python. uv para gestión de paquetes, ruff para linting+formato, ty para type checking. Rápidos, modernos, sin fricción.
github: Interactuar con issues, PRs, CI runs y queries avanzadas de GitHub API, todo desde gh.
frontend-design: Para cuando construyo interfaces. Genera componentes con alta calidad de diseño.

De mi repositorio pcaropi¶

Todas mis extensiones y skills personalizadas están en github.com/pcaro/pcaropi:

Extensiones¶

answer.ts — Q&A interactivo. Extrae preguntas de mensajes del asistente y las responde una a una (/answer o Ctrl+.).
context.ts — Visualización del uso de contexto (tokens, coste, archivos/skills cargados) vía /context.
files.ts — Navegador de archivos interactivo (/files o Ctrl+Shift+o) con estado git y vista rápida.
notify.ts — Notificaciones de escritorio (Linux/notify-send) cuando el agente completa un turno.
session-breakdown.ts — Historial de sesiones visualizado en 7/30/90 días (/session-breakdown).
todos.ts — Gestor de TODOs en Markdown con TUI, bloqueo de archivos y asignación de tareas (/todos).
uv.ts — Intercepta comandos Python (pip, poetry) y sugiere usar uv en su lugar.

Skills¶

cli-tools — Documenta las herramientas CLI disponibles en mi sistema (jq, fx, gh, httpie, etc.)
google-workspace — Acceso a APIs de Google (Drive, Docs, Calendar, Gmail) sin MCP.
summarize — Convierte URLs o archivos locales a Markdown usando uvx markitdown.
update-changelog — Skill para mantener el changelog del repositorio actualizado.
web-browser — Interacción con páginas web mediante Chrome DevTools Protocol.
linkedin-post-formatter — Formatea posts para LinkedIn con Unicode bold/italic.

Prompt templates¶

pr-create.md — Template para crear PRs con estructura consistente.
pr-fix-checks.md — Para arreglar checks fallidos en PRs.
review.md — Template para revisiones de código estructuradas.

MCP¶

pi-mcp-adapter (NicoBailon)¶

pi install git:github.com/nicobailon/pi-mcp-adapter

Adaptador para conectar servidores MCP estándar. Pi no trae MCP nativo (por diseño), pero con este adaptador puedes usar cualquier servidor MCP del ecosistema.

Fuente original: pi.dev | pcaropi

Pi de novato a avanzado — La guía completa

2026-05-21T00:00:00+02:00

Esta es la segunda entrega de la serie sobre pi, el agente de código. En la primera parte comparé pi con otros coding agents. Ahora toca ponerse manos a la obra: desde la instalación hasta trucos de power user, pasando por sesiones, branching, skills y extensiones.

Nivel 1: Novato — Primeros pasos¶

Instalación¶

Pi es un paquete npm. La forma más rápida:

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

O con el instalador oficial (Linux/macOS):

curl -fsSL https://pi.dev/install.sh | sh

Windows requiere WSL o Git Bash. Más detalles en la documentación.

Autenticación¶

Arranca pi en el directorio de tu proyecto:

cd /ruta/a/tu/proyecto
pi

La primera vez verás la pantalla de bienvenida. Usa /login para elegir un proveedor:

Suscripciones: Claude Pro/Max, ChatGPT Plus/Pro o GitHub Copilot.
API keys: Anthropic, OpenAI, DeepSeek, Groq, Mistral, Google, OpenRouter, Azure, Bedrock...

También puedes pasar la API key como variable de entorno:

export ANTHROPIC_API_KEY=sk-ant-...
pi

Yo, personalmente, tengo todas mis API keys almacenadas en Bitwarden y uso kitty rbw para cargarlas automáticamente al abrir el terminal. Así las claves están disponibles sin tener que escribirlas a mano cada vez.

Tu primer prompt¶

Ya dentro de pi, escribe algo y pulsa Enter:

Explícame este repositorio y dime cómo ejecutar sus tests.

Por defecto, pi tiene cuatro herramientas: read, write, edit y bash. Con eso ya puedes hacer prácticamente cualquier cosa.

Archivos de contexto (AGENTS.md)¶

Pi carga AGENTS.md o CLAUDE.md al arrancar. Es la forma de darle instrucciones globales a tu agente. Crea un archivo en la raíz de tu proyecto:

# Instrucciones del proyecto

- Ejecuta `npm run check` después de cada cambio de código.
- No ejecutes migraciones en producción localmente.
- Mantén las respuestas concisas.

Pi busca estos archivos en: - ~/.pi/agent/AGENTS.md — instrucciones globales - Subiendo desde el directorio actual hasta la raíz - El directorio actual

Después de modificar un archivo de contexto —o de instalar o cambiar una extensión— ejecuta /reload para que pi lo recoja sin reiniciar.

Referenciar archivos con @¶

Usa @ en el editor para buscar archivos con fuzzy-search:

@README.md "Resume esto"
@src/app.ts @src/app.test.ts "Revisa estos juntos"

También puedes pasar imágenes pegadas con Ctrl+V.

Nivel 2: Intermedio — Navegación y productividad¶

Atajos de teclado essenciales¶

Atajo	Acción
Ctrl+L	Seleccionar modelo
Ctrl+P	Ciclar entre modelos rápido
Shift+Tab	Cambiar nivel de thinking
Ctrl+G	Abrir editor externo (VS Code, vim...)
Ctrl+V	Pegar imagen en el prompt

Bash desde la TUI¶

Pi ejecuta comandos Bash sin salir de la interfaz:

!comando — Ejecuta y envía la salida al LLM.
!!comando — Ejecuta de forma local sin enviar la salida al LLM (útil para comandos silenciosos como git status).

Esta distinción es muy útil: ! para cuando quieres que el agente vea el resultado de un comando y reaccione, !! para cosas que solo necesitas tú como git status sin añadir ruido al contexto.

!npm run lint
!!git status

La barra de estado¶

En la parte inferior de pi verás:

Directorio de trabajo actual
Nombre de la sesión
Uso de tokens y caché
Coste acumulado
Porcentaje de contexto usado
Modelo activo

Cola de mensajes¶

Puedes enviar mensajes mientras el agente está trabajando:

Enter — Encola un mensaje de steering (se envía cuando termina la ronda actual de tool calls).
Alt+Enter — Encola un follow-up (se envía cuando el agente termina todo el trabajo).
Escape — Cancela y restaura los mensajes encolados al editor.

Sesiones y branching¶

Esta es una de las funcionalidades más potentes y exclusivas de pi.

Las sesiones se guardan automáticamente en ~/.pi/agent/sessions/. Puedes reanudarlas con:

pi -c                  # Continuar la sesión más reciente
pi -r                  # Navegar y seleccionar sesiones anteriores
pi --session <path|id> # Abrir una sesión específica

Dentro de pi:

/session — Muestra info de la sesión actual (archivo, ID, tokens, coste).
/tree — Navega el árbol de la sesión. Puedes saltar a cualquier punto anterior y continuar desde ahí, creando una rama alternativa sin perder el progreso previo.
/fork — Crea una nueva sesión desde un mensaje de usuario anterior.
/clone — Duplica la rama activa en un nuevo archivo de sesión.
/compact — Resumir mensajes antiguos para liberar contexto.
/resume — Explorar sesiones anteriores.
/name <nombre> — Poner nombre a la sesión para encontrarla después.

El branching con /tree es una funcionalidad que distingue a pi de cualquier otro agente de código cerrado. Puedes tener varias líneas de exploración en el mismo archivo de sesión, y si abandonas una rama, pi puede resumirla automáticamente para no perder el contexto.

Intercambio rápido de modelos¶

Usa Ctrl+P para ciclar entre modelos rápidamente. Configura tu selección con --models:

pi --models "claude-*,gpt-4o,deepseek-*"

O en settings.json:

{
  "defaultProvider": "opencode-go",
  "defaultModel": "deepseek-v4-flash",
  "defaultThinkingLevel": "high"
}

Mensajes de sistema¶

Puedes reemplazar o extender el prompt de sistema por defecto:

~/.pi/agent/SYSTEM.md — Reemplaza globalmente.
.pi/SYSTEM.md — Reemplaza por proyecto.
~/.pi/agent/APPEND_SYSTEM.md — Añade al final sin reemplazar.
.pi/APPEND_SYSTEM.md — Añade por proyecto.

Nivel 3: Avanzado — Skills, templates y extensiones¶

Skills¶

Los skills son archivos Markdown con frontmatter que se inyectan en el contexto del agente. Son la forma más sencilla de enseñar a pi comportamientos reutilizables.

Ya comparé ambos métodos en detalle, pero por resumir: puedes instalarlos con npx skills (mi método preferido) o gh skill:

# Instalar skills de Matt Pocock
npx skills add mattpocock/skills --skill grill-me --skill tdd

# Buscar skills disponibles
npx skills find

También puedes crear tus propios skills. Un skill es un archivo SKILL.md con frontmatter:

---
name: my-skill
description: Una skill de ejemplo
---

Esta es mi skill personalizada. Cuando el usuario la invoque con /skill:my-skill,
este contenido se inyecta en el contexto del agente.

Los skills se guardan en ~/.pi/agent/skills/ (global) o .pi/skills/ (proyecto). Ya escribí sobre cómo instalarlos.

Prompt templates¶

Son comandos personalizados con barra /. Crea un archivo Markdown en .pi/prompts/ o ~/.pi/agent/prompts/:

---
name: review-pr
description: Revisa un PR y deja comentarios en GitHub
---

Review this PR and leave inline comments on GitHub using `gh`. Check for:
- Breaking changes
- Missing error handling
- Test coverage
- Consistency with project conventions

Después de /reload, puedes usar /review-pr y el contenido se expandirá en el editor.

Extensiones (pi packages)¶

Las extensiones son módulos TypeScript que pueden registrar herramientas, interceptar eventos, mostrar UI personalizada, y mucho más. Es lo que diferencia a pi de cualquier otro agente.

# Instalar paquetes
pi install npm:@aliou/pi-linkup       # Búsqueda web
pi install npm:@aliou/pi-processes    # Procesos en background
pi install npm:pi-subagents           # Subagentes
pi install npm:pi-lens                # AST search + LSP
pi install npm:pi-slopchop            # Optimización de contexto

# Listar paquetes instalados
pi list

Las extensiones se descubren automáticamente desde ~/.pi/agent/extensions/ y .pi/extensions/. Puedes escribir la tuya propia en TypeScript:

import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";

export default function (pi: ExtensionAPI) {
  pi.registerTool({
    name: "saludar",
    description: "Saluda a alguien",
    parameters: Type.Object({
      nombre: Type.String({ description: "Nombre a saludar" }),
    }),
    async execute(toolCallId, params, signal, onUpdate, ctx) {
      return {
        content: [{ type: "text", text: `¡Hola, ${params.nombre}!` }],
      };
    },
  });
}

Compaction¶

Cuando la ventana de contexto se llena, puedes compactar:

Automático: Pi compacta cuando se acerca al límite de contexto.
Manual: /compact [instrucciones] para compactar con enfoque personalizado.
Extensiones: pi-slopchop puede reducir el uso de tokens hasta un 98%.

Temas¶

Pi soporta temas personalizados. Puedes instalar varios, yo uso pi-powerline-footer que personaliza la barra de estado:

pi install npm:pi-powerline-footer

Configura el tema en settings.json:

{
  "powerline": {
    "preset": "default",
    "customItems": [
      { "id": "ci", "statusKey": "ci", "position": "right", "color": "success" }
    ]
  }
}

Nivel 4: Power user — Configuración total¶

Keybindings personalizados¶

Pi permite mapear atajos de teclado en keybindings.json:

{
  "ctrl+shift+f": { "type": "files" },
  "alt+o": { "type": "command", "command": "ask-user" }
}

Modo no interactivo¶

Para prompts de un solo uso desde scripts:

pi -p "Resume este código"
cat README.md | pi -p "Resume este texto"
pi -p @captura.png "¿Qué hay en esta imagen?"

Modos programáticos¶

--mode json: Salida estructurada como JSON lines (ideal para pipelines).
--mode rpc: Comunicación bidireccional sobre stdin/stdout.
SDK: Integra pi en aplicaciones Node.js.

Modo read-only¶

pi --tools read,grep,find,ls -p "Revisa el código sin modificarlo"

Mi setup personal¶

Este artículo está escrito desde dentro de pi, usando exactamente la configuración que describo. Mi settings.json incluye más de 20 paquetes, skills personalizadas, y extensiones propias de mi repositorio pcaropi. También lanzo pi desde scripts con personalidades concretas: pi -p @prompt.md "Haz X" para tareas repetitivas sin necesidad de entrar en modo interactivo.

En la tercera y última entrega de esta serie, desgloso todas las extensiones que uso en mi día a día, desde subagentes hasta skills de productividad, pasando por búsqueda web, navegación con agente, y mucho más.

Fuente original: pi.dev

¿Qué es pi? — El agente de código minimalista que se ha vuelto viral

2026-05-21T00:00:00+02:00

Llevo ya varios meses usando pi como mi agente de código principal. Es una de esas herramientas que, una vez que la usas, no entiendes cómo funcionabas antes. En este artículo —primero de una serie de tres— voy a contar qué es pi, en qué se diferencia de otros coding agents y por qué creo que se ha vuelto extremadamente popular en GitHub. No os perdáis pi.dev, la web del proyecto — tiene unas animaciones muy didácticas que explican visualmente los conceptos.

La filosofía: menos es más¶

Pi se define como "a minimal terminal coding harness" — un arnés de codificación minimalista para la terminal. Y cuando dicen minimalista, lo dicen en serio.

El núcleo básico de pi tiene exactamente cinco capacidades nativas: leer archivos, ejecutar Bash, editar archivos, escribir archivos y gestionar sesiones. Eso es todo. No trae subagentes, ni modo de planificación, ni pop-ups de permisos, ni MCP incorporado, ni un editor de código.

Suena a poco, pero es la clave de todo. Vivimos en la era del harness engineering — la disciplina de construir entornos robustos alrededor de los agentes de IA — y pi es un punto de partida excelente para montar tu propio harness sin pagar el peaje de un ecosistema cerrado.

La filosofía de pi es que el usuario debe adaptar la herramienta a sus flujos de trabajo, y no al revés. En lugar de venir con 50 funciones que la mayoría no usa, pi te da las primitivas mínimas y un sistema de extensiones TypeScript para que construyas exactamente lo que necesites.

Si quieres subagentes, instalas una extensión. Si quieres MCP, te montas un adaptador. Si quieres un plan mode, te escribes un prompt template. Y si no quieres nada de eso, pues no lo tienes ocupando espacio ni ralentizando el arranque.

Comparativa con otros coding agents¶

Característica	Pi	Claude Code	Codex	OpenCode	Gemini CLI
Filosofía	Núcleo mínimo + extensiones	Todo incluido	Todo incluido	Núcleo mínimo	Todo incluido
Modelos	Cualquier proveedor (API key o suscripción)	Solo Claude	Solo OpenAI	Múltiples (OpenAI API)	Solo Gemini
Subagentes	Via extensiones	Nativos	Nativos	Nativos	Nativos
MCP	Via extensiones	Nativo	-	Nativo	Nativo
Plan mode	Via skills/templates	Nativo	Nativo	-	-
Extensiones	TypeScript SDK	Plugins JSON	-	-	-
Precio	Gratuito (tus claves)	Suscripción de pago	Suscripción de pago	Gratuito (tus claves)	Gratuito (cuota gratuita)
Plataforma	Terminal (cualquier emulador)	Terminal	Terminal	Terminal	Terminal
Sesiones en árbol	Nativo (JSONL tree)	Lineal	Lineal	Lineal	Lineal
Skills	Markdown + frontmatter	Markdown + frontmatter	-	-	-

Claude Code — El todoterreno de Anthropic¶

Claude Code es la apuesta oficial de Anthropic. Viene con todo: subagentes, memoria persistente, sistema de permisos, MCP nativo, y una experiencia muy pulida. Es el más maduro de los que no requieren IDE.

El problema es que solo funciona con Claude. Si quieres usar DeepSeek, Gemini u OpenAI, no puedes. Y el ecosistema de plugins es limitado comparado con lo que ofrece pi.

Codex — La integración con ChatGPT¶

Codex es el agente de OpenAI. Se puede usar desde la terminal (codex) o integrado con ChatGPT. Viene con subagentes y una experiencia similar a Claude Code.

Pero al igual que Claude Code, estás atado a un solo proveedor. Y las extensiones son prácticamente inexistentes: lo que viene, es lo que tienes.

Gemini CLI — El cli de la comunidad¶

Gemini CLI nace del desarrollo comunitario de google-gemini y se integra con su ecosistema (Gemini API, Google Cloud). Google ha ido dejando de lado el CLI en favor de Antigravity, su cliente privativo para empresas. Viene con skills y subagentes, pero la personalización es limitada y las extensiones de terceros son prácticamente inexistentes.

OpenCode — El alma gemela¶

OpenCode es el que más uso después de pi, y en muchos sentidos es su complemento natural. Su filosofía es parecida: núcleo mínimo, terminal, multi-modelo. No tiene el ecosistema de extensiones de pi, pero trae subagentes y MCP nativos. Está escrito en Go, arranca igual de rápido, y su integración con el ecosistema OpenAI es excelente.

¿Qué hace único a pi?¶

Después de probarlos todos, lo que hace único a pi es una combinación de factores que ningún otro agente reúne:

Extensibilidad: Con el SDK de TypeScript puedes añadir herramientas, comandos, interceptar eventos, crear UI personalizada, y compartirlo todo como pi packages. Nadie más ofrece este nivel de personalización.

Sesiones en árbol: Las conversaciones se guardan como un árbol de decisión. Usas /tree para saltar a cualquier punto anterior y crear una rama alternativa sin perder el progreso previo. Esto solo lo tiene pi.

Skills y prompt templates: Pequeños archivos markdown que se inyectan en el contexto del agente. Son la forma más simple de enseñar a tu agente nuevas capacidades. Ya hablé de cómo instalarlos y de las skills de Matt Pocock que se han vuelto virales.

Ecosistema de paquetes: En pi.dev/packages hay extensiones para casi todo: adaptadores MCP, buscadores web, modos de optimización de contexto, temas, y mucho más. Y si no encuentras lo que buscas, te escribes una extensión en TypeScript en cinco minutos.

No es un IDE: Pi es un agente que vive en tu terminal, no un editor. Esto significa que funciona igual en tu máquina local, en un servidor por SSH, dentro de tmux, o en WSL. Usas tu editor favorito y pi se encarga del resto. Profundizaré en este concepto en la siguiente entrega de la serie.

Por qué me gusta pi¶

A estas alturas seguramente se nota, pero por cerrar: me gusta pi porque vivo en la terminal. Porque quiero probar muchos modelos sin atarme a un proveedor. Porque personalizo todo con mis propias extensiones.

No es para todos, obviamente. Si prefieres pagar una suscripción y olvidarte, Claude Code o Codex son más directos. Pero si eres un ingeniero que vive en la terminal, pi es probablemente el mejor agente de código que existe hoy.

En los próximos artículos de esta serie: - Pi de novato a usuario avanzado — Instalación, TUI, sesiones, skills, extensiones y todo lo que necesitas saber para dominarlo. - Las extensiones de pi que uso — Mi setup real con paquetes, skills y extensiones personalizadas.

Fuente original: pi.dev

Programming as Theory Building: el artículo de Peter Naur

2026-05-18T00:00:00+02:00

Christian Ekrem ha escrito un artículo fantástico revisitando el ensayo de Peter Naur de 1985, Programming as Theory Building, y aplicándolo al contexto actual de la IA generativa.

Las ideas clave:

Un programa no es su código fuente. El código es solo una representación imperfecta de la teoría — el modelo mental compartido que explica cómo funciona el sistema, por qué funciona así y cómo debe evolucionar. Cuando los desarrolladores se van, la teoría se pierde.

La crisis actual de "código sin teoría" se ha disparado por tres factores: el uso reflejo de IA (aceptar código sin entenderlo), el código ciego al dominio generado por LLMs (estadística sin comprensión del negocio), y el problema de integración (importar decisiones arquitectónicas ajenas que contradicen el modelo de dominio).

Los seniors importan más que nunca como constructores de teoría, guardianes de la coherencia arquitectónica, colaboradores intencionales con IA (usarla para lo mecánico, preservar el juicio humano para lo importante) y mentores que transfieren comprensión profunda.

La IA no puede construir teoría. Los LLMs generan código sintácticamente correcto pero no entienden contexto de negocio, no hacen trade-offs reflexivos, no mantienen integridad conceptual. La pregunta no es si pueden escribir código, sino si podemos mantener los marcos teóricos humanos que transforman código disperso en programas coherentes.

Fuente original: Programming as Theory Building

Markdown preview en Kate Editor con markdownpart

2026-05-11T00:00:00+02:00

Resulta que KDE tiene un componente llamado markdownpart que permite hacer preview de Markdown en tiempo real dentro de Kate.

sudo apt install markdownpart

Una vez instalado, en Kate:

Preferencias → Configurar Kate → Complementos
Activar Vista previa del documento (o similar según la versión)

Aparecerá un botón en la barra lateral con un icono de un documento con una lupa. Al hacer clic, se abre un panel con el Markdown renderizado. Y lo mejor: tiene opciones de actualizar en vivo mientras escribes.

Configurar permisos udev para Vial en Linux

2026-05-11T00:00:00+02:00

Al conectar un teclado con firmware Vial (como el Keychron Q10) en Linux, la GUI de Vial no lo detecta porque el usuario no tiene permisos sobre los dispositivos /dev/hidraw*.

La documentación oficial de Vial recomienda usar una regla udev universal que identifica el teclado por su serial mágico vial:f64c2b3c. Esto es mejor que usar vendor/product ID porque funciona con cualquier teclado Vial que conectes.

Primero, identifica tu teclado con lsusb. El mío aparece como:

Bus 003 Device 015: ID 3434:01a1 Keychron Keychron Q10

El comando para crear la regla, recargar y aplicar:

export USER_GID=`id -g`; sudo --preserve-env=USER_GID sh -c 'echo "KERNEL==\"hidraw*\", SUBSYSTEM==\"hidraw\", ATTRS{serial}==\"*vial:f64c2b3c*\", MODE=\"0660\", GROUP=\"$USER_GID\", TAG+=\"uaccess\", TAG+=\"udev-acl\"" > /etc/udev/rules.d/59-vial.rules && udevadm control --reload && udevadm trigger'

Esto crea /etc/udev/rules.d/59-vial.rules, recarga las reglas y las dispara. Después, desconecta y vuelve a conectar el teclado. Vial debería reconocerlo al instante.

Si prefieres una regla específica para tu modelo, añade los IDs:

export USER_GID=`id -g`; sudo --preserve-env=USER_GID sh -c 'echo "KERNEL==\"hidraw*\", SUBSYSTEM==\"hidraw\", ATTRS{serial}==\"*vial:f64c2b3c*\", ATTRS{idVendor}==\"3434\", ATTRS{idProduct}==\"01a1\", MODE=\"0660\", GROUP=\"$USER_GID\", TAG+=\"uaccess\", TAG+=\"udev-acl\"" > /etc/udev/rules.d/59-vial.rules && udevadm control --reload && udevadm trigger'

La regla universal es más simple y cubre cualquier teclado Vial futuro.

Fuente original: Vial - Configuring udev on Linux

Spec Kit de GitHub — Especificaciones como fuente de verdad

2026-05-10T00:00:00+02:00

Sexta entrega de la serie sobre ingeniería de programación con agentes. Hoy toca el proyecto que GitHub ha convertido en el estándar de facto del desarrollo guiado por especificaciones: Spec Kit.

Hasta ahora hemos visto metodologías para dirigir agentes: compound engineering (Every), skills de disciplina (Addy Osmani), un sistema operativo completo para agentes (Superpowers de Jesse Vincent), y skills mínimas y pragmáticas (Matt Pocock). Todas comparten una premisa: defines cómo quieres que el agente trabaje y él ejecuta.

Spec Kit da la vuelta a esa premisa. No le dice al agente cómo trabajar. Le dice qué construir, y deja que el agente descubra cómo. La diferencia es sutil pero lo cambia todo.

El problema que resuelve¶

Todos los frameworks que hemos visto en la serie asumen que sabes lo que quieres construir y que el problema es que el agente no lo construye bien. Tiene razón: sin disciplina, los agentes toman atajos, generan código genérico y producen resultados inconsistentes.

Pero hay otro problema, más profundo: ¿y si no sabes exactamente lo que quieres? ¿Y si tus requisitos son vagos, contradictorios o incompletos?

Si veinte desarrolladores le piden a un agente "haz un CRUD de usuarios", obtendrán veinte resultados diferentes, y probablemente ninguno sea lo que realmente necesitaban. Porque "CRUD de usuarios" no es una especificación. Es una idea. Y las ideas no se implementan: se refinan.

Spec Kit aborda este problema desde la raíz. No es un framework para programar con agentes. Es un framework para especificar con agentes. El código sale solo.

La inversión de poder¶

Spec Kit llama a su idea central The Power Inversion (la inversión de poder). La idea no es nueva: es ingeniería del software de toda la vida. Cuando yo estudiaba ingeniería informática, esto se llamaba DDR (Documento de Definición de Requisitos). Tenías requisitos de usuario ("Como usuario quiero..."), requisitos funcionales y requisitos de sistema. De ahí derivabas una especificación técnica, y luego el código. En Carto era nuestra filosofía principal: PRD, documento de especificación técnica, código.

Lo que cambia con Spec Kit es que la especificación ya no es un documento que guía la implementación para que un humano la ejecute. Es un documento ejecutable por un agente de IA. El PRD no es contexto para que un desarrollador escriba código. Es la entrada que genera directamente la implementación.

La diferencia es que los agentes son muy buenos ayudándote a especificar. Pueden hacer preguntas, identificar ambigüedades, explorar el código existente en busca de contexto, y refinar los requisitos contigo antes de escribir una línea. Esa capacidad de iterar sobre la especificación en segundos en lugar de días es lo que hace que el flujo sea práctico.

Los números lo avalan: 95.000 estrellas en GitHub, 8.200 forks, 30+ agentes de IA soportados, y un ecosistema de extensiones comunitarias que ha crecido de 26 a 83 en solo un mes.

El flujo de trabajo¶

Spec Kit define seis comandos principales que cubren todo el ciclo de vida de una feature:

Comando	Qué hace
`/speckit.constitution`	Define los principios rectores del proyecto
`/speckit.specify`	Describe qué construir (requisitos, user stories)
`/speckit.clarify`	Preguntas estructuradas para resolver ambigüedades
`/speckit.plan`	Traduce la especificación a un plan técnico
`/speckit.tasks`	Descompone el plan en tareas accionables
`/speckit.implement`	Ejecuta las tareas y genera el código

Además hay comandos opcionales: /speckit.analyze para validación cruzada entre artefactos, y /speckit.checklist para generar checklists de calidad personalizados.

1. Constitución¶

Antes de escribir una sola línea de especificación, defines los principios del proyecto. No es un documento de equipo. Es un contrato que el agente debe respetar en cada decisión.

Spec Kit incluye una constitución de ejemplo con nueve artículos que cubren desde "library-first" (toda feature empieza como librería independiente) hasta "test-first imperative" (no hay código sin tests que fallen primero).

La constitución no es opcional. Es el sistema inmunológico del proyecto. Sin ella, el agente toma decisiones coherentes pero no necesariamente consistentes. Con ella, cada decisión refuerza la arquitectura.

2. Especificación¶

Aquí está la clave de todo: en /speckit.specify solo hablas del qué y el por qué. Nada de stack tecnológico. Nada de APIs. Nada de cómo.

El template de especificación fuerza esta separación explícitamente:

- ✅ Focus on WHAT users need and WHY
- ❌ Avoid HOW to implement (no tech stack, APIs, code structure)

Esto es más difícil de lo que parece. Como ingenieros, nuestro instinto es saltar al "cómo" en cuanto entendemos el problema. Spec Kit te obliga a mantenerte en el "qué" el tiempo suficiente para que la especificación sea completa.

Además, el template incluye marcadores [NEEDS CLARIFICATION] que el agente debe usar cuando algo no está claro. Esto evita el problema más común con los LLMs: que adivinen en lugar de preguntar.

3. Clarificación¶

Este paso es el que más valoro personalmente. Antes de pasar al plan técnico, /speckit.clarify inicia un diálogo estructurado donde el agente identifica ambigüedades y te pregunta una por una.

No es un cuestionario genérico. El agente ha leído la especificación y sabe exactamente qué no entiende. Te pregunta hasta que no quedan ramas del árbol de decisión sin explorar.

Es el mismo patrón que el /grill-me de Matt Pocock, pero incrustado en un flujo más amplio y con un formato estructurado que queda registrado en la propia especificación.

4. Plan¶

Ahora sí, llegó el momento del "cómo". Le dices al agente tu stack tecnológico y tus decisiones arquitectónicas. El agente genera un plan de implementación detallado que incluye:

Modelo de datos: esquemas, relaciones, restricciones
Contratos de API: endpoints, eventos, formatos
Investigación: comparativa de librerías, benchmarks, decisiones técnicas con su rationale
Quickstart: escenarios de validación clave

Cada elección técnica enlaza con requisitos concretos de la especificación. Nada queda sin trazar.

5. Tareas¶

El plan se descompone en tareas individuales, cada una con paths exactos, código completo y pasos de verificación. Las tareas independientes se marcan como paralelizables.

El sistema de tareas de Spec Kit es notable porque distingue entre tareas HITL (requieren decisión humana) y AFK (automatizables de principio a fin). Esto permite que el humano intervenga solo donde realmente aporta valor.

6. Implementación¶

El agente ejecuta las tareas en orden, respetando dependencias y siguiendo TDD. Cada tarea produce evidencia: tests que pasan, builds limpios, contratos validados.

Si algo falla, el agente no sigue adelante. Para, informa y espera instrucciones. Es la materialización del principio que recorre toda la serie: la verificación no es negociable.

La fundación constitucional¶

Spec Kit impone un gran nivel de detalle en su constitución. No son principios vagos. Son nueve artículos con cláusulas concretas que el agente no puede ignorar.

Artículo I — Library-First: Toda feature empieza como librería independiente. Esto fuerza modularidad desde el primer commit. No vale "ya lo refactorizaremos".

Artículo II — CLI Interface: Toda librería debe exponer una interfaz de línea de comandos. Esto garantiza observabilidad: puedes invocar cualquier funcionalidad desde un script, sin tocar la interfaz gráfica.

Artículo III — Test-First Imperative: No negociable. Primero los tests. Tests que fallan. Luego la implementación mínima para que pasen.

Artículos VII y VIII — Simplicidad y Anti-Abstracción: Máximo 3 proyectos en la implementación inicial. Usa el framework directamente, no lo envuelvas. Nada de "por si acaso".

Artículo IX — Integration-First Testing: Tests en entornos reales. Bases de datos reales. Servicios reales. Nada de mocks si puedes evitarlos.

El detalle clave es cómo estos artículos se aplican a través de gates en el template del plan de implementación. Antes de que el agente escriba una línea, pasa por una fase de "gates pre-implementación" que verifican cada artículo. Si algo falla, el agente debe justificarlo por escrito en una sección de "Complejidad".

Esto convierte la constitución de un documento pasivo a un sistema de enforcement activo. No es que el agente "debería" seguir las reglas. Es que no puede saltárselas sin dejar evidencia.

Comparación con el resto de la serie¶

Cada proyecto que hemos visto en la serie ocupa un nicho diferente:

Proyecto	Enfoque	Fortaleza
Every	Compound engineering	Acumulación de conocimiento en CLAUDE.md
Addy Osmani	Harness engineering	Disciplina de ingeniero senior con anti-racionalización
Superpowers	Methodology engineering	Sistema operativo completo para agentes
Matt Pocock	Skills engineering	Skills mínimas que cualquiera puede adoptar
Spec Kit	Spec engineering	Las especificaciones son la fuente de verdad

Spec Kit es el único que no empieza por el agente. Empieza por la especificación. El agente es el último paso, no el primero.

Mi lectura¶

Spec Kit es el proyecto que más se acerca a la ingeniería del software clásica de los que he cubierto en la serie. No por su complejidad técnica (que es poca: es básicamente un CLI de Python que genera archivos markdown), sino porque formaliza algo que siempre debimos hacer: especificar antes de construir.

Invertir la relación entre especificación y código es una idea que suena bien en abstracto pero que tiene implicaciones profundas. Si el código es un artefacto generado, ¿qué significa "mantener" el software? Mantener software significa evolucionar especificaciones. Debuggear significa corregir especificaciones que generan código incorrecto. Refactorizar significa reestructurar especificaciones para claridad.

El perfil del ingeniero de software siempre fue distinto al del programador. Nunca fue alguien que escribe código sin más. Es quien escribe especificaciones que generan código. Algo cercano a lo que ahora se denomina Product Owner en Scrum, pero con capacidad técnica para saber qué es implementable y qué no.

No sé si esta visión se cumplirá completamente. Pero Spec Kit tiene algo que ninguno de los otros proyectos tiene: el respaldo institucional de GitHub. Con 95.000 estrellas y creciendo, con una tasa de adopción que duplica a Superpowers en meses, Spec Kit no es un experimento. Es un movimiento.

Y lo más interesante es que GitHub no está construyendo Spec Kit para venderte nada. Es código abierto, es gratuito, y funciona con cualquier agente: Claude Code, Gemini CLI, Cursor, Codex, Copilot, el que uses. Es una apuesta por un estándar abierto de desarrollo con IA, y está funcionando.

La pregunta que debes hacerte no es "qué agente uso" o "qué methodology uso con mis agentes", sino "qué especificación escribo para que mis agentes construyan lo correcto". Spec Kit da una respuesta: escribe la especificación primero. El resto es implementación.

Recursos¶

GitHub Spec Kit — El repositorio oficial (95K+ estrellas)
Spec-Driven Development — la metodología — El documento que define SDD
Spec Kit Community Extensions — Catálogo de extensiones comunitarias
Matt Pocock — Skills que funcionan — Artículo anterior de la serie
Superpowers — Jesse Vincent — Artículo anterior de la serie
Agent Skills — Addy Osmani — Artículo anterior de la serie
Compound Engineering — Every — Artículo anterior de la serie

Matt Pocock — Skills sencillas que funcionan

2026-05-06T00:00:00+02:00

Quinta entrega de la serie sobre ingeniería de programación con agentes. Hoy toca el proyecto que está arrasando estos días: las skills de Matt Pocock.

He cubierto Superpowers (Jesse Vincent), Agent Skills (Addy Osmani) y Compound Engineering (Every). Cada uno aporta una pieza importante del puzzle. Pero las skills de Matt Pocock han explotado en popularidad en cuestión de días, y creo que sé por qué: aplican una filosofía KISS llevada al extremo. Skills cortas, directas, sin pretensiones. Y una de ellas, /grill-me, se ha convertido en un fenómeno por sí sola.

La filosofía: skills que un ingeniero real usaría¶

Matt es conocido por Total TypeScript y su trabajo en TypeScript. Cuando empezó a publicar skills para Claude Code, no escribió un framework. Escribió archivos markdown de tres líneas que hacían una cosa y la hacían bien.

El lema del repositorio lo resume: "Skills for Real Engineers" (skills para ingenieros de verdad). No hay capas de abstracción, ni plugins complejos, ni ciclos de vida sofisticados. Son ficheros markdown con frontmatter que se inyectan en el contexto del agente. Punto.

El repositorio se organiza en cubos: engineering/ (skills del día a día), productivity/ (herramientas generales), misc/ (cosas que raramente usa), personal/ (atadas a su setup) e in-progress/. De las ~20 skills totales, solo unas 6 son las que realmente recomienda para el día a día. Esa contención es la clave: no más de media docena de skills, y muy muy cortas.

El contraste con Superpowers (v5 con 20+ skills, loops adversariales, sistema de fases completo) no podría ser mayor. Matt demuestra que menos puede ser más si eliges bien qué automatizar.

`/grill-me`: el skill que lo cambia todo¶

Tres frases. Eso es todo el skill:

"Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. Ask the questions one at a time. If a question can be answered by exploring the codebase, explore the codebase instead."

Tres frases que han generado 62.000 estrellas en GitHub y se han compartido en todas partes. ¿Por qué?

Porque resuelven el problema número uno de trabajar con agentes: la alineación. El agente no sabe lo que quieres, y tú no sabes lo que el agente ha entendido. El grill-me fuerza una conversación estructurada donde el agente te pregunta hasta que no quedan ramas del árbol de decisión sin explorar.

Matt cuenta que en una sesión típica, Claude le hizo 16 preguntas para una feature relativamente simple. En features complejas, ha tenido sesiones de 30-40-50 preguntas que duran casi media hora. Pero al final de esa media hora, el diseño está completamente resuelto. No hay sorpresas cuando el agente empieza a escribir código.

El concepto de "árbol de decisión" viene de The Design of Design de Frederick P. Brooks. La idea es que cuando diseñas algo, caminas por ramas: "¿búsqueda avanzada o búsqueda simple? Si avanzada, ¿qué filtros? ¿qué ordenación?" Hasta que has recorrido todas las ramas y el diseño está completamente especificado.

El flujo completo: grill → PRD → issues → TDD¶

Matt encadena varias skills en un pipeline que cubre todo el ciclo de vida de una feature, desde la idea hasta el código pasando por tests:

/grill-me: el agente te entrevista hasta que el diseño está claro. Cada pregunta resuelve una decisión. Si puede responderla explorando el código, lo hace.
/to-prd: una vez alineados, convierte la conversación en un PRD (Product Requirements Document) con user stories, decisiones de implementación y criterios de aceptación. Se publica como issue en GitHub, Linear o el tracker que uses.
/to-issues: rompe el PRD en issues independientes usando vertical slices (tracer bullets). Cada issue atraviesa todas las capas (schema, API, tests) y es demoable por sí mismo. Distingue entre HITL (human-in-the-loop, requiere decisión humana) y AFK (automatizable de principio a fin).
/tdd: Test-Driven Development con ciclo red-green-refactor. Una skill sustancial que incluye filosofía sobre mocking, módulos profundos y diseño de interfaces. Escribir un test que falla → implementación mínima → refactor. Una iteración a la vez, nunca todas las vistas horizontales juntas.
/improve-codebase-architecture: para cuando el código se ha convertido en una bola de barro. Explora el codebase buscando módulos poco profundos, acoplamientos ocultos y falta de testabilidad.
/grill-with-docs: variante de grill-me que además actualiza un CONTEXT.md con el lenguaje compartido del dominio y escribe ADRs para decisiones difíciles de revertir. Es la skill favorita de Matt — combinación de entrevista con domain-driven design.

Es notable cómo el flujo entero encaja con lo que hemos visto antes:

El scaffolding de Every (CLAUDE.md que acumula conocimiento) aparece aquí como CONTEXT.md + ADRs.
La disciplina de Addy Osmani (tablas anti-racionalización, workflows con checkpoints) aparece en el TDD skill con sus checklist por ciclo.
La metodología estructurada de Superpowers (file structure primero, descomposición en unidades, loops adversariales) aparece aquí como vertical slices, tracer bullets y la separación HITL/AFK.

Pero Matt lo envuelve todo en skills tan cortas que caben en un tuit. No hay sobreingeniería. Hay pragmatismo.

Mi lectura¶

Matt Pocock ha hecho algo que me parece más difícil que construir un framework: ha destilado su experiencia en piezas tan pequeñas que cualquiera puede adoptarlas sin cambiar su flujo de trabajo.

El /grill-me me resulta especialmente familiar porque mi flujo personal con agentes siempre ha incluido una fase de preguntas iterativas — casi una versión manual de lo que Matt ha codificado. Verlo convertido en skill pública, con 62.000 personas dándole estrellas, confirma que el instinto era correcto: la alineación temprana es el paso más infravalorado en el trabajo con agentes.

El resto de skills son igual de sólidas. El to-prd y to-issues formalizan algo que cualquier ingeniero senior hace instintivamente (pensar antes de escribir, dividir el trabajo en trozos revisables) pero que raramente se documenta. El TDD skill es el mejor que he visto para agentes: no solo dice "haz TDD", sino que explica por qué las vistas horizontales producen tests malos y cómo hacer ciclos verticales correctamente.

Lo que diferencia a Matt del resto es la accesibilidad. Superpowers requiere integrar un runtime. Agent Skills requiere instalar un plugin. Las skills de Matt son ficheros markdown que puedes copiar a tu .claude/ en 30 segundos. Y si no quieres instalarlas, leerlas ya te da el framework mental.

No creo que las skills de Matt reemplacen a Superpowers o Agent Skills. Son herramientas para contextos diferentes. Superpowers es para cuando quieres una metodología completa que el agente no pueda saltarse. Matt es para cuando quieres piezas pequeñas, intercambiables, que entiendes y modificas.

Las dos tienen sentido. Pero Matt ha demostrado algo importante: a veces la mejor skill es la que cabe en tres líneas.

Recursos¶

mattpocock/skills en GitHub — El repositorio (62K+ estrellas)
AI Hero — Skills — La web oficial con guías de cada skill
5 Agent Skills I Use Every Day — El artículo de Matt presentando su kit
My Grill Me Skill Has Gone Viral — Sobre el fenómeno /grill-me
Superpowers — Jesse Vincent — Artículo anterior de la serie
Agent Skills — Addy Osmani — Artículo anterior de la serie
Compound Engineering — Every — Artículo anterior de la serie

Superpowers — Jesse Vincent impone metodología a los agentes de codificación

2026-05-06T00:00:00+02:00

Cuarta entrega de la serie sobre ingeniería de programación con agentes. Hoy toca un proyecto que ha cambiado las reglas del juego: Superpowers, de Jesse Vincent.

Con 180.000 estrellas en GitHub y 16.000 forks, Superpowers es el marco de habilidades para agentes más popular del momento. Pero lo que lo hace especial no es el número de estrellas, sino su obsesión: imponer una metodología de ingeniería completa a los agentes de código, desde el primer prompt hasta el último commit.

Quién es Jesse Vincent¶

Jesse Vincent es una figura conocida en el mundo del software de código abierto. Es el creador de Perl 6 (hoy Raku), cofundó Best Practical y construyó RT (Request Tracker), el sistema de ticketing usado por organizaciones como la Free Software Foundation y el kernel de Linux. Hoy está en Prime Radiant, una empresa que construye herramientas para ingeniería con agentes.

Su blog es un referente en la comunidad de coding agents desde octubre de 2025, cuando publicó el primer artículo sobre Superpowers. Desde entonces, cada release ha sido un evento.

La idea central¶

Superpowers no es un plugin más. Es una metodología de desarrollo completa para agentes de codificación, construida sobre habilidades composables que se activan automáticamente según el contexto.

El flujo básico es:

Brainstorming — El agente NO empieza a programar. Pregunta, explora alternativas y refina la idea antes de tocar una línea.
Using-git-worktrees — Crea un workspace aislado en una rama nueva.
Writing-plans — Descompone el trabajo en tareas de 2-5 minutos, cada una con paths exactos, código completo y pasos de verificación.
Subagent-driven-development o executing-plans — Despacha agentes para implementar o ejecuta en lotes con checkpoints humanos.
Test-driven-development — RED-GREEN-REFACTOR obligatorio. Tests primero, siempre.
Requesting-code-review — Review contra el plan, con severidades Critical/Nit/Optional.
Finishing-a-development-branch — Tests, merge o PR, cleanup.

El mantra que resume todo: si el agente empieza a codificar sin hacer preguntas, Superpowers ha fallado.

Visual Brainstorming¶

La novedad más llamativa de la versión 5 es el Visual Brainstorming Companion: un servidor web local que el agente levanta para mostrarte mockups, diagramas y comparaciones visuales en el navegador mientras conversáis.

El origen es curioso. Jesse se encontró pidiendo a Claude una y otra vez: "Oye, ¿por qué no escribes eso como HTML para que pueda ver lo que quieres decir?" Hasta que recordó el mantra más importante de la programación con agentes: "¿Por qué lo estoy haciendo yo?"

El agente ahora pregunta si quieres probar el compañero visual, y si aceptas, te abre un navegador con contenido interactivo. Detrás, un servidor WebSocket sirve chunks de HTML que el agente escribe a disco, con JavaScript para capturar clics y feedback.

Jesse lo probó para idear un logo para Prime Radiant con Claude. Dice que imaginar cómo habría sido en ASCII art da escalofríos.

Spec Review: el bucle adversarial¶

Otro avance de la v5 es el spec review loop. Jesse detectó que los agentes dejaban secciones "TBD" o "Fill this in later" en los documentos de planificación — y que eso acababa tan mal como cabría esperar.

La solución: después de planificar, Superpowers lanza un subagente que lee la documentación de diseño buscando lagunas y rarezas. No es un sustituto de leerla uno mismo, pero mejora drásticamente la calidad de los planes.

Es el mismo patrón que hemos visto en otras herramientas de la serie: un loop adversarial de revisión. El planificador produce, el revisor critica, el planificador corrige. Se repite hasta que no quedan objeciones.

Subagent Driven Development¶

Hasta la v4, Superpowers ofrecía al usuario la opción entre subagentes o ejecución secuencial con checkpoints humanos. Esa ambigüedad venía de una época en que los subagentes eran nuevos y Jesse no se fiaba de ellos.

A partir de la v5, si tu agente soporta subagentes, Subagent Driven Development es obligatorio. Si no los soporta, Superpowers te advierte que otro harness lo haría mejor, y luego hace lo que puede.

En harnesses como Claude Code que pueden elegir qué modelo usar para cada subagente, Superpowers instruye: modelo barato para tareas mecánicas, estándar para integración, capaz para arquitectura y revisión. Y los subagentes ahora tienen un protocolo de estado: DONE, DONE_WITH_CONCERNS, BLOCKED, NEEDS_CONTEXT.

Ingeniería de software como principio¶

El valor de las interfaces comienza aquí:

Descomposición en unidades: cada unidad debe tener un propósito claro, interfaces bien definidas y ser testeable de forma independiente.
"¿Puede alguien entender lo que hace una unidad sin leer su implementación? ¿Puedes cambiar la implementación sin romper a los consumidores?".
Archivos grandes como smell de diseño: no es solo un problema de estilo, es una advertencia de que la descomposición falló.
File Structure como paso obligatorio: antes de descomponer en tareas, primero decides qué archivos existen y qué responsabilidad tiene cada uno. Esto es diseño guiado por interfaces llevado desde la especificación hasta la implementación y la revisión.

Otras decisiones de diseño interesantes¶

Las skills no son documentación. Son workflows: secuencias de pasos que el agente sigue, con checkpoints que producen evidencia, terminando en un criterio de salida definido. Si metes un ensayo de 2000 palabras en el contexto, el agente lo lee y salta la ejecución real. Si metes un workflow, el agente tiene algo que hacer.

Prioridad de instrucciones. Superpowers establece una jerarquía explícita:

Tus instrucciones directas (CLAUDE.md, AGENTS.md) — prioridad máxima
Skills de Superpowers — overriding del comportamiento por defecto
System prompt por defecto — prioridad mínima

Si tu CLAUDE.md dice "no uses TDD" y un skill de Superpowers dice "usa TDD siempre", gana tu instrucción.

Divulgación progresiva. No se cargan las 20 skills en el contexto al inicio. Un meta-skill actúa como router que decide qué skills aplicar según la tarea. Cada skill describe cuándo debe activarse. El agente comprueba si aplica. Si no, sigue.

Tablas anti-racionalización. Cada skill incluye una tabla de excusas comunes que un agente podría usar para saltarse el workflow, emparejadas con una réplica. Esto es especialmente efectivo porque los LLMs son excelentes produciendo justificaciones plausibles para hacer lo que les apetece.

El SUBAGENT-STOP gate. Los subagentes despachados para tareas específicas se saltan el meta-skill y no activan flujos completos de skills. Esto evita que un subagente que solo debe implementar un cambio empiece a hacer brainstorming.

En qué se diferencia de los otros¶

Every se centra en el bucle de aprendizaje: compound engineering acumula conocimiento en CLAUDE.md para que cada ciclo sea más eficiente.

Addy Osmani se centra en la disciplina: agent-skills fuerza al agente a pasar por las fases que un ingeniero senior nunca saltaría, con tablas anti-racionalización como arma principal.

Superpowers es más ambicioso: es un sistema operativo completo para agentes de código. No solo define workflows, sino que gestiona worktrees de git, decide qué modelo usar para cada subagente, revisa especificaciones con loops adversariales, y tiene un protocolo de comunicación entre subagentes.

Si Every es compound engineering y Addy es harness engineering, Superpowers es methodology engineering: construir el sistema que obliga al agente a seguir una metodología completa de desarrollo de software.

Addy pone el foco en la disciplina del ingeniero senior. Superpowers pone el foco en la disciplina del proceso: el workflow es el que manda, no el agente. La diferencia es sutil pero importante.

Lo que más me ha gustado¶

El mantra "¿Por qué lo estoy haciendo yo?" aplicado al Visual Brainstorming. Es la pregunta que todo el que programa con agentes debería hacerse constantemente. Si el agente puede hacerlo, que lo haga.

El spec review loop. El patrón adversarial para mejorar la calidad de los planes es simple, efectivo, y aplicable a cualquier flujo de trabajo con agentes.

La prioridad de instrucciones. Poner CLAUDE.md por encima de las skills de Superpowers es el gesto de diseño más honesto del proyecto. Le dice al usuario: "esto es para ayudarte, no para decirte lo que tienes que hacer".

La tasa de rechazo del 94% como señal de calidad. Que el creador sea tan agresivo contra el slop de agentes es una declaración de intenciones. Superpowers no quiere más contribuciones, quiere contribuciones excelentes.

Mi lectura¶

Superpowers es el proyecto más completo de los que hemos visto en esta serie. Jesse Vincent lleva desde octubre de 2025 iterando sobre la misma idea: cómo hacer que un agente de código se comporte como un ingeniero con experiencia, no como un junior que escribe la primera solución que se le ocurre.

La diferencia con otras aproximaciones es que Superpowers no confía en el agente. No confía en que "sabrá lo que tiene que hacer". Le da un workflow, le obliga a seguirlo, revisa que lo ha seguido, y si se desvía, le redirige.

Eso suena restrictivo, y lo es. Pero la experiencia de cientos de miles de usuarios sugiere que es exactamente lo que los agentes necesitan: estructura, no libertad.

Para mí, lo más valioso de Superpowers no son las skills, sino la filosofía: si quieres que un agente produzca trabajo de calidad, no puedes delegar la metodología al agente. Tienes que codificarla en skills que se activen automáticamente, con checkpoints que produzcan evidencia, y con loops adversariales que verifiquen que no se han saltado nada.

Este framework es el que más he usado de los tres que he revisado en la serie. Desde sus primeras versiones con Claude Code se mostró muy sólido, y cada release ha sido un salto adelante.

El próximo artículo de la serie explorará otro enfoque. Pero creo que Superpowers marca un antes y un después en cómo pensamos sobre la ingeniería con agentes.

Recursos¶

Superpowers en GitHub — El repositorio (180K+ estrellas)
Superpowers 5 — el anuncio — El artículo de Jesse Vincent
Superpowers: How I'm using coding agents in October 2025 — El artículo original de lanzamiento
Prime Radiant — La empresa de Jesse Vincent
Compound Engineering — Every — Artículo anterior de la serie
Agent Skills de Addy Osmani — Artículo anterior de la serie

Agent Skills de Addy Osmani — Imponiendo disciplina de ingeniería senior a los agentes

2026-05-06T00:00:00+02:00

En las dos partes anteriores de esta serie hemos visto una visión general de la ingeniería con agentes y luego la metodología de compound engineering de Every. Ahora toca otra aproximación similar: Agent Skills, el proyecto de Addy Osmani en Google que lleva casi 30.000 estrellas en GitHub y que aborda el problema desde un ángulo completamente diferente.

El problema que nadie quiere ver¶

Addy plantea algo incómodo: el comportamiento por defecto de cualquier agente de código es tomar el camino más corto hacia "hecho". Le pides una feature y te escribe la feature. No pregunta si tienes una especificación. No escribe un test antes de la implementación. No considera si el cambio cruza un límite de confianza. No verifica cómo se verá el PR para un revisor. Produce código, declara victoria y sigue adelante.

Esto es exactamente el mismo fallo que todo ingeniero senior ha pasado su carrera aprendiendo a evitar. El trabajo senior no es el que aparece en el diff: es sacar a la luz suposiciones, escribir la especificación, fragmentar el trabajo en chunks revisables, elegir el diseño aburrido, dejar evidencia de que el resultado es correcto, dimensionar el cambio para que un humano pueda revisarlo.

Los agentes saltan esos pasos por la misma razón que cualquier junior lo haría: son invisibles. La señal de recompensa apunta a "tarea completada", no a "tarea completada y el documento de diseño existe". Así que hay que atornillar el andamiaje de ingeniero senior de nuevo.

Qué es una skill¶

Addy define una skill con precisión: es un archivo markdown con frontmatter que se inyecta en el contexto del agente cuando la situación lo requiere. Algo entre un fragmento de system prompt y un runbook.

Una skill no es documentación de referencia. No es "todo lo que deberías saber sobre testing". Es un workflow: una secuencia de pasos que el agente sigue, con checkpoints que producen evidencia, terminando en un criterio de salida definido.

Esa distinción lo cambia todo. Si metes un ensayo de 2000 palabras sobre mejores prácticas de testing en el contexto del agente, el agente lo lee, genera texto plausible, y salta el testing de verdad. Si metes un workflow (escribe el test que falla primero, ejecútalo, míralo fallar, escribe el mínimo código para pasar, míralo pasar, refactoriza), el agente tiene algo que hacer, y tú tienes algo que verificar.

Proceso descrito con claridad. Workflows sobre referencia. Pasos con criterios de salida sobre ensayos sin ellos.

Las 20 skills y los 7 comandos¶

El repositorio organiza 20 skills alrededor de 6 fases del ciclo de vida del software, con 7 comandos slash encima:

Fase	Comando	Qué hace
Define	`/spec`	Decide qué estás construyendo
Plan	`/plan`	Fragmenta el trabajo
Build	`/build`	Implementa en slices verticales
Verify	`/test`	Demuestra que funciona
Review	`/review`	Atrapa lo que se escapó
Ship	`/ship`	Lleva a producción de forma segura

También hay /code-simplify que atraviesa todo el ciclo.

Una feature compleja podría activar 11 skills en secuencia. Un bug pequeño podría usar 3. Un meta-skill (using-agent-skills) actúa como router que decide cuáles aplican. El workflow escala al scope real, no al scope asumido.

Cinco principios que sostienen todo¶

1. Proceso simple y directo¶

Workflows son accionables para agentes; ensayos no. Lo mismo ocurre en equipos humanos. Si tu manual del equipo tiene 200 páginas, nadie lo lee bajo presión. Si es un conjunto pequeño de workflows con checkpoints, la gente realmente los ejecuta.

2. Tablas anti-racionalización¶

Esta es la decisión de diseño más distintiva del proyecto. Cada skill incluye una tabla de excusas comunes que un agente (o un ingeniero cansado) podría usar para saltarse el workflow, emparejadas con una réplica.

"Esta tarea es demasiado simple para necesitar una especificación." → Los criterios de aceptación siguen aplicando. Cinco líneas están bien. Cero líneas no.
"Escribiré los tests después." → "Después" es la palabra que sostiene todo. No hay después. Escribe el test que falla primero.
"Los tests pasan, mándalo." → Tests que pasan son evidencia, no prueba. ¿Comprobaste el runtime? ¿Verificaste el comportamiento visible al usuario? ¿Un humano leyó el diff?

La razón por la que esto funciona es que los LLMs son excelentes en la racionalización. Producirán un párrafo plausible explicando por qué esta tarea en particular no necesita una spec, o por qué este cambio en particular está bien para mergear sin revisión. Las tablas anti-racionalización son réplicas pre-escritas a mentiras que el agente aún no ha contado.

El patrón es igual de bueno para equipos humanos. La mayoría de la decadencia en ingeniería no es que alguien elija hacer mal trabajo. Es que la gente acepta justificaciones plausibles para saltarse las partes que no le apetecen hacer.

3. La verificación NO es negociable¶

Cada skill termina en evidencia concreta. Tests pasan. La salida del build está limpia. El trace del runtime muestra el comportamiento esperado. Un revisor da el visto bueno. "Parece correcto" nunca es suficiente.

El agente es un generador. Necesitas una señal separada de que el trabajo está hecho. Las skills hornean esa señal en cada workflow.

4. Divulgación progresiva¶

No cargues las 20 skills en el contexto al inicio de la sesión. Actívalas según la fase.

Cada token cargado en el contexto degrada el rendimiento en algún lugar, así que cargas lo relevante y dejas el resto en disco. La divulgación progresiva es cómo metes una librería de 20 skills en un slot de 5K tokens sin envenenar el pozo.

5. Disciplina de scope¶

El meta-skill codifica algo que graparía a cada agente si pudiera: "toca solo lo que te piden tocar". No refactorices sistemas adyacentes. No elimines código que no entiendes completamente. No topes con un TODO y decidas reescribir el archivo.

Esto suena obvio hasta que ves a un agente decidir que arreglar un bug requiere modernizar tres archivos no relacionados. La disciplina de scope es el determinante más importante de si el PR de un agente es mergeable o hay que deshacerlo.

El ADN de Google¶

Addy trabaja en Google, y las skills están saturadas de prácticas de Software Engineering at Google y la cultura de ingeniería pública de Google. Esto es intencional. La mayoría de lo que hace que el software a escala de Google funcione está documentado y es público, y es exactamente la parte que los agentes son más propensos a saltar.

Ley de Hyrum en api-and-interface-design. Cualquier comportamiento observable de tu API eventualmente será dependido por alguien.
La pirámide de tests (~80/15/5) y la Regla de Beyoncé en test-driven-development. "Si te gustó, deberías haberle puesto un test".
DAMP sobre DRY en tests. La filosofía de testing de Google es explícita: el código de test debe leerse como una especificación, incluso a costa de algo de duplicación.
PRs de ~100 líneas, con etiquetas de severidad Critical / Nit / Optional / FYI en code-review-and-quality. Directamente de las normas de code review de Google. PRs grandes no se revisan; se sellan sin mirar.
La Valla de Chesterton en code-simplification. No elimines algo hasta que entiendas por qué fue puesto ahí.
Desarrollo basado en trunk y commits atómicos en git-workflow-and-versioning.
Shift Left y feature flags en ci-cd-and-automation. Atrapa problemas lo antes posible, desacopla deploy de release.
Código como pasivo en deprecation-and-migration. Cada línea que mantienes es una que tienes que mantener para siempre.

Ninguna de estas ideas es nueva. El punto es que ninguna de ellas está en el agente por defecto. Un modelo frontier ha leído la frase "Ley de Hyrum" en su training data, pero no aplica la Ley de Hyrum cuando diseña tu API a las 3 de la mañana mientras duermes. Las skills son cómo te aseguras de que sí lo hace.

Qué puedes usar aunque decidas no seguir la estrategia completa¶

Anti-racionalización como práctica de equipo. Escribe las mentiras que tu equipo se cuenta a sí mismo. "Arreglaremos los tests después del lanzamiento." "Este cambio es demasiado pequeño para un doc de diseño." "Está bien, tenemos monitorización." Empareja cada una con la réplica. Ponlo en tu AGENTS.md o en tu wiki de ingeniería. Te ahorrará argumentos y atrapará el próximo atajo del viernes por la tarde.

Proceso claro y sobre papel para cualquier cosa que escribas internamente. Si te encuentras escribiendo un documento de 2000 palabras titulado "cómo abordamos X", has escrito material de referencia. Conviértelo a un workflow con checkpoints. El documento se reduce a 400 palabras y la gente realmente lo ejecuta.

Verificación como criterio de salida duro. Haz que "producir evidencia" sea el paso de salida de cada tarea. Para agentes, para ingenieros, para ti mismo. La evidencia es lo que demuestra que el trabajo está hecho: una ejecución de tests en verde, una captura de pantalla, un log, una aprobación de review. Sin ella, la tarea no está hecha. "Parece correcto" nunca cierra el bucle.

Divulgación progresiva para cualquier manual. No escribas un manual de 50 páginas. Escribe un router pequeño que apunte al capítulo pequeño correcto para la situación. Esto es cierto para AGENTS.md, para runbooks, para playbooks de incidentes, para cualquier cosa que alguien lea bajo presión de tiempo.

Cinco no negociables, extraídos del meta-skill, que pondría en cualquier AGENTS.md mañana:

Saca a la luz las suposiciones antes de construir. Suposiciones equivocadas mantenidas en silencio son el modo de fallo más común.
Para y pregunta cuando los requisitos entren en conflicto. No adivines.
Empuja hacia atrás cuando sea warranted. El agente (o ingeniero) no es una máquina de decir sí.
Prefiere la solución aburrida y obvia. La astucia es cara.
Toca solo lo que te piden tocar.

Esa es una cultura de ingeniería válida en cinco líneas, y no necesitas instalar nada para adoptarla.

Mi lectura¶

Lo que propone Addy es distinto a lo de Every, pero complementario. Every se centra en el bucle de aprendizaje: cada iteración hace que el siguiente ciclo sea más fácil. Addy se centra en la disciplina: cada tarea debe pasar por las fases que un ingeniero senior nunca saltaría.

Every es compound engineering. Addy es harness engineering — construir el arnés que fuerza al agente a comportarse como un senior. El repositorio de Addy no es un framework, es una biblioteca de workflows portables. El mismo archivo SKILL.md funciona en Claude Code, Cursor, Gemini CLI, Codex, y cualquier otro entorno que acepte contenido de system prompt.

La implicación es clara: no basta con tener un agente potente. Necesitas un sistema que le impida tomar atajos. Las tablas anti-racionalización son la idea más brillante del proyecto porque atacan directamente la debilidad más peligrosa de los LLMs: su capacidad para producir justificaciones plausibles para hacer mal trabajo.

En mi propio flujo, voy a adoptar dos cosas inmediatamente: las tablas anti-racionalización para las tareas donde más fallo (saltarme tests en cambios "pequeños", asumir que "ya lo revisaré después"), y la regla de los cinco no negociables como checklist mental antes de cualquier sesión con un agente.

Recursos¶

Agent Skills en GitHub — El repositorio con las 20 skills (29K+ estrellas)
Agent Skills — el artículo — El post de Addy explicando el diseño
Agent Harness Engineering — El artículo sobre el arnés de agentes en general
Long-running Agents — Por qué los skills importan más en sesiones largas

Compound Engineering — La visión de Every sobre ingeniería con agentes

2026-05-06T00:00:00+02:00

En la primera parte de esta serie hablé de cómo los agentes de IA han cambiado mi forma de construir software. Pero eso era solo el calentamiento. Lo que viene ahora es la visión de una empresa que ha llevado esta idea al extremo: Every, la startup de Dan Shipper y Kieran Klaassen, que ha construido no solo productos con agentes, sino una metodología completa para hacerlo.

La llaman compound engineering.

El problema con la ingeniería tradicional¶

En la ingeniería de software clásica, cada nueva feature complica la siguiente. Más código significa más casos límite, más interdependencias, más sorpresas que nadie anticipó. Es una curva de complejidad que solo sube.

Every se dio cuenta de que con agentes escribiendo el código, esa premisa ya no tenía sento. Si un agente puede generar código en segundos, el cuello de botella deja de ser "escribir código" y pasa a ser "saber qué código escribir". Y si el agente puede aprender de cada iteración, la complejidad deja de ser un peso muerto y se convierte en combustible.

En compound engineering, cada feature hace más fácil la siguiente. No porque el código desaparezca, sino porque el sistema aprende de él.

El bucle de compound engineering¶

Every define cuatro pasos que se repiten en ciclo. El truco está en que el output de cada ciclo alimenta el siguiente:

1. Plan¶

Aquí es donde pasa el 40% del tiempo de un compound engineer. No escribir código, no revisar PRs. Planificar.

El agente investiga el codebase actual, lee la historia de commits, busca mejores prácticas en internet, y sintetiza todo en un plan de implementación detallado. Cuando empieza a escribir, ya está calentado. Ya conoce las convenciones del proyecto, los patrones que funcionaron antes, y los que fracasaron.

Este paso es crítico porque un agente sin contexto genera código genérico. Un agente con contexto genera código que encaja en tu arquitectura como si lo hubiera escrito un miembro del equipo.

2. Work¶

El agente escribe código y tests según el plan. Esto es lo que la mayoría de la gente imagina cuando piensa en "programar con IA": el agente genera funciones, clases, tests. Pero en compound engineering, este paso representa apenas el 10% del esfuerzo humano. El código se escribe solo. El valor está en todo lo que rodea a ese código.

3. Review¶

El ingeniero revisa el output. No solo busca bugs, sino que extrae lecciones. ¿Por qué el agente eligió esta abstracción? ¿Hubo un patrón que no reconoció? ¿Un edge case que olvidó?

En Every usan múltiples agentes revisoras especializadas: una para seguridad, otra para rendimiento, otra para simplicidad, otra para mantenibilidad. Cada una mira el código desde un ángulo diferente. El ingeniero humano orquesta estas revisiones y decide qué feedback incorporar.

4. Compound¶

Este es el paso que cambia todo. Las lecciones extraídas en la review no se quedan en la cabeza del ingeniero. Se documentan. Se codifican. Se convierten en parte del sistema.

Every usa archivos como CLAUDE.md y AGENTS.md donde se registra todo: patrones de código aprobados, decisiones arquitectónicas, bugs recurrentes y sus soluciones, estilos de nomenclatura, preferencias de diseño. La próxima vez que un agente trabaje en el proyecto, lee estos archivos antes de empezar. Cada ciclo hace que el agente sea más listo.

Un ejemplo real: el detector de frustración¶

Kieran Klaassen describe en Every cómo construyeron un "detector de frustración" para su producto Cora, un asistente de email con IA. El objetivo: detectar cuando un usuario se está frustrando con la app y generar automáticamente un reporte de mejora.

El flujo fue así:

Crearon una conversación de ejemplo donde un usuario expresa frustración (preguntas repetidas, lenguaje cada vez más conciso).
Le pidieron a Claude que escribiera un test que verifique si el sistema detecta esa frustración.
El test falló — como debe ser en TDD.
Le pidieron a Claude que escribiera la lógica de detección.
Funcionó parcialmente. Entonces le pidieron que iterara el prompt hasta que el test pasara.
Para evitar la no-determinación de la IA, hicieron que Claude ejecutara el test 10 veces.
Analizó los 6 fallos, leyó el chain-of-thought de cada uno, y descubrió un patrón: el sistema no detectaba lenguaje atenuado como "Hmm, not quite", que en contexto de repetición sí señala frustración.
Actualizó el prompt para buscar específicamente ese lenguaje. En la siguiente iteración, identificaba frustración 9 de 10 veces.
Codificaron todo el flujo en CLAUDE.md. La próxima vez que necesiten detectar una emoción o comportamiento de usuario, no empiezan de cero. Dicen: "usa el workflow del detector de frustración".

Ese es compound engineering en acción. No es solo resolver el problema de hoy. Es enseñar al sistema a resolver toda una categoría de problemas.

El plugin de compound engineering¶

Every ha open-sourcéado su sistema como un plugin que funciona con Claude Code, Codex CLI, Cursor y otros. Tiene más de 50 agentes especializados y 38 skills accesibles como slash commands.

Algunos de los skills más interesantes:

/ce-strategy — Crea o mantiene el STRATEGY.md del producto: problema, approach, persona, métricas clave.
/ce-plan — Genera planes estructurados para cualquier tarea multi-paso, con verificación de confianza automática.
/ce-brainstorm — Q&A interactivo para pensar un feature antes de planificarlo.
/ce-work — Ejecuta items de trabajo de forma sistemática.
/ce-debug — Encuentra root causes y fixea bugs con hipótesis testeables.
/ce-code-review — Review estructurada con múltiples agentes revisores en paralelo.
/ce-compound — Documenta problemas resueltos para que el equipo (y los agentes) aprendan.
/ce-compound-refresh — Revisa learnings obsoletos y decide si actualizar, reemplazar o archivar.
/ce-product-pulse — Genera reportes de uso, performance, errores y followups.
/ce-sessions — Busca en el historial de sesiones de Claude Code, Codex y Cursor.

Y las agentes revisoras son especialistas: hay una para contratos de API, otra para migraciones de datos, otra para carreras en frontend, otra para seguridad, otra para rendimiento. Cada una aplica su lente específico.

Por qué esto importa¶

Every corre cinco productos software, cada uno construido y mantenido principalmente por una sola persona. Productos que usan miles de personas todos los días. No son demos. Son negocios reales.

Su métrica: un solo desarrollador con compound engineering hace el trabajo de cinco desarrolladores tradicionales. No porque escriba más código, sino porque cada línea que escribe construye sobre todo lo aprendido antes.

La implicación es profunda. Si la ingeniería tradicional asume que escribir código es difícil y los ingenieros son escasos, compound engineering asume que el código es barato y el conocimiento es el activo valioso. La pregunta ya no es "¿cómo escribo esto?", sino "¿cómo enseño al sistema a escribir esto, y todo lo que se le parezca, para siempre?".

Mi lectura¶

Lo que propone Every no es una herramienta, es un cambio de paradigma. La ingeniería de software siempre ha tenido un componente de acumulación: bibliotecas, frameworks, patrones. Pero eso era acumulación de código. Compound engineering es acumulación de conocimiento sobre cómo construir.

El CLAUDE.md no es documentación para humanos. Es memoria para agentes. Y eso cambia la naturaleza del trabajo del ingeniero: deja de ser quien escribe código para ser quien diseña sistemas que escriben código, y que además aprenden de cada línea que generan.

No es futurismo. Every ya lo está haciendo. El plugin está en GitHub, con 16k+ estrellas. La pregunta no es si esto va a llegar a tu equipo, sino cuándo.

Recursos¶

Compound Engineering Plugin — El plugin open source de Every
Compound Engineering: How Every Codes With Agents — El artículo original de Dan Shipper y Kieran Klaassen
My AI Had Already Fixed the Code Before I Saw It — Kieran describe el sistema de compounding en acción

Ingeniería de Programación con Agentes

2026-05-06T00:00:00+02:00

Después de más de 20 años picando código, la llegada de los agentes de IA ha cambiado cómo trabajo más que cualquier framework o lenguaje nuevo. No se trata de que la IA escriba código por mí, sino de que me permita mantener el foco en lo que realmente importa: el diseño, la arquitectura y las decisiones técnicas que un agente no puede tomar. Esta será una serie de anotaciones que recoge el trabajo de varias semanas de prueba con diferentes metodologías y herramientas. Lo dividiré en varias partes, cada una explorando un enfoque distinto.

Nuevo flujo de trabajo¶

Trabajo con agentes como compañeros de pair programming que nunca se cansan. Les doy contexto, les planteo problemas y reviso su trabajo con el mismo criterio que aplicaría a un pull request de un compañero humano. La diferencia es que puedo iterar en segundos en lugar de horas.

No uso la IA para generar código que no entiendo. Cada línea que entra en un proyecto mío tiene que pasar por mi cabeza primero. Los agentes son excelentes para:

Escribir tests repetitivos o scaffolding
Explorar APIs o librerías nuevas
Refactorizar código siguiendo patrones que yo defino
Limpiezas y lintering

Lo que no funciona¶

Los agentes brillan en tareas bien delimitadas y fallan estrepitosamente cuando les pides que hagan diseño arquitectónico sin supervisión. He visto propuestas de abstracciones innecesarias, dependencias fantasmas y soluciones a problemas que no existían. La regla de oro: si no puedes explicarle el problema a un humano junior, tampoco podrás explicárselo a un agente.

El futuro¶

La ingeniería de software no va a desaparecer, pero sí va a mutar. Está mutando ya. Y muy, muy rápidamente.

En esta serie veremos varios procesos de ingeniería aplicados al uso de agentes: Compound Engineering (Every), Agent Skills (Addy Osmani), Superpowers (Jesse Vincent) y Skills para ingenieros reales (Matt Pocock). Cada uno con su filosofía, sus trade-offs y sus casos de uso.

Winhance: limpiar y optimizar Windows sin reinstallar

2026-05-05T00:00:00+02:00

Llevo usando Linux como sistema principal desde hace años. Tengo dos máquinas con Windows en casa: el portátil de mi hija y un pequeño Mele que uso para conectar al telescopio. No estoy acostumbrado a manejar el ecosistema de Windows, así que cuando toca reinstalar o limpiar una de esas máquinas siempre termino buscando utilidades que hagan el trabajo por mí.

Winhance es exactamente eso: una herramienta de C# con casi 10.000 estrellas en GitHub que permite debloater, optimizar y personalizar Windows 10 y 11 sin tener que reinstalar. Esencialmente hace lo mismo que UnattendedWinstall pero sin necesidad de una instalación limpia.

La instalación es ridiculamente simple desde PowerShell:

irm "https://get.winhance.net" | iex

También hay un instalador descargable desde winhance.net o GitHub Releases, con opción de instalación normal o portable.

Lo que me ha gustado:

Software & Apps: interfaz para quitar bloatware de Windows (apps preinstaladas, capacidades legacy, optional features) e instalar aplicaciones útiles via WinGet. Tiene categorías organizadas para navegadores, multimedia, visores de documentos, etc.
Optimize: todo en un panel searchable. Control del UAC, ajustes de privacidad, optimizaciones para gaming, configuración de Windows Updates, planes de energía, sonido y notificaciones. Cada opción con un toggle switch claro.
Customize: selector de tema oscuro/claro, personalización de la taskbar, menú inicio y el explorador de archivos.
Advanced Tools: herramienta para crear ISOs de Windows personalizadas con WIMUtil (incluyendo drivers del sistema actual) y generar archivos autounattend.xml basados en tus selecciones de Winhance.
Configuración exportable: puedes guardar toda tu configuración en un archivo para importarla después de una reinstalación. Esto es oro puro si manejas varias máquinas.

La licencia es PolyForm Shield 1.0.0, lo que significa que es gratis para uso personal, empresas y profesionales de IT, pero no puedes hacerle fork y redistribuirlo como producto competidor.

Me lo dejo aquí apuntado para la próxima vez que tenga que limpiar una de esas dos máquinas Windows. Seguro me ahorra un buen rato de clicks por el panel de configuración.

Extensiones de subagentes para pi: TintinWeb, NicoBailon y Taskplane

2026-05-03T15:23:00+02:00

La mayor ventaja de pi frente a otros coding agents son sus extensiones. Pi no trae subagentes, no trae plan mode, no trae MCP. Te da las primitivas para que montes lo que necesites. Si no quieres montarlo tú, instalas un paquete de terceros y listo.

Tengo varias extensiones propias en mi repo pcaropi, pero aquí voy a comparar tres enfoques distintos para delegar trabajo a subagentes — que es de lo más útil cuando trabajas con pi en proyectos serios.

Las tres alternativas¶

	TintinWeb	NicoBailon	Taskplane (HenryLach)
Paradigma	Subagentes individuales estilo Claude Code	Orquestración genérica (single/chain/parallel)	Orquestración por batches con waves, lanes y DAG
Instalación	`pi install npm:@tintinweb/pi-subagents`	`pi install npm:pi-subagents`	`pi install npm:taskplane`
Agentes built-in	3 (Explore, Plan, general-purpose)	8 (scout, researcher, planner, worker, reviewer…)	4 (supervisor, task-worker, task-reviewer, task-merger)
Chains / Parallel	❌	✅ Cadenas + fan-out/fan-in	✅ Waves con lanes paralelas según DAG
Git worktrees	✅ Básico	✅ Avanzado	✅ Nucleo del sistema
Web Dashboard	❌	❌	✅ Dashboard en vivo con SSE
Madurez	Early (0.6.3)	Maduro (0.24.0)	Initial release

TintinWeb — Subagentes al estilo Claude Code¶

@tintinweb/pi-subagents replica el modelo de Claude Code: herramientas Agent, get_subagent_result y steer_subagent. Pocos agentes (Explore, Plan, general-purpose), pero experiencia muy pulida: widget animado, conversation viewer interactivo, steering en caliente para redirigir agentes en ejecución.

Lo más diferencial: memoria persistente entre sesiones (project/local/user) y un event bus RPC para que otras extensiones spawneen subagentes.

Ideal si vienes de Claude Code y quieres algo familiar.

NicoBailon — El orquestador completo¶

pi-subagents de NicoBailon es el más maduro de los tres (0.24.0, 20K líneas de TypeScript). Una sola herramienta subagent con modos single, chain y parallel. Viene con 8 agentes built-in, 6 prompt templates predefinidos, y una TUI de preview para editar steps antes de lanzar.

Cosas que me gustan: model fallback en cascada (si un modelo falla por quota, prueba el siguiente), agent packages con namespacing, e integración con pi-intercom para comunicación hijo→padre.

Es el que uso yo en el día a día. Flexible, probado, bien documentado.

Taskplane — Orquestración por batches¶

Taskplane de HenryLach es otra cosa. No es un framework de subagentes genérico: es un sistema de orquestración de tareas por lotes. Las tareas se definen en archivos PROMPT.md + STATUS.md con pasos, dependencias y checkboxes. Un DAG organiza las tareas en waves, cada wave ejecuta lanes en paralelo con worktrees aislados, y un merge agent integra todo al final.

Tiene cosas brutales: dashboard web en vivo con SSE, workers multi-paso que mantienen contexto entre pasos, reviews inline automáticas, y auto-recovery que reintenta workers caídos. Incluso soporta polyrepo con dependencias cross-repo.

Para proyectos donde tienes un batch de features bien definidas con dependencias, es imbatible.

¿Cuál usar?¶

Delegar tareas sueltas con una experiencia limpia → TintinWeb
Orquestación flexible con chains, parallel y templates → NicoBailon
Ejecutar un batch de features con dependencias y reviews automáticas → Taskplane

Los tres se pueden instalar con un pi install npm:.... TintinWeb y NicoBailon pueden coexistir porque usan herramientas con nombres distintos. Taskplane tiene su propio paradigma y no debería conflictuar con ninguno.

Más extensiones y configuraciones de pi en mi repo pcaropi.

Fuente original: pi.dev

Bloqueo DNS de enlaces de AliExpress con NextDNS

2026-05-03T10:01:00+02:00

Llevaba unos días con un problema raro: los enlaces de AliExpress que aparecen en descripciones de vídeos de productos no cargaban. Firefox mostraba "Servidor no encontrado". Sabía que tenía pinta de ser un bloqueo DNS, porque al activar la VPN de PIA (Private Internet Access) el problema desaparecía.

El diagnóstico¶

El comando dig lo confirmó enseguida:

# Consultando al router (que usa NextDNS)
$ dig s.click.aliexpress.com @192.168.1.1

;; ANSWER SECTION:
s.click.aliexpress.com. 300 IN  A   0.0.0.0

# Consultando a Google DNS
$ dig s.click.aliexpress.com @8.8.8.8

;; ANSWER SECTION:
s.click.aliexpress.com. 300 IN  A   23.40.114.185

El router devolvía 0.0.0.0 para s.click.aliexpress.com. Eso no es un NXDOMAIN —dominio inexistente—, es un bloqueo deliberado: el dominio resuelve a una IP nula y el navegador no puede conectar.

Con la VPN activa, las consultas DNS pasaban por los servidores de PIA, que no aplican blocklists, y los enlaces funcionaban sin problema.

La causa¶

El router tenía configurado NextDNS con la lista de bloqueo por defecto. Bloqueaba bien el malware y el phishing, pero también estaba tocando dominios legítimos como los de redirección de afiliados. Demasiado agresiva para mi día a día.

La solución¶

La solución más simple habría sido añadir s.click.aliexpress.com a la lista blanca de NextDNS y ya está. Pero aproveché para revisar qué lista estaba usando y cambiarla por HaGeZi - Multi PRO, que de paso resolvía el problema.

Según la guía oficial de HaGeZi:

Lista	Nivel de bloqueo	Falsos positivos
Light	Relajado	Ninguno
Normal	Relajado/Equilibrado	Casi ninguno
Pro	Equilibrado	Muy raros ← recomendada
Pro++	Equilibrado/Agresivo	Algunos
Ultimate	Agresivo	Frecuentes

Multi PRO (~420k dominios, ~200k comprimidos) es la recomendación personal del autor de HaGeZi para un bloqueo efectivo sin problemas. Bloquea anuncios, trackers, telemetría, phishing, malware, scam, cryptojacking y "crap", con muy pocos falsos positivos.

El detalle clave: dominios de referral¶

La FAQ de HaGeZi dedica una sección entera a explicar que los dominios de referral —enlaces de afiliado/tracking como s.click.aliexpress.com— están permitidos en todas las listas, salvo unos pocos que también funcionan como trackers puros y solo se bloquean en Pro++ y Ultimate.

Estos dominios solo se activan tras un click manual del usuario y no se usan para mostrar publicidad. Bloquearlos rompe enlaces de resultados de búsqueda, ofertas, emails de confirmación, etc.

Resumen¶

Una blocklist DNS demasiado agresiva bloquea dominios que no son publicidad ni malware, sino mecanismos de redirección del comercio electrónico. El equilibrio está en Multi PRO: buena protección de privacidad sin romper funcionalidad cotidiana.

Si en algún momento necesito más agresividad, el precio será tener que desbloquear falsos positivos manualmente. Por ahora, Multi PRO va perfecto.

Más información: HaGeZi DNS Blocklists

Escaneo a doble cara con la Brother DCP-L3560CDW

2026-05-03T00:00:00+02:00

Mi nueva multifunción Brother DCP-L3560CDW no escanea a doble cara desde el alimentador. El ADF es solo simple cara, aunque la impresora sí imprime a dúplex.

Para documentos a una cara, el flujo es perfecto: meto las hojas en el alimentador, pulso Scan en la pantalla táctil de 3.7 pulgadas y el documento aparece directamente en la carpeta Samba de Paperless. Sin tocar el PC.

El problema llega con documentos a doble cara. La solución que uso:

Escaneo todas las páginas impares con el alimentador
Doy la vuelta al taco, pongo la última página boca arriba y escaneo las pares
En Document Scanner (simple-scan): menú hamburguesa → Reorder pages → Combine sides (reverse)
Guardo el PDF
Lo muevo a la carpeta de red para que Paperless lo ingiera

He mirado alternativas en KDE (Skanpage, Skanlite) pero ninguna tiene la función de intercalado manual que ofrece Document Scanner. Skanlite ni siquiera permite juntar varias páginas en un mismo PDF.

Seguiré investigando si hay alguna forma más directa. De momento, este flujo funciona.

marksman: LSP para Markdown

2026-04-29T22:46:00+02:00

Escribo bastante en Markdown — este blog, notas, documentación — y hasta ahora me las apañaba sin más. Pero tras acostumbrarme a los beneficios del LSP en código, empecé a echar en falta algo similar para mis archivos .md. Enlaces rotos, referencias a notas inexistentes, falta de autocompletado entre documentos... todo eso se acumula cuando mantienes varios ficheros.

Así que he instalado marksman, un servidor LSP dedicado exclusivamente a Markdown.

¿Qué es marksman?¶

marksman es un servidor de protocolo de lenguaje (LSP) que entiende la estructura de tus documentos Markdown. No solo resalta sintaxis: analiza enlaces internos, referencias entre archivos, títulos, tablas de contenido y mucho más.

Algunas de las funciones que ofrece:

Autocompletado de enlaces internos entre archivos Markdown.
Ir a definición (F12) para saltar a la sección o archivo referenciado.
Renombrar símbolos: cambia un título y actualiza todos los enlaces que apuntan a él.
Detección de errores: alerta sobre enlaces rotos o referencias inexistentes.
Información flotante (hover) para previsualizar contenido de enlaces.
Búsqueda de referencias para ver dónde se usa un título o archivo.

Básicamente, convierte un conjunto de archivos Markdown en algo parecido a un proyecto de código, con todas las ventajas de navegación y refactorización que eso conlleva.

Instalación¶

Lo he instalado con gah (GitHub Asset Helper), una herramienta que uso habitualmente para bajar binarios de releases de GitHub:

gah install artempyanykh/marksman

Seleccioné la versión marksman-linux-x64 y en cuestión de segundos ya tenía el binario disponible en el PATH.

También se puede instalar vía Homebrew, Snap, o descargando el binario directamente desde las releases del proyecto.

Configuración en `fresh`¶

Lo uso junto a fresh, mi editor de terminal preferido. fresh tiene soporte LSP nativo, así que solo tuve que asegurarme de que marksman esté en el PATH. Al abrir un archivo Markdown, fresh detecta automáticamente el servidor y ofrece iniciarlo:

Una vez arrancado, el menú LSP de fresh muestra todas las opciones disponibles:

¿Por qué me convence?¶

No necesito un editor gráfico pesado para escribir Markdown con comodidad. Con marksman + fresh tengo autocompletado de enlaces, navegación rápida entre notas, y detección de errores sin salir de la terminal. Es especialmente útil en este blog, donde hay decenas de artículos referenciándose entre sí.

Si trabajas habitualmente con Markdown y usas un editor con soporte LSP, marksman es una de esas herramientas que, una vez instaladas, te preguntas cómo has podido vivir sin ellas.

Repositorio oficial: marksman en GitHub

La subida de precio de los SBC (Single Board Computers)

2026-04-28T00:00:00+02:00

En mi cajón hay una Raspberry Pi 2, una Orange Pi PC, una ODROID-C2 y una Banana Pi M4 Zero. Las compré hace años, cuando 30 euros te daban una placa decente para cacharrear. Servidores DNS, Docker simplón, un poco de automatización en casa... funcionaban sin preguntar demasiado.

Mirando la comparativa de CNX Software, la Banana Pi BPI-M4 Zero pasó de $29 a $115. Casi un 300% de subida. La Raspberry Pi 5 de 8GB, de $80 a $175. La Orange Pi 5 Ultra de 16GB, de $125 a $309. Y así.

El culpable es el precio de la RAM. La demanda de memorias para GPUs de IA ha inflado los precios de todos los chips desde finales de 2025. Los fabricantes no pueden competir sin RAM, así que terminan subiendo precios o dejando de fabricar.

A mí me gustan los clusters de racks de 10 pulgadas. Una docena de placas para montar un mini-datacenter casero. Hoy eso costaría lo mismo que un servidor de segunda mano con más potencia y menos quebraderos de cabeza.

Los cacharritos han muerto. O mejor dicho: dejaron de ser el chollo que eran.

Fuente original: CNX Software

neofetch

2026-04-27T18:00:00+02:00

Me pasa constantemente: quiero saber rápidamente qué distro estoy usando, la versión del kernel, cuánto RAM tengo... y aunque he usado la herramienta mil veces, el nombre se me escapa de la cabeza.

Cada vez termino buscando en Google "el programita que te da información de tu distro en la terminal". Ya ni me esfuerzo en recordar.

Quizás algún día se me quede. Pero lo dudo.

Rufus, la mejor forma de instalar un Windows limpio

2026-04-27T12:00:00+02:00

Leo en informática sin límites que Rufus 4.14 (en fase beta) mejora sustancialmente su capacidad para instalar un Windows limpio.

Rufus lleva años siendo la referencia para crear medios de instalación de Windows. La nueva versión va más allá:

Deshabilita Teams, Outlook, Copilot y otros programas innecesarios de Microsoft
Permite usar cuentas locales en lugar de obligar a usar cuentas Microsoft
Elimina BitLocker (el cifrado que trae de cabeza a usuarios y empresas)
Nuevo modo desatendido: automatización completa de la instalación sin intervención del usuario

Si necesitas un Windows sin toda la basura que Microsoft intenta imponer, Rufus es la herramienta.

Fuente original: Rufus 4.14 - Informática sin límites

Proyecto: github.com/pbatard/rufus

Probando Aurora: mi primer vistazo al futuro del escritorio Linux

2026-04-24T09:51:00+02:00

Siempre he sido de KDE. Con distros Suse o Debian. Desde hace unos años mi escritorio principal es KDE Neon.

Pero últimamente he estado siguiendo el proyecto Aurora y decidí darle una oportunidad en una máquina virtual. Y tengo que decirlo: tiene muy buena pinta.

¿Qué es Aurora?¶

Aurora es una distribución Linux basada en Fedora que está replanteando cómo debería funcionar un escritorio moderno. No es solo "otra distro con KDE" — es un cambio de paradigma completo.

Lo primero que llama la atención es que usa un modelo image-based. En lugar de actualizar paquetes individuales con dnf o apt, el sistema operativo completo se actualiza como una imagen atómica. Esto significa:

Actualizaciones en segundo plano que se aplican al reiniciar
Rollback instantáneo si algo sale mal (puedes arrancar en la versión anterior desde el grub)
Sistema inmutable que es mucho más difícil de romper

Para alguien que viene de un sistema tradicional, con muchos años a sus espaldas, esto es un gran gran cambio.

KDE, pero diferente¶

Aurora usa KDE Plasma, pero no es el KDE simple original que se solía encontrar en Fedora (nunca fue la mejor distro para este gui). Está cuidadosamente personalizado para ofrecer una experiencia "out of the box" que simplemente funciona. No hay que configurar nada, no hay que instalar tweaks ni ajustes raros.

Y aun así, mantiene la esencia de KDE: es flexible, es potente, y se siente familiar desde el primer momento.

Aurora DX: el verdadero atractivo¶

Pero donde Aurora realmente brilla es en la Developer Experience (DX). Llevo días trasteando con esto y cada vez que descubro algo nuevo, parace una buena decisión. Eso sí, he de tener en cuenta que tengo mucho linux a mis espaldas y es difícil cambiar viejas costumbres.

Devcontainers por defecto¶

El IDE preinstalado es Visual Studio Code con la extensión de DevContainers ya configurada. Todo el desarrollo ocurre dentro de contenedores, no en el host. Esto significa:

Tu sistema operativo no se ensucia con dependencias de proyectos
Cada proyecto puede tener su propio entorno aislado
Puedes descartar y recrear entornos en segundos

Homebrew integrado¶

Aurora incluye Homebrew preinstalado y configurado para no tocar el sistema base. Quieres una herramienta CLI nueva? brew install. Listo. Sin conflictos con los paquetes del sistema, sin necesidad de sudo, sin romper nada. Ya sabéis que me gusta mantener algunas tools pequeñas muy actualizadas y usar gah para instalar.

Tienen incluso un ujust bbrew que te da un menú interactivo para instalar categorías enteras de herramientas: fonts, k8s-tools, ai, cncf...

ujust: comandos que simplifican la vida¶

ujust es como un alias con superpoderes. Comandos como:

ujust devmode        # Activa el modo desarrollador
ujust dx-group       # Te añade a los grupos necesarios
ujust jetbrains-toolbox  # Instala JetBrains Toolbox
ujust cncf           # Navega e instala herramientas CNCF

Cada comando te guía paso a paso. Es como tener un asistente que sabe exactamente qué necesitas.

Tailscale y herramientas cloud-native¶

Tailscale viene preconfigurado para VPN. Cockpit para gestión del sistema. Herramientas de profiling como sysprof, bcc, bpftrace. Todo lo que necesitarías para desarrollo cloud-native está ahí, listo para usar.

Terminal con soporte de contenedores¶

El terminal por defecto es Ptyxis, que tiene integración nativa con Distrobox. Puedes tener contenedores "pet" interactivos y cambiar entre ellos y el host con un atajo. Es muy cómodo.

Las grandes diferencias¶

En Aurora, el sistema se cuida solo:

No puedes romperlo fácilmente — el sistema base es inmutable
Las actualizaciones son atómicas — o funcionan completas, o no se aplican
Todo está en contenedores — tus herramientas, tus entornos, tus dependencias
Si algo falla, hay rollback — arrancas la versión anterior y listo

Es como la diferencia entre cuidar un jardín y vivir en un hotel. En un hotel, todo simplemente funciona.

¿Dejaré KDE Neon?¶

No lo sé aún. Llevo años en KDE Neon y tengo mi flujo de trabajo montado. Pero Aurora me está haciendo replantear cosas.

Lo que más me tira:

El DX es simplemente superior para desarrollo moderno
Las actualizaciones automáticas sin tener que estar pendiente
La filosofía de "todo en contenedores" tiene mucho sentido

Lo que me da miedo:

La inmutabilidad — al principio se siente restrictivo
El cambio de mentalidad — dejar de tener control total
¿Y si necesito algo específico? (que me a ocurrir seguro) — aunque con homebrew y contenedores, probablemente no sea mucho

Enlaces:

Ampliar disco de VM Aurora en Unraid y redimensionar particiones

2026-04-24T00:00:00+02:00

Ampliar disco de VM Aurora en Unraid y redimensionar particiones¶

Me quedé sin espacio en mi prueba de la distribución Aurora Linux. Como la ejecuto en una VM en mi NAS Unraid, simplemente aumenté el disco virtual y luego redimensioné las particiones dentro del sistema.

Esta es una distribución basada en Fedora Kinoite (imágenes OSTree/bootc) del proyecto Universal Blue, que usa un sistema de archivos Btrfs con subvolúmenes.

Situación inicial del disco¶

Antes de la expansión, el disco tenía aproximadamente 15GB y la partición principal estaba al límite:

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
vda    253:0    0   60G  0 disk
├─vda1 253:1    0  600M  0 part /boot/efi
├─vda2 253:2    0    2G  0 part /boot
└─vda3 253:3    0 12,4G  0 part /var/home, /var, /etc...

El filesystem Btrfs mostraba:

Device size:         12.41GiB
Device unallocated:    1.00MiB
Free (estimated):    512.12MiB (min: 512.12MiB)
Usage:               93%

Paso 1: Expandir el disco en Unraid¶

Desde la terminal de Unraid, con la VM apagada:

# Apagar la VM
virsh shutdown Aurora

# Expandir el disco a 60GB (triplicando el tamaño original)
qemu-img resize -f raw /mnt/user/domains/Aurora/vdisk1.img 60G

# Verificar el nuevo tamaño
ls -lh /mnt/user/domains/Aurora/vdisk1.img
qemu-img info /mnt/user/domains/Aurora/vdisk1.img

# Encender la VM
virsh start Aurora

Paso 2: Instalar growpart en Aurora¶

Aurora es un sistema inmutable basado en OSTree, así que necesité instalar la herramienta growpart usando rpm-ostree:

# Instalar cloud-utils-growpart
sudo rpm-ostree install cloud-utils-growpart

# Reiniciar (requerido después de rpm-ostree install)
systemctl reboot

Paso 3: Expandir la partición¶

Una vez reiniciado el sistema, expandí la partición 3 para ocupar todo el espacio del disco:

# Expandir la partición 3 del disco /dev/vda
sudo growpart /dev/vda 3

Output:

CHANGED: partition=3 start=5425152 old: size=26030080 end=31455231 new: size=120403935 end=125829086

Paso 4: Redimensionar el filesystem Btrfs¶

Aurora usa una estructura especial con múltiples subvolúmenes Btrfs:

root (ID 256) - sistema base (montado read-only en /sysroot)
home (ID 257) - directorios de usuario
var (ID 258) - variables del sistema

El truco está en que /sysroot está montado como read-only (por ser OSTree inmutable), pero puedo hacer el resize desde cualquier mount point con escritura del mismo filesystem Btrfs:

# Redimensionar desde /var (que tiene escritura)
sudo btrfs filesystem resize max /var

Output:

Resize device id 1 (/dev/vda3) from 12.41GiB to max

Resultado final¶

Después del redimensionamiento, el filesystem Btrfs muestra:

Device size:         57.41GiB    ← Antes era 12.41GiB ✓
Device unallocated:  45.00GiB    ← Espacio disponible
Device slack:          3.50KiB   ← Antes era 45.00GiB ✓
Free (estimated):    45.50GiB    ← Espacio libre para usar
Usage:               ~20%        ← Antes estaba al 93%

Verificando con lsblk:

NAME   MAJ:MIN RM  SIZE RO TYPE MOUNTPOINTS
vda    253:0    0   60G  0 disk
├─vda1 253:1    0  600M  0 part /boot/efi
├─vda2 253:2    0    2G  0 part /boot
└─vda3 253:3    0 57,4G  0 part /var/home, /var, /etc...

Resumen de comandos¶

# === EN UNRAID (VM apagada) ===
qemu-img resize -f raw /mnt/user/domains/Aurora/vdisk1.img 60G

# === EN AURORA ===
sudo rpm-ostree install cloud-utils-growpart
systemctl reboot
sudo growpart /dev/vda 3
sudo btrfs filesystem resize max /var

# === VERIFICAR ===
lsblk
df -h /var
df -h /var/home
df -h /etc
sudo btrfs filesystem usage /var

Notas importantes¶

Sistemas OSTree: En distribuciones inmutables como Aurora, el sistema base es read-only. El resize debe hacerse desde un subvolumen con escritura (/var, /etc, o /var/home).
Btrfs dinámico: El espacio en Btrfs se asigna dinámicamente a los subvolúmenes según necesidad. No es necesario asignar espacio específico a cada subvolumen.
Reinicio requerido: Después de rpm-ostree install, siempre hay que reiniciar para que los cambios surtan efecto.
Backup: Aunque el proceso es seguro, siempre es recomendable tener backup antes de operar sobre particiones. En mi caso no hizo falta por no tener nada importante. Es una VM de prueba.

Rust eBooks Nightly — libros de Rust en EPUB, AZW3, MOBI y PDF

2026-04-21T22:00:00+02:00

Rust eBooks Nightly es un proyecto de Artur Sulej que automáticamente construye y publica la última versión de los libros de Rust más importantes en EPUB, AZW3, MOBI y PDF. Se actualiza diariamente via GitHub Actions.

Los libros disponibles ahora mismo:

The Rust Programming Language (el libro oficial de rust-lang.org)
Rust By Example
The Rust Reference
The Rustonomicon — todo sobre código unsafe en Rust
The Cargo Book
Rust Cookbook
Asynchronous Programming in Rust
Learning Rust With Entirely Too Many Linked Lists — mi favorito para aprender alienist patterns
Rust Unsafe Code Guidelines
The Embedded Rust Book
The wasm-bindgen Guide
Real-Time Interrupt-driven Concurrency (RTIC)
The Rust and WebAssembly Book

La gracia del proyecto es que es nightly — cada día clona el repositorio de cada libro, lo construye con mdBook, lo convierte a los distintos formatos con Calibre, y lo sube a GitHub Pages. Si un libro falla en construirse, se salta y crea un issue automáticamente. Los demás siguen adelante.

Llevo tiempo usando un Likebook Muses y tener los libros de Rust siempre a mano es bastante útil.

Estos libros cubren la documentación oficial, así que están bien complementados con otros de pago y gran calidad como Programming Rust (O'Reilly), Rust for Rustaceans de Jon Gjengset o Black Hat Rust de Sylvain Kerkour.

Enlace: https://artur-sulej.github.io/rust-ebooks/ Repo: https://github.com/Artur-Sulej/rust-ebooks

Desactivar git autocrlf

2026-04-21T12:00:00+02:00

No soy usuario habitual de Windows, pero si me viese obligado una temporada WSL sería para mí casi una obligación. No está de más tener esta nota a mano (por Ryan Harrison).

Si usas Windows, Git lleva años modificando tus saltos de línea sin que te des cuenta. El culpable es core.autocrlf, activado por defecto.

git config --global core.autocrlf false

Qué hace `core.autocrlf`¶

Windows usa históricamente CRLF (\r\n) como salto de línea, mientras que Linux y macOS usan LF (\n). Con autocrlf true (el default en Windows):

En checkout: Git convierte LF del repositorio a CRLF en tu working directory
En commit: Git convierte CRLF de vuelta a LF antes de guardar

En teoría, tus ficheros locales quedan en formato Windows y el repositorio se mantiene limpio con LF. En la práctica, es fuente constante de problemas.

Por qué es un mal default¶

WSL lo agrava. Tu entorno Linux espera LF, pero Git ha convertido todo a CRLF. Resultado: cada script y config file tiene un \r fantasma al final de cada línea, provocando fallos silenciosos. Y si no has visto el warning de marras, es que ya te has acostumbrado a ignorarlo:

warning: LF will be replaced by CRLF in some-file.sh.
The file will have its original line endings in your working directory

Los editores modernos soportan LF sin problema. El argumento original era que el Bloc de notas de Windows no podía manejar LF — algo que era cierto en 2003. Desde Windows 10 (2018) el Bloc de notas soporta LF. VS Code, Sublime, Vim, IntelliJ, Notepad++... todos lo manejan perfectamente desde hace años.

La conversión es pérdida en la práctica. Ficheros binarios se pueden corromper si Git los clasifica mal como texto. Y si en un equipo alguien tiene autocrlf true y otro false, aparecerán commits que son solo cambios de saltos de línea.

La solución: desactívalo y usa `.gitattributes`¶

git config --global core.autocrlf false

A partir de ahí, Git deja tus saltos de línea tal cual — sin conversiones silenciosas. Para equipos, un fichero .gitattributes en el repositorio es un enfoque mucho mejor, porque aplica las mismas reglas para todos independientemente de su config local.

Usa LF en todas partes, configura tu editor para que guarde con LF por defecto, y no pienses más en ello.

Fuente original: Git - Disable autocrlf (Ryan Harrison)

Instalando skills de GitHub

2026-04-19T12:00:00+02:00

Dos formas principales de instalar skills para agentes de IA (Claude Code, Codex, Cursor, etc.): el nuevo subcomando gh skill de GitHub CLI y la herramienta npx skills de Vercel Labs.

`gh skill` — el enfoque oficial de GitHub¶

GitHub CLI ahora tiene un subcomando nativo para gestionar skills:

# Buscar skills
gh skill search terraform

# Instalar un skill específico
gh skill install github/awesome-copilot documentation-writer

# Previsualizar antes de instalar
gh skill preview github/awesome-copilot documentation-writer

# Actualizar todos los skills instalados
gh skill update --all

# Validar skills antes de publicar
gh skill publish --dry-run

Cómo instala: gh skill copia los archivos (no usa symlinks) e inyecta metadata de tracking directamente en el frontmatter del SKILL.md (repositorio, ref, tree SHA). Esta metadata permite que gh skill update detecte cambios reales de contenido comparando el tree SHA local vs el remoto.

Dónde instala: Por defecto en scope de proyecto (dentro del repositorio git actual), pero puedes usar --scope user para instalar en tu home directory y que esté disponible globalmente. Los directorios por agente son:

Agente	Proyecto	Usuario
GitHub Copilot	`.agents/skills`	`~/.copilot/skills`
Claude Code	`.claude/skills`	`~/.claude/skills`
Cursor	`.agents/skills`	`~/.cursor/skills`
Codex	`.agents/skills`	`~/.codex/skills`
Gemini CLI	`.agents/skills`	`~/.gemini/skills`
Antigravity	`.agents/skills`	`~/.gemini/antigravity/skills`

Nota: GitHub Copilot, Cursor, Codex, Gemini CLI, Antigravity y Pi comparten .agents/skills a nivel de proyecto.

Lo interesante es que está integrado directamente en gh, así que si ya usas GitHub CLI para todo, no necesitas otra dependencia más. Pero la búsqueda es bastante básica y limitada al ecosistema de GitHub.

`npx skills` — la herramienta de Vercel Labs¶

Llevo tiempo usando npx skills de Vercel Labs y me parece más completa para el día a día:

# Listar skills disponibles en un repo
npx skills add github/awesome-copilot --list

# Instalar un skill específico
npx skills add github/awesome-copilot --skill publish-to-pages

# Instalar todos los skills de un repo
npx skills add vercel-labs/agent-skills --all

# Actualizar skills
npx skills update

# Buscar skills de forma interactiva
npx skills find

Ventajas que le veo:

Soporte multi-agente: Funciona con Pi, Claude Code, Codex, Cursor, OpenCode, Gemini CLI, y más de 40 agentes. Cada uno tiene su directorio de skills y npx skills los gestiona todos.
Instalación flexible: Puedes instalar skills de forma global (-g) o por proyecto, y elegir entre symlink (recomendado para actualizar fácil) o copiar archivos.
Búsqueda interactiva: El comando npx skills find te da una interfaz tipo fzf para explorar skills disponibles.
Actualizaciones más granulares: Puedes actualizar skills individuales o todos, y elegir si son los globales o los del proyecto.

El punto débil es que la búsqueda no funciona del todo bien cuando un repo tiene múltiples skills — a veces no los encuentra todos o no los lista como esperas.

Pero donde npx skills realmente brilla es con npx skills find — una interfaz interactiva tipo fzf para explorar y buscar skills disponibles. Es muchísimo mejor que la búsqueda básica de gh skill:

Puedes buscar por palabra clave, navegar interactivamente por los resultados, ver el número de instalaciones y lanzar el comando de instalación directamente. Para descubrir nuevas skills, esta es la mejor opción sin duda.

Comparativa técnica¶

Característica	`gh skill`	`npx skills`
Método de instalación	Copia archivos	Symlink (recomendado) o copia
Scope por defecto	Proyecto	Proyecto
Scope global	`--scope user`	`-g` / `--global`
Tracking de versión	Tree SHA en frontmatter	Metadata similar
Update	Compara tree SHA local vs remoto	Git pull en el repo
Agentes soportados	6 (Copilot, Claude, Cursor, Codex, Gemini, Antigravity)	40+
Búsqueda interactiva	No (`gh skill search` es básico)	Sí (`npx skills find` con fzf)
Integración	Nativo en gh CLI	Herramienta independiente

`skills-lock.json` — el archivo de lock de `npx skills`¶

npx skills mantiene un archivo de lock global en ~/.agents/.skill-lock.json (formato v3) que registra:

Todos los skills instalados globalmente
Su origen (repo, URL, tipo de fuente)
Hash de la carpeta para detectar cambios
Fechas de instalación y última actualización
Preferencias del usuario (agentes seleccionados)

Actualmente funciona como registro para que npx skills update sepa qué verificar, pero no como manifiesto declarativo — no hay un comando npx skills install que restaure skills desde cero leyendo el lock (como haría npm ci). Es decir, si borras tus skills instalados, el lock file solo sirve como referencia, no para restaurar automáticamente.

Mi flujo actual¶

Para instalar skills nuevos:

# Ver qué skills tiene un repo
npx skills add github/awesome-copilot --list

# Instalar solo los que me interesan
npx skills add github/awesome-copilot --skill publish-to-pages --skill documentation-writer

Y para mantenerlos actualizados:

npx skills update

En resumen: me quedo con npx skills de Vercel sin duda. GitHub CLI está bien si solo usas Copilot y quieres todo integrado en gh, pero si trabajas con múltiples agentes (como yo, que uso Pi como principal), npx skills es muy superior por su soporte multi-agente, flexibilidad y sobre todo por npx skills find para descubrir nuevas skills.

Enlaces¶

Velvet OS: kernels modernos para hardware ARM antiguo

2026-04-17T00:00:00+02:00

Nota mental sobre Velvet OS, un proyecto que descubrí a través de esta entrada en Raspberry Pi para Torpes.

Velvet OS es un framework sencillo para construir imágenes de tarjetas SD arrancables con Debian o Ubuntu para diversos dispositivos ARM. El objetivo es proporcionar kernels de Linux modernos para hardware que ya no tiene soporte oficial o que quedó abandonado.

Lo interesante del proyecto:

Soporta más de 30 sistemas diferentes, desde Chromebooks ARM hasta SBCs como Odroid y OrangePi
Kernels actualizados (actualmente 6.12) para hardware que se quedó estancado en kernels 3.x o 4.x
Imágenes listas para usar, sin necesidad de compilar nada
Proyecto mantenido activamente por hexdump0815

El nombre "Velvet OS" viene de que el autor suele cubrir las tapas rayadas de sus Chromebooks con terciopelo autoadhesivo, haciendo desaparecer el branding comercial. La idea es que usar estas imágenes sea una experiencia tan agradable como tocar terciopelo.

Tengo varios cacharritos antiguos por casa, incluyendo dos OrangePi. A ver si saco un ratito para actualizarlos con kernels modernos y darles una segunda vida.

El tutorial de Raspberry Pi para Torpes explica en detalle cómo actualizar una ODROID-U3 de 2013 al kernel 6.12, incluyendo los pasos para configurar el U-Boot, copiar el kernel, generar el initrd y ajustar el boot.ini. Todo el proceso está muy bien documentado.

Enlaces:

Creación de vídeo con Gemini: personajes de Sevilla

2026-04-15T00:00:00+02:00

La creación de vídeo con IA generativa está mejorando a pasos agigantados. El último experimento que he probado es generar vídeos a partir de imágenes con Gemini.

El proceso es sencillo: creé tres imágenes con personajes ficticios inspirados en Sevilla, y Gemini las convirtió en vídeos con movimiento natural.

Aquí os dejo las tres imágenes originales:

Y el vídeo resultante:

Tu navegador no soporta vídeo HTML5.

Los resultados fueron satisfactorios. Los personajes se mueven de forma coherente, mantienen la consistencia visual y la calidad del movimiento ha mejorado notablemente respecto a versiones anteriores.

Es impresionante ver cómo la IA puede entender el contexto de una imagen y aplicar animaciones que parecen naturales. Todavía hay trabajo en detalles como las manos y ciertas deformaciones, pero el progreso es evidente.

Fuente original: Tweet en X

Google Stitch: Generación y prototipado UI con AI

2026-04-13T12:38:00+02:00

Google Stitch es una herramienta de diseño AI-native impulsada por Gemini para generar interfaces de usuario a partir de texto o imágenes.

El caso de uso¶

Diseñar flujos de UI y prototipos rápidos (dashboards, formularios, CRUDs) es un proceso repetitivo. Herramientas tradicionales como Figma son el estándar para diseño detallado, pero para la ideación rápida o para desarrolladores sin perfil de diseño, la generación mediante AI reduce drásticamente el tiempo.

Características principales¶

Tras la gran actualización de marzo de 2026, Stitch incluye:

Canvas infinito AI-native: Soporte para texto, imágenes y código simultáneamente.
Generación múltiple: Creación de hasta 5 pantallas conectadas a la vez.
Prototipado interactivo instantáneo: Transición entre pantallas generadas y autocompletado de flujos.
Soporte de voz: Posibilidad de dictar modificaciones o críticas de diseño en tiempo real.
DESIGN.md: Archivo markdown exportable que estandariza las reglas de diseño para ser consumidas por otros agentes o proyectos.

Exportación y código¶

Una de las ventajas es que Stitch no genera solo imágenes, sino código funcional exportable:

Frameworks soportados: HTML/CSS, Tailwind, Vue.js, Angular, Flutter y SwiftUI.
Integración con Figma: Permite exportar los diseños directamente a Figma para su refinamiento.
MCP y Google AI Studio: Facilita la conexión de Stitch con entornos de código y agentes como Antigravity.

Precios y límites¶

Actualmente Stitch opera dentro de Google Labs y es de uso gratuito, pero con cuotas:

350 generaciones mensuales estándar (Gemini 3 Flash)
200 generaciones mensuales experimentales o Pro (Gemini 3 Pro)

Consideraciones frente a Figma¶

Cuándo usar Stitch: Para prototipado ultra rápido, MVPs, flujos estándar (CRUDs) y para desarrolladores o product managers que necesiten materializar ideas sin dominar una herramienta de diseño.
Cuándo usar Figma: Para sistemas de diseño corporativos, identidades visuales complejas, colaboración multijugador masiva en tiempo real y flujos de trabajo fuertemente integrados.

Aunque la irrupción de Stitch amenaza el monopolio del diseño basado en "arrastrar rectángulos" para interfaces estándar, la exportación a Figma permite usarlos conjuntamente.

Fuentes: - Google Blog: Design UI using AI - NxCode: Google Stitch vs Figma

rbw sync: missing field `access_token`

2026-04-11T19:30:00+02:00

Hoy me he encontrado con este error al intentar sincronizar mi vault de Bitwarden con rbw:

$ rbw sync
rbw sync: failed to sync database from server: failed to parse JSON: missing field access_token at line 1 column 393

Diagnóstico¶

Es un bug conocido de rbw que existe desde 2020 (#32) y sigue abierto. Ocurre tanto con Bitwarden oficial como con Vaultwarden. No es un problema de la versión de Vaultwarden.

Causa: rbw guarda un token de sesión localmente que se corrompe o expira, y al intentar sincronizar, el servidor devuelve una respuesta JSON sin el campo access_token que rbw espera. El caché local de rbw queda en un estado inválido.

Solución¶

rbw purge
rbw sync

rbw purge limpia el caché local de la vault. Después, rbw sync te pedirá la master password y volverá a descargar todo desde cero.

Contexto del bug¶

Abierto desde diciembre de 2020 (#32), 19 👍, sin fix
Reabierto en agosto 2024 (#202) con la misma sintomatía
El maintainer (doy) no ha podido reproducirlo → sigue sin arreglarse
Aparece con más frecuencia tras añadir entradas nuevas (TOTP, SSH keys) desde otro cliente (browser extension, web vault) y luego intentar sync desde rbw

TL;DR: rbw purge && rbw sync y debería funcionar.

rbw-env: Exportar variables de entorno desde Bitwarden

2026-03-26T20:55:00+01:00

Siguiendo con la saga de kitty-rbw, hoy presento otro script del mismo proyecto: rbw-env.

El problema¶

Uso pi-agent con diferentes modelos de IA (Claude, OpenAI, Gemini...) y cada uno requiere su propia API_KEY. Mantener estas claves en el disco es un riesgo de seguridad, y tener que introducirlas cada vez es tedioso.

La solución: rbw-env¶

El script permite exportar entradas de Bitwarden como variables de entorno. La idea es sencilla pero efectiva:

Seleccionas una carpeta con fzf (por ejemplo, "ai-providers")
rbw-env exporta cada entrada como export VARIABLE='valor'
El archivo temporal se borra solo después de hacer source

Uso¶

# Seleccionar carpeta interactivamente
kitty @ kitten kitty_rbw/rbw_env.py

# O pasar la carpeta como argumento
kitty @ kitten kitty_rbw/rbw_env.py ai-providers

El comando crea un archivo temporal en /tmp/kitty_rbw_env_* y envía el comando source a la ventana:

source /tmp/kitty_rbw_env_qfdhyh_b

La última línea del archivo temporal es el borrado del propio archivo:

rm -f /tmp/kitty_rbw_env_qfdhyh_b

La idea es no hacer los export directamente en la terminal para que no se vean por pantalla (a veces grabo tutoriales por ejemplo)

Estructura en Bitwarden¶

Cada entrada en la carpeta exportada usa:

Usuario: nombre de la variable (ej: ANTHROPIC_API_KEY)
Contraseña: valor de la variable (ej: sk-ant-...)
Nombre: descripción opcional

Si alguna entrada tiene usuario o nombre igual a NOEXPORT, se ignora (útil para notas).

Integración con kitty-rbw¶

En la entrada anterior explico cómo instalar kitty-rbw. Con Ctrl+Alt+Shift+b tengo el selector de carpetas para exportar las variables de entorno.

Crit: El bucle de revisión para Agentes

2026-03-22T14:49:00+01:00

Revisar lo que un agente de IA escribe directamente en la terminal es, a menudo, una pesadilla. No puedes señalar una línea concreta, dar feedback estructurado y, cuando el agente actualiza el archivo, te toca volver a leerlo todo para ver qué ha cambiado realmente.

Ahí es donde entra Crit.

Crit abre los archivos generados o modificados por tu agente en el navegador con una interfaz al estilo GitHub. Puedes dejar comentarios en líneas específicas, sugerencias de cambio y, lo mejor de todo, ver los diffs entre las distintas rondas de iteración.

Lo que más me ha gustado es su enfoque multi-agente y su usabilidad. No importa si usas Claude Code, Cursor, Aider o, como en mi caso, OpenCode. Crit se integra de maravilla.

Instalación y configuración¶

La instalación es tan sencilla como:

gah install tomasz-tomczyk/crit

Una vez instalado, integrarlo con OpenCode es cuestión de un comando:

crit install opencode

Esto instala los comandos y las skills necesarias para que los agentes puedan usar Crit. Al ejecutar /crit en OpenCode, se inicia el bucle de revisión: el agente propone un plan o cambios, Crit abre la interfaz web para que tú des el visto bueno o corrijas, y el agente recibe tu feedback estructurado en un archivo .crit.json para actuar en consecuencia.

Nota para mi yo del futuro: Si usas pi-agent en vez de OpenCode, puedes copiar el comando de OpenCode como prompt y copiar el skill de crit tal cual — funciona perfectamente. De hecho, esta misma anotación ha sido revisada usando pi-agent con Crit.

Por qué usarlo¶

Interfaz Web, no TUI: Renderizado de Markdown y diffs visuales persistentes.
Diffs entre rondas: Ves exactamente qué ha cambiado desde tu último comentario.
Agnóstico al agente: Funciona con cualquier herramienta, permitiendo un flujo de trabajo consistente.
Sugerencias directas: Puedes insertar sugerencias que el agente puede aplicar tal cual.

Por ejemplo, el propio cambio que subsanó el problema de la coma de esta misma anotación:

Es, sin duda, la pieza que faltaba para que el trabajo con agentes sea realmente colaborativo y no una sucesión de "copy-pasted" y revisiones manuales tediosas.

Joyas ocultas en pi-powerline-footer

2026-03-22T00:00:00+01:00

Llevo usando pi-powerline-footer un tiempo, principalmente por su funcionalidad principal: ese footer con información útil del modelo, contexto, tokens y coste. Pero hace poco descubrí dos features que han cambiado cómo trabajo con pi en el día a día.

Editor Stash: tu portapapeles temporal integrado¶

Con Alt+S puedes guardar el contenido actual del editor, limpiarlo, escribir algo rápido (por ejemplo, una pregunta corta a otro agente), y cuando termine, tu texto original vuelve automáticamente.

Es perfecto cuando estás en medio de una tarea compleja y necesitas hacer una consulta rápida sin perder el contexto. O cuando quieres guardar un bloque de código que vas a reutilizar después.

Además, tienes atajos para copiar (ctrl+alt+c) y cortar (ctrl+alt+x) el contenido completo del editor, y un historial de stashs accesible con ctrl+alt+h que persiste entre sesiones.

Model Profiles: navegación rápida entre configuraciones de modelo¶

Esta es la feature que más uso ahora mismo. Con varios providers activos —principalmente OpenRouter (con sus muchísimos modelos), Google Gemini y OpenCode— cambiar entre modelos era un lío.

Los Model Profiles guardan combinaciones de modelo + nivel de thinking. Los defino en ~/.pi/agent/settings.json:

{
  "modelProfiles": [
    {
      "model": "google/gemini-3-pro",
      "thinking": "high",
      "label": "Gemini Deep"
    },
    {
      "model": "anthropic/claude-opus-4-5",
      "thinking": "xhigh",
      "label": "Opus Ultra"
    },
    { "model": "openai/codex-5.3", "thinking": "low", "label": "Codex Fast" }
  ]
}

Con alt+shift+tab ciclo entre perfiles y con ctrl+alt+m abro un selector visual. El cambio es instantáneo —no más menúes interminables buscando el modelo exacto.

Es especialmente útil con OpenRouter, donde la lista de modelos es enorme. En lugar de navegar por todos, tengo mis 3-4 configuraciones preferidas y alterno entre ellas según la tarea.

La documentación del plugin está llena de pequeñas utilidades: Working Vibes para mensajes de carga temáticos, atajos de teclado configurables, integración con git... Pero estas dos features que he descrito son las que más impacto tienen en mi flujo de trabajo diario.

Si aún no lo has probado: pi install npm:pi-powerline-footer y luego /reload.

Agent Browser: Navegación para Agentes

2026-03-18T09:00:00+01:00

agent-browser (https://github.com/vercel-labs/agent-browser) me permite que los agentes de IA puedan navegar por la web y realizar acciones complejas como si fueran un humano.

Lo tengo integrado en una skill y lo uso habitualmente con pi agent para automatizar tareas que requieren interacción con el navegador. Es brutal lo que se puede conseguir cuando el agente puede "ver" y "actuar" en la web directamente.

Tailscale Aperture: Gateway de IA sin distribuir API keys

2026-03-16T10:00:00+01:00

Una de las cosas que me quitó el sueño cuando empecé a usar LLMs en el trabajo fue: ¿dónde guardo las API keys? En repositorios privados, en .env files que se me olvidaban gitignorear, en notas del móvil... Un desastre.

Tailscale anunció recientemente Aperture, un AI gateway que corre dentro de tu tailnet y que elimina completamente ese problema.

El problema de las API keys distribuidas¶

Cuando los desarrolladores necesitan acceso a OpenAI, Anthropic, o cualquier otro proveedor de LLM, la práctica habitual ha sido:

Crear una API key
Compartirla por Slack, email, o pegada en un repo privado
Rezar porque no se filtrre
Cuando alguien se va, rotar manualmente todas las keys

Esto escama mal. Una organización con 50 desarrolladores puede tener cientos de keys flotando en documentos, scripts de CI/CD, y machines de desarrolladores que ya no están en la empresa.

Aperture: centralización con identidad real¶

La solución de Tailscale es elegante: usar la identidad del tailnet para autenticar, no keys distribuidas.

Cómo funciona:

Configuras Aperture en tu tailnet con las API keys de tus proveedores (OpenAI, Anthropic, Google, OpenRouter, etc.)
Los desarrolladores se conectan a Aperture usando su identidad de Tailscale
Aperture inyecta las credenciales del proveedor correspondiente y reenvía la petición
Telemetría completa: tokens usados, costos, sesiones, todo en un dashboard

Los desarrolladores nunca ven las API keys reales. Aperture las mantiene centralizadas y las inyecta server-side.

Integración con herramientas existentes¶

Lo bueno es que funciona con las herramientas que ya usas:

-Claude Code: Configuras ANTHROPIC_BASE_URL=http://ai y listo - Codex: Base URL a Aperture - Gemini CLI, Roo Code, Cline: Similar, cambias la URL base - Custom apps: Funciona con cualquier cliente que use OpenAI-compatible APIs

Desde el punto de vista del cliente, Aperture se ve como el proveedor mismo. Detecta el modelo en el request body y enruta al proveedor correcto.

pi-ts-aperture: Plugin para Pi¶

Hay un plugin oficial de Pi para routearte automáticamente a través de Aperture:

pi install npm:@aliou/pi-ts-aperture
/aperture:setup

El asistente te pide: 1. URL de tu Aperture (ej: ai.your-tailnet.ts.net) 2. Qué proveedores routear

Guarda la configuración en ~/.pi/agent/extensions/aperture.json y modifica los providers para usar Aperture como proxy.

Visibilidad y control¶

El dashboardde Aperture te da:

Tokens por modelo y usuario: ¿Cuánto gasta cada persona?
Sesiones agrupadas: Una sesión de Claude Code puede tener 50 requests; las ves como una unidad coherente
Tool use: Qué herramientas se están invocando y con qué frecuencia
Adopción: Quién está usando qué, y quién probó una vez y no volvió
Export a S3: Para integrar con tu SIEM habitual

Para equipos de plataforma o seguridad que necesitan auditoria, esto es oro.

Requisitos¶

Un tailnet de Tailscale (fundamental, toda la autenticación depende de la identidad de Tailscale)
API keys de los proveedores que quieras usar
El dispositivo que corre Pi debe estar en el tailnet

En resumen¶

Si tu organización está adoptando herramientas de IA y no quieres lidiar con API keys circulando por todos lados, Aperture es una solución limpia. Centraliza credenciales, da visibilidad real del uso, y usa la infraestructura de identidad que ya tienes con Tailscale.

Está en alpha todaví a, pero disponible gratuitodurante el periodo de testing. Vale la pena probarlo si ya usas Tailscale.

sem: Control de versiones semántico

2026-03-15T14:11:00+01:00

Me encontré con sem hace unas semanas y me parece una idea brutal. Es un CLI que va más allá del diff tradicional línea a línea y entiende la estructura real del código.

La diferencia entre líneas y entidades¶

Cuando haces un git diff tradicional, ves algo como:

- const oldAuth = function(user) { ... }
+ const newAuth = async function(user) { ... }

Pero con sem diff ves:

⊕ function validateToken          [added]
∆ function authenticateUser       [modified]
⊖ function legacyAuth             [deleted]

No líneas añadidas o eliminadas, sino entidades que cambiaron: funciones, clases, métodos. Mucho más útil para entender qué pasó realmente en el PR.

Comandos disponibles¶

sem diff: Muestra qué entidades cambiaron
sem impact <entidad>: Analiza qué se rompería si cambias esa entidad (dependencias entrantes)
sem blame: Blame a nivel de entidad — quién cambió cada función/clase
sem graph: Muestra el grafo de dependencias entre entidades

Ejemplo práctico¶

# Ver qué entidades cambiaron en working directory
sem diff

# Ver solo cambios staged
sem diff --staged

# Ver cambios de un commit específico
sem diff --commit abc1234

# Ver impacto de cambiar una función
sem impact validateToken

# Salida JSON para pipelines CI
sem diff --format json

Instalación¶

# macOS
brew install sem-cli

# Linux (mi caso)
brew install sem-cli
# o descargar binario de GitHub Releases

O build from source si tienes Rust instalado:

git clone https://github.com/Ataraxy-Labs/sem
cd sem/crates
cargo install --path sem-cli

Why esto es útil¶

Para mí, principalmente dos casos:

Code reviews más rápidas — Entiendes el impacto real de un cambio en segundos
Refactors seguros — Antes de renombrar una función crítica, sem impact te dice qué puede romperse

Soporta 20 lenguajes (incluyendo Python, Rust, Go, TypeScript, Java, C++, etc.) usando tree-sitter para parsear el código.

Una herramienta que va directo a mi toolkit diario.

os.click: Central de descarga de ISOs de sistemas operativos

2026-03-12T10:00:00+01:00

La próxima vez que necesite una ISO de Windows o alguna distro Linux y no quiera estar media hora saltando entre menús de Microsoft o buscando el "mirror" correcto, entrar directamente en os.click.

Me ha pasado hoy buscando una ISO de Windows 11 para una VM; nunca me acuerdo de la URL exacta y os.click me ha salvado el rato. Lo bueno que tiene:

Enlaces directos: No alojan nada, te mandan al servidor oficial (Microsoft, Canonical, etc.).
Limpio: Sin anuncios raros ni botones de "Download" falsos.
Variedad: Tienen Windows (10, 11, Server) y casi cualquier distro Linux que use habitualmente.

Básicamente es un índice bien organizado. Para no olvidarlo.

De net-tools a iproute2: equivalents de comandos

2026-03-06T11:30:00+01:00

Más de 30 años con Linux, y es difícil cambiar a lo que ya estás acostumbrado. En mi caso, siempre he usado ifconfig, arp, route y netstat para configurar y diagnosticar la red. Pero estos comandos pertenecen al paquete net-tools, que lleva años siendo reemplazado por iproute2.

net-tools vs iproute2¶

Tradicionalmente ha habido dos formas de configurar la red en Linux:

La forma antigua: con comandos como ifconfig, arp, route y netstat, que pertenecen al paquete net-tools
La forma nueva: mayormente (¡pero no enteramente!) encapsulada en un único comando ip, que pertenece al paquete iproute2

Parece que iproute2 fue marcado como "important" en Debian en 2008, lo que significa que cada lanzamiento desde Debian 5 "lenny" (!) ha incluido el comando ip.

He estado entrenando lentamente a mi cerebro para usar los nuevos comandos, pero a veces olvido algunos. Aquí tienes una tabla de equivalencias:

net-tools	iproute2	Forma corta	Función
`ifconfig`	`ip address`	`ip a`	Mostrar/configurar direcciones IP
`ifconfig -s`	`ip link`	`ip l`	Mostrar estado de enlaces (up/down, contadores)
`route`	`ip route`	`ip r`	Mostrar o modificar la tabla de rutas
`arp`	`ip neigh`	`ip n`	Mostrar tabla ARP/vecinos
`netstat`	`ss`	`ss`	Mostrar estadísticas de sockets

Comparación visual¶

Aquí puedes ver la diferencia entre usar ip a y ip -br -c a:

`ip a` (salida completa)¶

`ip -br -c a` (salida resumida y coloreada)¶

Mi alias favorito¶

También suelo crear un alias para que la salida sea más legible:

alias ip='ip -br -c'

Esto proporciona una salida mucho más bonita y legible, como puedes ver en la segunda imagen.

¿Tú sigues usando los comandos antiguos o ya te has pasado a iproute2?

Solución al Error de Rodney con Chrome en Wayland

2026-03-06T09:00:00+01:00

Rodney es una herramienta CLI creada por Simon Willison diseñada específicamente para que agentes de IA puedan controlar una instancia de Chrome mediante el Chrome DevTools Protocol. Es similar a agent-browser de Vercel, pero usando CDP en lugar de Playwright.

El Problema¶

Al ejecutar uvx rodney open https://google.es sin iniciar primero Rodney con rodney start, el proceso falla porque:

Rodney intenta iniciar Chrome con el Chromium que descarga automáticamente en ~/.cache/rod/browser/
Ese Chromium (v128.0.6568.0) tiene un bug conocido con el backend Ozone en sistemas Wayland
El crash ocurre debido a la combinación de flags --single-process + --ozone-platform=headless
El error en los logs indica: gl_factory_ozone.cc(62): "Expected Mock or Stub, actual:0"

La Solución¶

La forma más sencilla de solucionar este problema es configurar Rodney para que use el Chrome de tu sistema en lugar del Chromium descargado automáticamente. Esto se hace mediante la variable de entorno ROD_CHROME_BIN:

# Añadir a ~/.bashrc o ~/.zshrc
echo 'export ROD_CHROME_BIN=/usr/bin/google-chrome' >> ~/.bashrc
source ~/.bashrc

Después de configurar esto, Rodney funcionará correctamente:

uvx rodney start
uvx rodney open https://google.es

Ejemplo de funcionamiento¶

Una vez configurado, el flujo de trabajo es:

~/src/anotaciones [cv|…2] 
09:39 $ uvx rodney start
Chrome started (PID 2981885)
Debug URL: ws://127.0.0.1:34373/devtools/browser/319c905a-83a2-47d9-a6e0-8e6a4f2ff830
~/src/anotaciones [cv|…2] 
09:39 $ uvx rodney open https://google.es
Google
~/src/anotaciones [cv|…2] 
09:39 $ uvx rodney screenshot
screenshot.png
~/src/anotaciones [cv|…3]

¿Por qué pasa esto?¶

El Chromium que Rodney descarga automáticamente tiene un bug conocido con el backend Ozone en sistemas Linux que usan Wayland (la alternativa a X11). Cuando se usan ciertas combinaciones de flags de Chrome, el proceso falla porque el sistema gráfico no está configurado como "Mock" o "Stub" (que es lo que esperan las pruebas).

Usar el Chrome del sistema evita este problema porque: - El Chrome del sistema está compilado con soporte completo para Wayland - Generalmente es una versión más estable y actualizada - No tiene los mismos flags de desarrollo que causan conflictos

Enlace¶

Repositorio de Rodney en GitHub

Graba y Comparte tus Sesiones de Terminal con asciinema

2026-02-27T12:00:00+01:00

A menudo necesitamos compartir lo que sucede en nuestra terminal, ya sea para un tutorial, demostrar un error o simplemente documentar un proceso. Aunque existen herramientas para grabar vídeo tradicional, asciinema ofrece una alternativa mucho más potente y ligera.

¿Qué es asciinema?¶

asciinema no graba vídeo en el sentido tradicional (píxeles). En su lugar, captura el flujo de texto de la terminal junto con los tiempos exactos. Esto tiene varias ventajas:

Archivos diminutos: En lugar de megabytes de vídeo, obtienes archivos de texto muy pequeños.
Texto seleccionable: Al reproducir una sesión en la web, puedes copiar y pegar el código directamente.
Calidad perfecta: No hay pérdida de resolución ni artefactos de compresión.

Instalación y Ayuda¶

Ya tengo asciinema instalado en mi sistema. Aquí puedes ver el resumen de comandos disponibles:## Ejemplo interactivo

A continuación puedes ver una pequeña demostración de asciinema en acción, ejecutando el comando cowsay Muuuuu:

Comandos básicos¶

Para empezar a grabar, simplemente ejecuta:

asciinema rec demo.cast

Esto comenzará a grabar todo lo que ocurra en tu sesión actual de terminal. Cuando termines, simplemente presiona Ctrl-D o escribe exit. El resultado se guardará en el archivo demo.cast.

Para reproducirlo localmente:

asciinema play demo.cast

Y si quieres compartirlo con el mundo, puedes subirlo a su servicio de alojamiento gratuito:

asciinema upload demo.cast

¿Por qué usarlo?¶

Es ideal para desarrolladores que escriben blogs técnicos (como este), ya que permite insertar las grabaciones directamente en el navegador con un reproductor ligero basado en JavaScript. ¡Adiós a los GIFs borrosos de 20MB!

kitty-rbw: Acceso rápido a Bitwarden desde tu terminal kitty

2026-02-26T14:20:00+01:00

En la entrada anterior hablamos de rbw, el cliente de Bitwarden para terminal escrito en Rust que destaca por su velocidad y por usar un agente para gestionar el desbloqueo del almacén.

Hoy doy un paso más allá y presento kitty-rbw, un kitten que he desarrollado para el terminal kitty. Su objetivo es permitirte buscar y usar tus credenciales de Bitwarden sin tener que salir del terminal ni escribir comandos complejos, integrándose perfectamente en tu flujo de trabajo.

¿Qué es un kitten?¶

Los kittens son pequeños programas en Python que extienden las funcionalidades del terminal kitty. Pueden ejecutarse en ventanas superpuestas (overlays), lo que los hace ideales para herramientas interactivas que no queremos que ensucien nuestro historial del terminal.

Características principales¶

kitty-rbw utiliza fzf para ofrecer una búsqueda difusa (fuzzy search) extremadamente rápida sobre tu almacén de rbw. Estas son sus funciones más destacadas:

Búsqueda simultánea: Filtra por nombre, usuario y carpeta al mismo tiempo.
Inyección directa: Escribe la contraseña o el usuario directamente en la ventana activa del terminal donde lanzaste el kitten. Ideal para prompts de sudo o inicios de sesión SSH.
Soporte para el portapapeles: Copia el usuario, la contraseña o el código TOTP con un solo atajo de teclado.
Priorización de uso: Las 10 entradas que más utilizas aparecen al principio de la lista, facilitando el acceso a lo más común.
Atajos por carpeta: Puedes configurar el kitten para que se abra pre-filtrado por una carpeta específica (por ejemplo, una para el trabajo y otra personal).

Instalación¶

Para instalarlo, solo tienes que clonar el repositorio en tu directorio de configuración de kitty:```bash cd ~/.config/kitty git clone https://github.com/pcaro/kitty_rbw

Luego, añade un atajo de teclado en tu `kitty.conf`:

```conf
map kitty_mod+b kitten kitty_rbw/rbw.py

Uso y atajos¶

Una vez configurado, al pulsar el atajo (Ctrl+Shift+b por defecto) se abrirá un panel con tus credenciales.

Tecla	Acción
`Enter`	Escribe la contraseña en el terminal
`Ctrl+u`	Escribe el nombre de usuario
`Ctrl+b`	Escribe usuario, pulsa `Tab` y luego contraseña
`Ctrl+t`	Copia el código TOTP al portapapeles
`Alt+p`	Copia la contraseña al portapapeles
`Alt+u`	Copia el usuario al portapapeles
`Alt+s`	Sincroniza el almacén (`rbw sync`)

Si quieres saber más o contribuir al proyecto, puedes encontrarlo en GitHub: https://github.com/pcaro/kitty_rbw

rbw: El cliente de Bitwarden para terminal que deberías usar

2026-02-26T11:45:00+01:00

Aunque Bitwarden tiene un cliente oficial de línea de comandos, este puede resultar lento al estar basado en Node.js. Para los que buscamos algo más ágil, rbw es la solución ideal. Es una implementación no oficial en Rust que destaca por ser extremadamente rápida y por gestionar el desbloqueo del almacén mediante un agente, evitando que tengas que introducir tu contraseña maestra en cada comando.

Instalación¶

La forma más sencilla de instalarlo es bajando el binario directamente desde sus releases de GitHub. Yo utilizo gah para este propósito:

gah install doy/rbw

Este comando descargará el binario de rbw y el de rbw-agent.

Configuración inicial¶

Lo primero es configurar tu cuenta y el servidor:

rbw login

Te pedirá tu email y la URL del servidor (puedes dejarla en blanco si usas el oficial de Bitwarden o poner la de tu instancia de Vaultwarden).

Para empezar a usarlo, desbloquea el almacén:

rbw unlock

A diferencia del cliente oficial, no necesitas exportar variables de entorno con tokens de sesión. El agente de rbw se encarga de todo en segundo plano.

Uso básico¶

Para obtener una contraseña rápidamente:

rbw get "Nombre del Elemento"

Si hay varios elementos con el mismo nombre, puedes usar filtros o el ID. También puedes obtener campos personalizados o el nombre de usuario:

rbw get "OpenRouter" --folder "APIs"
rbw get --username "Twitter"

Integración con pi-agent¶

Una de las mayores ventajas de tener un cliente CLI rápido y seguro es la capacidad de integrar secretos en tus herramientas de desarrollo.

pi-agent permite ejecutar comandos para obtener claves de API dinámicamente. Esto evita tener que guardar claves en archivos de configuración en texto plano. En tu settings.json, puedes configurar el acceso a una clave de la siguiente manera:

{ 
    "type": "api_key", 
    "key": "!rbw get 'OpenRouter'" 
}

El prefijo ! indica a pi-agent que debe ejecutar el comando y usar su salida estándar como la clave. Gracias al agente de rbw, este comando se ejecutará instantáneamente sin pedirte la clave maestra cada vez, siempre que el almacén esté desbloqueado.

DeepDiff: La navaja suiza para comparar datos en Python

2026-02-20T00:00:00+01:00

Cuando trabajamos con datos estructurados en Python, a menudo necesitamos comparar dos diccionarios, JSONs u objetos complejos para encontrar qué ha cambiado. Si bien la comparación directa (==) es útil, a veces necesitamos entender exactamente qué es diferente: qué claves se han añadido, cuáles se han eliminado, o dónde han cambiado los valores, incluso en estructuras profundamente anidadas.

Aquí es donde entra DeepDiff.

DeepDiff es una biblioteca de Python increíblemente potente que ofrece mucho más que una simple comparación. Es una herramienta esencial para pruebas, validación de datos y depuración de APIs.

Características principales¶

DeepDiff no es solo una herramienta, es un conjunto de utilidades:

DeepDiff: Compara diccionarios, iterables, cadenas y otros objetos recursivamente. Puede ignorar el orden en listas, ignorar tipos específicos, o excluir rutas de la comparación.
DeepSearch: Busca objetos dentro de otros objetos, como un grep para estructuras de datos en memoria.
DeepHash: Calcula hashes de objetos basándose en su contenido. Muy útil para deduplicación de datos complejos donde el orden de las claves no importa.
Delta: Genera "deltas" (diferencias) que se pueden aplicar a otros objetos, similar a un git patch pero para objetos Python.

Instalación¶

La forma moderna y recomendada de instalar herramientas en Python es usando uv.

Como herramienta de línea de comandos (CLI)¶

Si solo quieres usar el comando deep en tu terminal para comparar archivos JSON o YAML:```bash uv tool install "deepdiff[cli]"

Esto instalará el comando `deep` en tu sistema de forma aislada. Asegúrate de incluir `[cli]` para instalar las dependencias necesarias.

### Como biblioteca en tu proyecto

Si vas a usarlo dentro de tus scripts de Python:

```bash
uv add "deepdiff"

O si necesitas la CLI también dentro de tu entorno virtual:

uv add "deepdiff[cli]"

Ejemplos de uso¶

En Python¶

Imagina que tienes dos respuestas de API ligeramente diferentes y quieres saber qué cambió:

from deepdiff import DeepDiff

t1 = {
    "id": 1,
    "name": "Producto A",
    "tags": ["nuevo", "oferta"],
    "details": {"price": 100, "stock": 50}
}

t2 = {
    "id": 1,
    "name": "Producto A",
    "tags": ["oferta", "nuevo"],  # Orden diferente
    "details": {"price": 120, "stock": 50}
}

# Por defecto, el orden importa en listas
diff = DeepDiff(t1, t2)
# Resultado muestra cambios en la lista 'tags' y en 'details.price'

# Si ignoramos el orden en iterables
diff_ignore_order = DeepDiff(t1, t2, ignore_order=True)
print(diff_ignore_order)

Salida:

{
    'values_changed': {
        "root['details']['price']": {
            'new_value': 120,
            'old_value': 100
        }
    }
}

Como ves, detectó el cambio de precio pero ignoró el cambio de orden en los tags.

En la terminal (CLI)¶

El comando deep es muy útil para comparar archivos rápidamente:

# Comparar dos archivos JSON
deep diff production.json development.json

También puedes usarlo para extraer información o buscar dentro de archivos JSON/YAML grandes sin tener que escribir un script.

Conclusión¶

DeepDiff es una de esas librerías que, una vez que conoces, no puedes dejar de usar. Su flexibilidad para ignorar ciertos campos (como timestamps o IDs autogenerados) la hace perfecta para tests de integración y validación de datos.

Puedes ver la documentación completa en zepworks.com/deepdiff.

Renderizando Markdown en la terminal con Glow

2026-02-20T00:00:00+01:00

Glow es un renderizador de Markdown para la línea de comandos. Permite leer archivos Markdown locales o remotos, y renderizarlos con resaltado de sintaxis y estilos, directamente en tu terminal.

Esta herramienta me resulta especialmente útil ahora que paso más tiempo usando la terminal con Kitty, ya que me permite consultar documentación y READMEs sin tener que abrir un navegador o un editor gráfico.

Instalación¶

Para instalar Glow, utilizaremos gah, una herramienta que facilita la instalación de binarios desde GitHub Releases.```bash gah install charmbracelet/glow

El proceso de instalación es muy sencillo:

```text
$ gah install charmbracelet/glow
Fetching release info for: charmbracelet/glow [latest]
Found release: v2.1.1
Downloading: glow_2.1.1_Linux_x86_64.tar.gz
############################################################################################################################################################################### 100.0%
GitHub Release did not provide digest for glow_2.1.1_Linux_x86_64.tar.gz. Skipping verification.
Extracting: glow_2.1.1_Linux_x86_64.tar.gz
Installing: glow
Give a new name or keep 'glow'? (Leave empty to keep the same)
New name: 
Installed: glow
Done!

Una vez instalado, simplemente ejecuta glow seguido del archivo que quieras visualizar, o incluso la URL de un README en GitHub.

Shot-scraper: Capturas de pantalla automatizadas para la web

2026-02-20T00:00:00+01:00

¿Alguna vez has necesitado tomar capturas de pantalla de una página web de forma programática? Tal vez para documentar tu proyecto, monitorizar cambios en una UI, o generar imágenes para redes sociales. Existen muchas formas de hacerlo, pero shot-scraper destaca por su facilidad de uso y potencia.

Creada por Simon Willison, shot-scraper es una herramienta de línea de comandos (CLI) que envuelve Playwright para hacer que tomar screenshots sea trivial.

Instalación¶

Al igual que con otras herramientas modernas de Python, la mejor forma de instalarla es usando uv:```bash uv tool install shot-scraper

Una vez instalada, necesitarás descargar el navegador que utiliza por debajo (Chromium):

```bash
shot-scraper install

Uso básico¶

La forma más sencilla de usarlo es darle una URL y un nombre de archivo:

shot-scraper https://pablocaro.es/ blog.png

Esto generará una imagen llamada blog.png con la captura de la página.

Capturando selectores específicos¶

Una de las características más potentes es la capacidad de capturar solo un elemento específico de la página usando selectores CSS:

shot-scraper https://github.com/pcaro -s ".js-calendar-graph" calendar.png

Este comando capturará únicamente el gráfico de contribuciones de GitHub.

Interactuando con JavaScript¶

A veces necesitas ejecutar algo de código antes de tomar la foto. Por ejemplo, para ocultar un banner de cookies o esperar a que cargue algo.

shot-scraper https://pablocaro.es/ \
  --javascript "document.querySelector('header').style.display = 'none';" \
  -o sin-header.png

Automatización avanzada¶

Si necesitas tomar muchas capturas, puedes definir un archivo YAML de configuración:

# shots.yml
- url: https://pablocaro.es/
  output: home.png
  height: 800
- url: https://pablocaro.es/archives.html
  output: archives.png
  wait: 1000  # Esperar 1 segundo

Y ejecutarlas todas de una vez:

shot-scraper multi shots.yml

Más allá de las capturas¶

shot-scraper también incluye utilidades para:

Accesibilidad: Volcar el árbol de accesibilidad de una página (shot-scraper accessibility).
PDF: Generar PDFs de páginas web (shot-scraper pdf).
HAR: Grabar archivos HAR para analizar el tráfico de red (shot-scraper har).

Es una de esas herramientas que, una vez instaladas, encuentras usos para ella constantemente. Perfecta para integrar en pipelines de CI/CD para generar visuales de documentación automáticamente.

Más info en la documentación oficial.

Stern: Logs de Kubernetes con esteroides

2026-02-20T00:00:00+01:00

Si trabajas con Kubernetes, probablemente hayas sufrido el comando kubectl logs. Es útil para ver los logs de un pod específico, pero se queda corto cuando tienes múltiples réplicas de un servicio o cuando los pods se reinician y cambian de nombre.

Aquí es donde entra Stern.

Stern te permite hacer "tail" (seguir) logs de múltiples pods y contenedores dentro de Kubernetes simultáneamente. Lo mejor de todo es que utiliza expresiones regulares para seleccionar los pods, por lo que no necesitas copiar y pegar esos IDs aleatorios (pod-1234567890-abcde).

Instalación¶

Stern es muy popular y está disponible en la mayoría de gestores de paquetes.### Usando Krew (recomendado) Si ya usas kubectl, Krew es la forma más natural de instalar plugins:

kubectl krew install stern

Usando Homebrew¶

brew install stern

Binario directo¶

También puedes descargar el binario directamente desde sus releases en GitHub.

Si utilizas algún helper como gah (GitHub Asset Helper) o scripts personalizados, la instalación es tan sencilla como:

gah install stern/stern

Características principales¶

1. Tailing de múltiples pods¶

En lugar de buscar el nombre exacto del pod, puedes usar una regex:

stern backend

Esto mostrará los logs de todos los pods que contengan "backend" en su nombre (backend-api, backend-worker, etc.), intercalados y coloreados para distinguirlos fácilmente.

2. Filtrado y exclusión¶

Puedes filtrar el contenido de los logs sobre la marcha sin necesidad de grep:

# Solo mostrar líneas que contengan "Error"
stern backend -i Error

# Excluir líneas que contengan "Health check"
stern backend -e "Health check"

3. Selectores de Kubernetes¶

Además de regex por nombre, puedes usar selectores de etiquetas, lo cual es mucho más preciso para entornos de producción:

stern -l app=mi-app -l tier=frontend

4. Formato de salida¶

Si tus logs están en JSON (como es buena práctica), Stern puede pasarlos tal cual para que los proceses con herramientas como jq o fx:

stern backend -o raw | fx

Conclusión¶

Stern es una de esas herramientas que instalas el primer día y te preguntas cómo podías vivir sin ella. Hace que el debug en entornos distribuidos sea mucho menos doloroso al agregar la información de manera coherente.

Dale una oportunidad y tus sesiones de debugging te lo agradecerán.

Gestionando instalaciones desde GitHub con gah

2026-02-11T20:23:00+01:00

gah es una herramienta que facilita la instalación de programas que distribuyen sus binarios a través de releases de GitHub. Es una alternativa ligera cuando no quieres depender del gestor de paquetes de tu distribución o cuando necesitas una versión más reciente.

Instalación

Para instalar gah, puedes usar el siguiente script oficial:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/get-gah/gah/refs/heads/master/tools/install.sh)"

Uso

Una vez instalado, usarlo es muy directo. Aquí tienes un par de ejemplos que he usado recientemente para instalar herramientas populares escritas en Rust:

Para instalar fd (una alternativa rápida a find):

gah install sharkdp/fd

Para instalar ripgrep (una alternativa rápida a grep):

gah install BurntSushi/ripgrep

Gah se encarga de descargar el asset correcto para tu arquitectura, descomprimirlo y colocarlo en tu path.

broot, una forma diferente de navegar por tus directorios

2026-01-02T10:00:00+01:00

Llevaba tiempo buscando un reemplazo para ls y tree que me permitiera navegar por directorios grandes sin perder el contexto. broot es la herramienta que necesitaba.

Instalación¶

# Con cargo (Rust)
cargo install broot

# O con tu gestor de paquetes
brew install broot  # macOS
apt install broot   # Debian/Ubuntu

Primeros pasos¶

El comando básico es simplemente br (puedes crear un alias para que reemplace a cd):

br

Esto abre una vista de árbol interactiva del directorio actual. Las teclas principales:

↓ / ↑ - Navegar entre archivos y directorios
/ - Búsqueda fuzzy (ej: /config encuentra todos los archivos con "config" en el nombre)
Enter - Entrar en un directorio
alt + Enter - Hacer cd al directorio seleccionado y salir de broot
:e - Abrir el archivo seleccionado con el editor definido en $EDITOR
:q - Salir

Características que uso¶

Búsqueda sin perder el contexto¶

A diferencia de find, broot muestra dónde está cada resultado dentro del árbol de directorios:

br
/pytest  # Encuentra todos los archivos/directorios con "pytest"

Esto es útil cuando sabes el nombre de un archivo pero no recuerdas en qué carpeta está.

Paneles múltiples¶

Puedes dividir la vista para comparar o mover archivos entre directorios:

:pp  # Crear panel derecho
:pc  # Crear panel inferior
:pt  # Intercambiar paneles

En cada panel puedes navegar independientemente y usar verbos como :copy o :move.

Previsualización de archivos¶

Selecciona un archivo y usa :preview para ver su contenido sin salir de broot. Para imágenes en terminales que lo soporten (kitty, iterm2):

:preview

Ver solo archivos relevantes¶

broot oculta automáticamente archivos ignorados por Git y directorios comunes como node_modules. Para verlos:

:show_git_ignored

Verbos personalizados¶

En ~/.config/broot/conf.toml puedes añadir comandos personalizados:

[[verbs]]
name = "edit"
invocation = "e"
execution = "$EDITOR {file}"

[[verbs]]
name = "git status"
invocation = "gs"
execution = "git status"

Integración con el shell¶

Para usar br como reemplazo de cd, añade esto a tu .bashrc o .zshrc:

# Esto permite que br cambie el directorio del shell padre
source /usr/share/broot/launcher/bash/br

Ahora br directorio te deja en ese directorio al salir.

Cuándo usar broot¶

Navegar por proyectos grandes con muchas carpetas
Buscar archivos cuando no recuerdas la ruta exacta
Mover/copiar archivos entre directorios distantes
Explorar directorios con muchos archivos ignorados por Git

Enlaces¶

Fuente original: Documentación de broot

YAML Multilínea: Entendiendo y probando cadenas de texto complejas

2025-12-25T16:10:00+01:00

YAML se ha convertido en el formato de facto para la configuración en muchos proyectos, desde Kubernetes hasta scripts de CI/CD. Una de sus funcionalidades más potentes, y a veces confusas, es la gestión de cadenas de texto multilínea. Afortunadamente, existe una herramienta interactiva excepcional para dominar este aspecto: yaml-multiline.info.

Formatos para Cadenas Multilínea en YAML¶

YAML ofrece principalmente dos enfoques para definir cadenas que abarcan varias líneas:

Escalares de Flujo (Flow Scalars):
- Son cadenas simples, a menudo entrecomilladas ('...' o "...") o sin comillas.
- Ignoran indentaciones y, por defecto, reemplazan los saltos de línea con espacios.
- Las cadenas con comillas dobles permiten usar secuencias de escape como \n.
Escalares de Bloque (Block Scalars):
- Ofrecen un control mucho más preciso sobre los saltos de línea y la indentación.
- Se indican con un carácter especial al inicio de la línea donde comienza la cadena.

Claves para Cadenas Multilínea en Bloque¶

Los dos indicadores de estilo más importantes para escalares de bloque son:

| (Estilo Literal): Mantiene todos los saltos de línea y la indentación tal cual. Es ideal para bloques de texto donde el formato es crucial (ej. código, mensajes largos). yaml literal_string: | Esta es una línea. Esta es otra. Con su propia indentación. Resultado: "Esta es una línea.\nEsta es otra.\n Con su propia indentación.\n"
> (Estilo Plegado/Folded): Reemplaza los saltos de línea con espacios, uniendo las líneas en una sola. Solo los saltos de línea dobles (líneas en blanco) o las líneas con mayor indentación se conservan como saltos de línea. Es útil para párrafos largos. yaml folded_string: > Esta es una cadena plegada en varias líneas. Mantendrá el formato de párrafo. Resultado: "Esta es una cadena plegada en varias líneas. Mantendrá el formato de párrafo.\n"

Además de esto, existen indicadores de "chomping" (- para eliminar saltos de línea finales, + para mantenerlos, o el comportamiento por defecto) y de indentación que ofrecen aún más control.

¡Demo en Tiempo Real!¶

Lo que hace a yaml-multiline.info una herramienta invaluable es su demo interactiva. Puedes probar diferentes sintaxis YAML en tiempo real y ver cómo se interpreta la cadena resultante. Es la mejor manera de entender visualmente cómo funcionan los estilos literal y plegado, y cómo los indicadores de chomping y la indentación afectan el resultado final.

Conclusión¶

Entender cómo manejar cadenas multilínea en YAML no solo mejora la legibilidad de tus archivos de configuración, sino que también previene errores inesperados. La demo en tiempo real de yaml-multiline.info es un recurso fantástico para cualquier persona que trabaje regularmente con YAML y quiera dominar este aspecto.

Sitio web: yaml-multiline.info

Pandas Styler: Mejora la presentación de tus DataFrames

2025-12-25T15:55:00+01:00

Cuando trabajamos con datos en Python, los DataFrames de Pandas son nuestra herramienta principal. Sin embargo, su presentación por defecto en consolas o notebooks puede ser muy básica. Aquí es donde el objeto Styler de Pandas se convierte en un aliado fundamental para transformar DataFrames simples en tablas visualmente atractivas e informativas.

¿Qué es Pandas `Styler`?¶

El objeto Styler te permite aplicar formato condicional y estilos CSS directamente a tus DataFrames de Pandas. Con él, puedes resaltar patrones, enfatizar valores importantes y mejorar la legibilidad sin necesidad de exportar los datos a otra herramienta.

Funcionalidades Clave¶

Formato Condicional: Resalta celdas, filas o columnas basándose en condiciones definidas por ti (e.g., valores por encima de un umbral, duplicados, etc.).
Estilos CSS: Aplica estilos CSS como colores de fondo, fuentes, bordes o alineaciones para personalizar la apariencia.
Estilos Predefinidos: Incluye métodos como background_gradient() para aplicar gradientes de color que visualicen la distribución de valores.
Integración con Excel: Mantiene los estilos al exportar DataFrames a archivos Excel, facilitando reportes profesionales.

Conclusión¶

El objeto Styler de Pandas es una herramienta sencilla pero potente para llevar la presentación de tus datos al siguiente nivel. Con unas pocas líneas de código, puedes hacer que tus DataFrames no solo sean una fuente de datos, sino también una herramienta de comunicación efectiva.

Artículo original: Stylin' with Pandas | Practical Business Python

`fresh`: Mi editor de terminal preferido para el día a día

2025-12-25T15:45:00+01:00

Aunque vim es una herramienta increíblemente potente y nano destaca por su simplicidad extrema, a menudo busco un punto intermedio para la edición de archivos en la terminal. Un editor que sea rápido, moderno y que no me obligue a recordar modos o combinaciones de teclas complejas para tareas sencillas. Así es como he descubierto fresh, y se ha convertido rápidamente en mi editor de terminal preferido para el uso diario.

¿Qué es `fresh`?¶

fresh es un editor de texto para terminal diseñado para ser simple, rápido y eficiente. A diferencia de vim, fresh es un editor sin modos, lo que significa que puedes empezar a escribir y editar texto inmediatamente, como lo harías en un editor gráfico. A diferencia de nano, fresh ofrece una experiencia más moderna con características que esperas de un editor de texto actual.

¿Por qué lo prefiero a `nano` o `vim` para mi uso habitual?¶

Sin Modos: La principal ventaja sobre vim. No necesitas aprender a cambiar entre modos de inserción, normal, visual, etc. Simplemente abres el archivo y editas.
Moderno y Rápido: A pesar de ejecutarse en la terminal, fresh se siente responsivo y ofrece una interfaz limpia.
Resaltado de Sintaxis: Soporte para coloreado de sintaxis para una gran variedad de lenguajes.
Soporte de Ratón: Puedes hacer clic para mover el cursor, seleccionar texto, o incluso usar la rueda para scroll.
Multi-Cursor: Una característica muy potente que nano no ofrece y que vim requiere más complejidad para usar.
Deshacer/Rehacer: Funcionalidad completa de undo/redo.
Búsqueda y Reemplazo: Funciones de búsqueda y reemplazo sencillas e intuitivas.

Mientras que vim sigue siendo mi elección para ediciones complejas o scripting avanzado, para "abrir un .conf", modificar un .bashrc, o escribir una pequeña nota, fresh es imbatible en velocidad y comodidad. nano es quizás demasiado básico para mis necesidades, careciendo de la mayoría de las características modernas que fresh ofrece.

Instalación¶

fresh es fácil de instalar en la mayoría de las distribuciones Linux. Por ejemplo, en sistemas basados en Debian/Ubuntu:

sudo apt install fresh

O puedes seguir las instrucciones del repositorio oficial para compilarlo desde el código fuente o usar otros gestores de paquetes.

Conclusión¶

Si buscas un editor de terminal que sea un híbrido perfecto entre la potencia de vim y la simplicidad de nano, pero con un toque moderno y centrado en la usabilidad inmediata, fresh es una excelente opción. Dale una oportunidad, ¡podría convertirse en tu nuevo favorito!

Repositorio oficial: fresh en GitHub

Cómo ver los archivos de un paquete RPM en Linux

2025-12-25T15:15:00+01:00

En sistemas Linux basados en RPM (como Red Hat, CentOS, Fedora, openSUSE), es común interactuar con paquetes en formato .rpm. A menudo, necesitamos saber qué archivos contiene un paquete antes de instalarlo, o qué paquete es el responsable de un archivo específico ya instalado en el sistema. Para ello, la herramienta rpm nos ofrece varias opciones útiles.

1. Listar Archivos de un Paquete RPM sin Instalar¶

Si tienes un archivo .rpm descargado y quieres ver qué archivos instalará (y dónde) sin necesidad de instalarlo, puedes usar la opción -qlp:

rpm -qlp nombre_del_paquete.rpm

-q: Modo de consulta (query).
-l: Lista los archivos (list files).
-p: Consulta un paquete (package file) en lugar de uno instalado.

Ejemplo:

rpm -qlp nginx-1.20.1-1.el8.x86_64.rpm

2. Encontrar el Paquete Dueño de un Archivo Instalado¶

Si encuentras un archivo en tu sistema y quieres saber a qué paquete RPM pertenece (útil para depuración o para saber si puedes borrarlo de forma segura), usa la opción -qf:

rpm -qf /ruta/al/archivo

Ejemplo:

rpm -qf /etc/nginx/nginx.conf
# Salida esperada: nginx-1.20.1-1.el8.x86_64

3. Obtener Información Detallada de un Paquete¶

Para ver información completa sobre un paquete (versión, descripción, dependencias, etc.), ya sea instalado o un archivo .rpm, puedes usar -qi (para paquetes instalados) o -qip (para archivos de paquete):

rpm -qi nombre_del_paquete_instalado
# Ejemplo: rpm -qi nginx

rpm -qip nombre_del_paquete.rpm
# Ejemplo: rpm -qip nginx-1.20.1-1.el8.x86_64.rpm

Conclusión¶

Dominar estas sencillas opciones del comando rpm te proporciona un control mucho mayor sobre los paquetes y archivos de tu sistema Linux, facilitando la administración y la depuración. Son herramientas esenciales para cualquier administrador de sistemas o desarrollador que trabaje con distribuciones basadas en RPM.

Artículo original: Cómo Ver los Archivos de un Paquete RPM o Deb

Kooha: Captura de pantalla sencilla y elegante en Linux

2025-12-25T15:00:00+01:00

En Linux, la necesidad de grabar la pantalla de forma sencilla y eficiente es común, ya sea para crear tutoriales, presentaciones, reportes de bugs o simplemente compartir una experiencia. Aunque existen muchas herramientas, Kooha destaca por su enfoque minimalista y su interfaz de usuario intuitiva, basada en GTK.

¿Qué es Kooha?¶

Kooha es una aplicación de grabación de pantalla gratuita y de código abierto, diseñada específicamente para entornos de escritorio Linux. Su objetivo principal es ofrecer una experiencia de usuario sin complicaciones, enfocándose en las funcionalidades esenciales de una grabadora de pantalla.

¿Por qué elegir Kooha?¶

Facilidad de Uso: Su interfaz es clara y directa. No hay menús complejos ni opciones abrumadoras, lo que la hace ideal para usuarios de todos los niveles.
Diseño Minimalista: Se integra perfectamente con el aspecto de GNOME y otros entornos GTK, ofreciendo una experiencia visual limpia y agradable.
Funcionalidades Clave: A pesar de su simplicidad, incluye todas las opciones necesarias para la mayoría de las tareas de grabación.
Código Abierto: Al ser open-source, se beneficia de la comunidad y permite a los usuarios inspeccionar y contribuir al código.

Características Principales¶

Grabación de Pantalla Completa: Captura todo lo que ocurre en tu monitor.
Grabación de Ventana Específica: Elige una aplicación o ventana en particular para grabar.
Grabación de Área Seleccionada: Define un área rectangular en tu pantalla para la captura.
Grabación de Audio: Incluye audio desde tu micrófono.
Grabación de Webcam: Integra la imagen de tu cámara web en la grabación.
Formatos Comunes: Soporte para formatos populares como WebM y MP4.
Opciones de Calidad: Ajustes para la tasa de fotogramas (FPS) y la calidad del video.

Instalación¶

La forma más recomendada de instalar Kooha es a través de Flatpak, lo que asegura que obtendrás la última versión y todas las dependencias necesarias:

flatpak install flathub com.github.SeaDve.Kooha

También puede estar disponible en los repositorios de algunas distribuciones Linux o como paquete Snap.

Conclusión¶

Kooha es la herramienta perfecta para quienes buscan una solución de grabación de pantalla en Linux que sea potente sin ser complicada. Su elegancia y sencillez la convierten en una excelente adición al arsenal de productividad de cualquier usuario de Linux.

Repositorio oficial: SeaDve/Kooha en GitHub

OpenEvidence: La plataforma líder en información médica para profesionales

2025-12-25T14:45:00+01:00

En el ámbito de la salud, el acceso rápido y fiable a la información médica más reciente y relevante es crucial para la toma de decisiones clínicas. OpenEvidence se posiciona como una plataforma líder diseñada para consolidar y presentar esta información de forma accesible a los profesionales sanitarios.

¿Qué Ofrece OpenEvidence?¶

OpenEvidence actúa como un centro neurálgico para la información médica, firmando acuerdos de contenido con algunas de las publicaciones y organizaciones más prestigiosas del sector. Entre sus colaboradores se incluyen:

The New England Journal of Medicine (NEJM)
JAMA Network
National Comprehensive Cancer Network (NCCN), incluyendo sus guías y vías clínicas.
Mayo Clinic Platform

Esto asegura que los profesionales tengan a su alcance una fuente autorizada y actualizada de conocimientos.

Funcionalidades Clave para Profesionales¶

La plataforma está diseñada para satisfacer las necesidades específicas de los profesionales de la salud, ofreciendo:

Evidencia Primaria: Acceso directo a los hallazgos clínicos y la investigación original.
Documentos para Pacientes: Herramientas para crear folletos informativos para pacientes, facilitando la comunicación.
Exploración de Capacidades: Un sistema intuitivo para navegar por una vasta biblioteca de recursos.
Guías Clínicas y Vías: Acceso a las últimas recomendaciones para el tratamiento y manejo de diversas condiciones.

¿Para Quién es?¶

OpenEvidence está dirigido principalmente a profesionales de la salud verificados en EE.UU. y se ofrece de forma gratuita para este grupo. Está disponible a través de aplicaciones para iOS y Android, lo que permite un acceso cómodo y móvil a la información.

Conclusión¶

OpenEvidence representa un avance significativo en la democratización del acceso a la información médica de alta calidad. Al consolidar recursos de diversas fuentes autorizadas y ofrecerlos en una plataforma fácil de usar, permite a los profesionales sanitarios tomar decisiones más informadas y, en última instancia, mejorar la atención al paciente.

Página oficial: OpenEvidence

`direnv`: Gestiona tus entornos de desarrollo de forma inteligente

2025-12-25T14:30:00+01:00

En el día a día de un desarrollador, es común trabajar con múltiples proyectos, cada uno con sus propias variables de entorno, rutas (PATH), versiones de herramientas o credenciales. La gestión manual de estas variables puede llevar a configuraciones desordenadas en tu .profile o .bashrc, o a errores por usar el entorno incorrecto. Aquí es donde direnv brilla, ofreciendo una solución elegante y automática.

¿Qué es `direnv`?¶

direnv es una extensión para tu shell (Bash, Zsh, Fish, etc.) que detecta automáticamente cuando cambias de directorio. Cuando entras en un directorio que contiene un archivo .envrc, direnv lo carga; cuando sales de él, lo descarga. Esto significa que tu entorno de shell se adapta dinámicamente a tu proyecto actual, sin que tengas que hacer nada manualmente.

¿Cómo funciona?¶

direnv se integra con tu shell a través de un hook en el comando cd. Cada vez que cambias de directorio, direnv comprueba si existe un archivo .envrc en el directorio actual o en alguno de sus ancestros. Si encuentra uno (y le has dado permiso para cargarlo), ejecuta los comandos definidos en ese archivo para modificar tu entorno. Al salir del directorio, revierte esos cambios, limpiando tu entorno.

Casos de Uso Comunes¶

Gestión de PATH: Añadir binarios específicos de un proyecto a tu PATH temporalmente.
Entornos Virtuales de Python: Activar automáticamente un virtualenv o uv venv al entrar en un proyecto Python.
Credenciales y Claves API: Cargar variables de entorno con credenciales de bases de datos, claves API o tokens de forma segura (sin que queden en el historial del shell).
Variables de Entorno Específicas del Proyecto: RAILS_ENV, NODE_ENV, etc.
Cambio de Versiones de Herramientas: Integrar con herramientas como nvm o pyenv para cambiar automáticamente de versión de Node.js o Python.

Instalación Básica (ejemplo para Bash)¶

Instalar direnv: Puedes instalarlo desde tu gestor de paquetes (sudo apt install direnv, brew install direnv, etc.).
Activar el hook en tu shell: Añade la siguiente línea a tu ~/.bashrc (o ~/.zshrc):

bash eval "$(direnv hook bash)"
Crear un archivo .envrc: En la raíz de tu proyecto, crea un archivo .envrc con las variables y comandos que quieras.

```bash

.envrc en la raíz de tu proyecto Python¶

layout python # Activa automáticamente un entorno virtual export MY_API_KEY="super_secreto_del_proyecto" ```
Permitir la carga: La primera vez que entres al directorio con un nuevo .envrc, direnv te pedirá confirmación:

bash direnv: error .envrc is blocked. Run `direnv allow` to approve its contents Ejecuta direnv allow.

La Librería Estándar de `direnv`¶

direnv viene con una potente librería estándar que incluye funciones predefinidas para tareas comunes, como layout python (para gestionar virtualenvs), use nix, use node, etc., simplificando enormemente la configuración de tus .envrc.

Beneficios Clave¶

Entornos limpios: Tu .profile permanece ordenado.
Consistencia: Cada proyecto tiene exactamente el entorno que necesita.
Productividad: No más source venv/bin/activate manual o recordar configurar variables.

direnv es una herramienta pequeña pero poderosa que transforma la forma en que gestionas tus entornos de desarrollo, haciendo tu vida en la terminal mucho más eficiente y libre de errores.

Artículo original: direnv homepage

`docker-http-https-echo`: Una herramienta esencial para depuración de red

2025-12-25T14:15:00+01:00

En el complejo mundo de las aplicaciones distribuidas, la depuración de problemas de red, proxies, balanceadores de carga o reglas de firewall puede ser una tarea ardua. Necesitamos una forma simple de verificar qué está recibiendo un servidor. Aquí es donde una herramienta como mendhak/docker-http-https-echo se vuelve indispensable.

¿Qué es `mendhak/docker-http-https-echo`?¶

Es un contenedor Docker extremadamente ligero y simple que funciona como un servidor HTTP y HTTPS de "eco". Su función principal es responder a cualquier solicitud HTTP o HTTPS con una descripción detallada de la propia solicitud. Esto incluye:

Cabeceras de la solicitud (headers).
Método HTTP (GET, POST, PUT, etc.).
URL y parámetros de la solicitud.
Cuerpo de la solicitud (body).
Dirección IP remota del cliente.
Información del TLS/SSL (si es HTTPS).

¿Por qué es útil?¶

Este tipo de servidor de eco es invaluable para una variedad de escenarios de depuración:

Depuración de Proxies y Balanceadores de Carga: Verifica si un proxy inverso o un balanceador de carga está reescribiendo cabeceras, modificando URLs o pasando el cuerpo de la solicitud como esperas.
Reglas de Firewall y Seguridad: Confirma que el tráfico está llegando al destino correcto y que no está siendo bloqueado o alterado.
Inspección de Cabeceras HTTP/HTTPS: Útil para ver exactamente qué cabeceras envía tu cliente o una aplicación específica.
Pruebas de Integración: Un objetivo predecible para pruebas automáticas de cómo diferentes servicios se comunican a través de HTTP/HTTPS.
Diagnóstico de Contenido Mixto: Puedes usarlo para verificar si los recursos HTTP se están cargando correctamente en un contexto HTTPS.

Cómo Usarlo¶

Su uso es directo a través de Docker:

Para HTTP (puerto 8080)¶

docker run -p 8080:8080 mendhak/http-https-echo

Luego, puedes acceder a http://localhost:8080 con tu navegador o curl:

curl http://localhost:8080/path?query=value -H "X-Custom-Header: test"

Para HTTPS (puerto 8443)¶

Para usar HTTPS, debes mapear el puerto HTTPS del contenedor. La imagen ya viene con un certificado autofirmado para pruebas.

docker run -p 8443:8443 mendhak/http-https-echo

Accede a https://localhost:8443 (es posible que tu navegador te advierta sobre el certificado autofirmado).

Conclusión¶

mendhak/docker-http-https-echo es una de esas herramientas simples pero increíblemente útiles que todo desarrollador y operador de sistemas debería tener a mano. Facilita la comprensión de los flujos de red y acelera la depuración de problemas de conectividad en cualquier entorno basado en contenedores.

Repositorio original: mendhak/docker-http-https-echo en GitHub

Kubegres: Gestión simplificada de PostgreSQL en Kubernetes

2025-12-25T14:00:00+01:00

Desplegar y gestionar bases de datos relacionales en Kubernetes puede ser un desafío. Aunque los contenedores y la orquestación ofrecen flexibilidad, la persistencia de datos, la alta disponibilidad y las copias de seguridad de una base de datos como PostgreSQL requieren una consideración cuidadosa. Aquí es donde Kubegres entra en juego.

¿Qué es Kubegres?¶

Kubegres es un operador de Kubernetes que permite implementar y gestionar clusters PostgreSQL en Kubernetes de forma sencilla y eficiente. Un operador es una aplicación que extiende las funcionalidades de Kubernetes, automatizando tareas operacionales complejas que normalmente requieren intervención manual.

¿Por qué usar Kubegres?¶

Kubegres abstrae gran parte de la complejidad de ejecutar PostgreSQL en un entorno orquestado, ofreciendo funcionalidades clave como:

Alta Disponibilidad (HA): Configuración automática de replicas de PostgreSQL para garantizar la continuidad del servicio ante fallos.
Replicación: Soporte para replicación de streaming (Primary/Standby) para redundancia y escalabilidad de lectura.
Backups y Restauración: Facilita la configuración de políticas de backup y la recuperación de datos.
Escalabilidad: Permite escalar las réplicas de lectura de PostgreSQL para manejar cargas de trabajo crecientes.
Actualizaciones sencillas: Gestiona las actualizaciones de versiones de PostgreSQL dentro del clúster.
Supervisión: Integra mecanismos para monitorizar el estado del clúster.

¿Cómo funciona?¶

Kubegres utiliza los Custom Resources (CRs) de Kubernetes. Esto significa que interactúas con tu clúster PostgreSQL utilizando objetos estándar de Kubernetes (YAML). Defines el estado deseado de tu clúster (número de réplicas, versión de PostgreSQL, políticas de backup) en un archivo YAML, y Kubegres se encarga de que ese estado se mantenga en todo momento.

apiVersion: kubegres.reactive-tech.io/v1
kind: Kubegres
metadata:
  name: my-postgres
spec:
  replicas: 3
  image: postgres:13.2
  database:
    size: 10Gi
  # ... otras configuraciones para backups, etc.

Beneficios para desarrolladores y operaciones¶

Simplificación: Reduce drásticamente la complejidad de operar PostgreSQL en Kubernetes.
Automatización: Tareas como el failover, la replicación y los backups se gestionan automáticamente.
Consistencia: Asegura que el estado de tu base de datos siempre refleje tu configuración deseada.
DevOps Friendly: Permite integrar la gestión de bases de datos en tus pipelines de CI/CD utilizando las mismas herramientas y flujos de trabajo que para el resto de tus aplicaciones en K8s.

Kubegres es una excelente opción para equipos que buscan una solución robusta y automatizada para sus necesidades de PostgreSQL en Kubernetes.

Artículo original: Kubegres - The Kubernetes PostgreSQL operator

Estados de Conexión TCP en GNU/Linux: netstat y ss

2025-12-25T13:30:00+01:00

En el mundo de GNU/Linux, herramientas como netstat y ss son indispensables para monitorizar y diagnosticar el estado de las conexiones de red en nuestros sistemas. Para interpretar correctamente su salida, es fundamental entender los diferentes estados por los que atraviesa una conexión TCP. Esta entrada explora esos estados, desde el establecimiento hasta la terminación de una conexión.

Fases de una Conexión TCP¶

Una conexión TCP se gestiona a través de tres fases principales:

Establecimiento de la Conexión: Un proceso de reconocimiento (handshake) de varios pasos que inicia la conexión.
Transferencia de Datos: Una vez establecida, los datos se envían entre los dos puntos finales.
Terminación de la Conexión: Cierra la conexión y libera los recursos asociados.

Durante estas fases, el socket de Internet (el punto final local de la comunicación) experimenta una serie de cambios de estado.

Estados del Socket TCP Explicados¶

Aquí se detallan los estados más comunes que puedes encontrar al listar conexiones con netstat o ss:

ESTABLISHED: La conexión TCP está establecida y lista para transferir datos. Este es el estado deseado para una conexión activa.
SYN_SENT: El socket local ha enviado un paquete SYN al servidor remoto y está esperando una respuesta SYN-ACK. Indica que se está intentando establecer una conexión.
SYN_RECV: El servidor ha recibido un paquete SYN de un cliente y ha respondido con un SYN-ACK, esperando ahora un ACK del cliente. Es parte del handshake de tres vías.
FIN_WAIT1: El socket local ha cerrado su lado de la conexión y ha enviado un paquete FIN, esperando un ACK del par remoto. La conexión se está cerrando activamente.
FIN_WAIT2: El socket local ha recibido el ACK a su FIN, pero aún está esperando un paquete FIN del par remoto para cerrar completamente la conexión.
TIME_WAIT: El socket ha esperado después de cerrar la conexión para asegurarse de que todos los paquetes han sido transmitidos y recibidos por ambos lados, y para permitir que los paquetes duplicados se extingan en la red. Es un estado de espera necesario antes de liberar completamente los recursos.
CLOSE: El socket no está en uso y no hay conexión.
CLOSE_WAIT: El par remoto ha cerrado su lado de la conexión (ha enviado un FIN y ha sido ACKed), y el socket local está esperando que la aplicación local cierre su propio lado.
LAST_ACK: El socket local ha enviado su FIN al par remoto, y está esperando el ACK final del par remoto. Esto sucede después de un CLOSE_WAIT.
LISTEN: El socket está a la espera de conexiones entrantes. Solo se ve con las opciones --listening (-l) o --all (-a) de netstat/ss.
CLOSING: Ambos lados de la conexión han intentado cerrarse simultáneamente, y el socket local está en el proceso de enviar/recibir FIN y ACK.
UNKNOWN: El estado del socket es desconocido o no se puede determinar.

Herramientas: `netstat` y `ss`¶

Puedes ver estos estados utilizando comandos como:

netstat -tn   # Muestra conexiones TCP, sin resolución de nombres (-n)
ss -tn        # Versión moderna y más rápida de netstat

La opción -t filtra para conexiones TCP y -n evita la resolución de nombres, lo que acelera la salida y muestra las IPs directamente.

Conclusión¶

Entender los estados de conexión TCP es vital para diagnosticar problemas de red, identificar procesos que no responden o que están atascados, y comprender cómo se comportan las aplicaciones en términos de conectividad. Saber qué significa cada estado te permite depurar problemas de forma más efectiva en tu sistema GNU/Linux.

Artículo original: Tipos de Conexiones en netstat y ss Explicadas

Reduce el Ruido en tus Logs de Python: Un enfoque inteligente

2025-12-25T13:00:00+01:00

El módulo logging de Python es una herramienta poderosa, pero puede convertirse rápidamente en una fuente de "ruido" cuando las librerías de terceros inundan tus logs con mensajes que no son relevantes para la depuración de tu aplicación. Mantener los logs limpios es crucial para identificar problemas de forma eficiente y comprender el comportamiento real de tu código.

El Problema con `basicConfig()`¶

Muchos desarrolladores Python comienzan a usar logging con logging.basicConfig(). Si bien es conveniente, esta función configura el "root logger" (logger raíz) de tu aplicación. El problema es que todos los loggers de tu aplicación, incluidas las librerías de terceros, son hijos del logger raíz.

Esto significa que si configuras el logger raíz a nivel DEBUG, empezarás a ver mensajes de depuración de todas las librerías que uses, lo cual puede ser abrumador y ocultar la información verdaderamente importante de tu propio código.

La Solución Recomendada: Configuración Granular¶

Para evitar esta sobrecarga, la estrategia consiste en tomar un control más granular de los niveles de logging.

Nombra tus Loggers: Sigue la buena práctica de crear un logger específico para cada módulo de tu aplicación utilizando logging.getLogger(__name__). Esto crea una jerarquía de loggers que puedes controlar individualmente.

```python

mi_modulo.py¶

import logging logger = logging.getLogger(name)

def mi_funcion(): logger.info("Mi función se está ejecutando.") logger.debug("Mensaje de depuración en mi función.") ```
Configura Niveles en Loggers Específicos de la Aplicación: En lugar de modificar el logger raíz, establece el nivel de logging en el logger de nivel más alto de tu propia aplicación. Esto permite que tus módulos registren mensajes a niveles detallados (por ejemplo, DEBUG), mientras que las librerías de terceros (que seguirán siendo hijos del logger raíz no configurado, o con una configuración por defecto menos verbosa) solo mostrarán mensajes más críticos (por ejemplo, WARNING o ERROR).

```python

main.py (o tu punto de entrada principal)¶

import logging from mi_paquete.mi_modulo import mi_funcion

Crea un logger para tu aplicación principal¶

app_logger = logging.getLogger('mi_paquete') # O el nombre de tu paquete principal app_logger.setLevel(logging.DEBUG)

Crea un handler para la salida (por ejemplo, a consola)¶

handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter)

Añade el handler al logger de tu aplicación¶

app_logger.addHandler(handler)

Ahora, el logger raíz (y sus hijos, las librerías) no se verán afectados directamente¶

Puedes controlar el nivel de librerías específicas si lo necesitas¶

logging.getLogger('requests').setLevel(logging.WARNING) # Ejemplo para una librería

mi_funcion() ```

Consejo Avanzado: Gestión de Dependencias Propias¶

Para proyectos con múltiples módulos internos o dependencias de "primera parte" (que tú mismo desarrollas), puedes envolver getLogger() para que siempre prefije el nombre del logger con el de tu organización o proyecto (por ejemplo, ORG_NAME.mi_modulo). Esto te permite controlar el nivel de logging de todo un conjunto de loggers internos de forma más sencilla.

Conclusión¶

Reducir el ruido en tus logs no solo los hace más legibles, sino también más fiables como herramienta de depuración. Al adoptar un enfoque granular en la configuración de logging de Python, aseguras que la información crítica de tu aplicación no se pierda entre un mar de mensajes de librerías de terceros.

Artículo original: How to Make Your Logs Less Noisy in Python | Sinclair Target

Kitty como terminal de acceso rápido: La comodidad de un desplegable

2025-12-25T12:30:00+01:00

Una de las características más apreciadas de terminales como Yakuake o Guake es su capacidad para aparecer y desaparecer instantáneamente con una sola pulsación de tecla, ofreciendo un acceso rápido sin interrumpir el flujo de trabajo. Kitty, el terminal acelerado por GPU, también puede replicar y mejorar esta experiencia, combinando su potencia con la comodidad de un terminal desplegable.

El Concepto del Terminal Desplegable¶

La idea es simple: un terminal que reside en segundo plano y se muestra u oculta a demanda. Esto es especialmente útil para comandos rápidos, monitoreo o cualquier tarea que requiera una interacción breve con la línea de comandos.

Kitty para Acceso Rápido¶

Kitty no tiene una función de "desplegable" nativa como Yakuake, pero su flexibilidad y capacidades de scripting permiten configurarlo para este propósito. La clave reside en:

Instancias de Kitty dedicadas: Puedes lanzar una instancia de Kitty en un "daemon" o en segundo plano, lista para ser activada.
Control remoto: Kitty ofrece un protocolo de control remoto (kitty @) que permite interactuar con instancias ya abiertas.
Gestor de ventanas: Usar las reglas de tu gestor de ventanas (KDE, Gnome, i3, Sway, etc.) para asignar una tecla de acceso rápido que muestre u oculte la ventana de Kitty.

Configuración de Ejemplo¶

Aquí tienes un enfoque conceptual para lograr un terminal de acceso rápido con Kitty y un gestor de ventanas (por ejemplo, con xdotool para entornos Xorg, o funciones similares en Wayland):

Lanzar Kitty en segundo plano: Puedes tener una instancia de Kitty que se inicie automáticamente con tu sesión y que esté configurada para ser "flotante" y con un tamaño específico.
Script de alternancia (toggle): Crear un pequeño script que compruebe si la ventana de Kitty "siempre visible" está activa y, si lo está, la oculte; si no lo está, la muestre.

```bash

!/bin/bash¶

KITTY_CLASS="kitty-dropdown" # Una clase personalizada para la ventana de Kitty KITTY_ID=$(xdotool search --class "$KITTY_CLASS" | head -n 1)

if [ -z "$KITTY_ID" ]; then # Si no existe, lanzarla kitty --class "$KITTY_CLASS" & else # Si existe, alternar visibilidad if xdotool getwindowfocus getwindowpid | grep -q "$(xdotool getwindowpid "$KITTY_ID")"; then xdotool windowminimize "$KITTY_ID" else xdotool windowmap "$KITTY_ID" # Mostrar la ventana xdotool windowraise "$KITTY_ID" # Asegurarse de que esté al frente xdotool windowfocus "$KITTY_ID" # Darle el foco fi fi ```
Atajo de teclado en tu gestor de ventanas: Asigna una tecla global (por ejemplo, F12) para ejecutar este script.

```

Ejemplo en ~/.config/i3/config o similar¶

bindsym $mod+F12 exec --no-startup-id /path/to/your/toggle-kitty-dropdown.sh ```

Y en tu kitty.conf, puedes configurar la instancia de Kitty para que tenga la clase específica y una posición/tamaño adecuados:

```

kitty.conf (configuración para la instancia dropdown)¶

window_class_members kitty-dropdown initial_window_width 80% initial_window_height 40% window_border_width 0

... otras configuraciones de apariencia ...¶

```

Este método te proporciona la rapidez y comodidad de un terminal desplegable, pero con toda la potencia y personalización que Kitty ofrece. ¡Es lo mejor de ambos mundos!

Atajos de teclado esenciales en Kitty: Dominando tu terminal

2025-12-25T12:15:00+01:00

Kitty es un terminal que brilla por su rendimiento y su gran capacidad de personalización, pero donde realmente se potencia es en su interfaz controlada por teclado. Dominar sus atajos te permitirá navegar, gestionar y manipular tus sesiones de terminal con una eficiencia asombrosa.

Descubre tus atajos: `show_shortcuts`¶

La forma más rápida de conocer todos los atajos de teclado configurados en tu instancia de Kitty es usando su propia funcionalidad:

kitty +kitten show_shortcuts

Esto abrirá una ventana interactiva donde podrás ver todos los atajos, tanto los predeterminados como los personalizados en tu kitty.conf.

Atajos Esenciales para el Día a Día¶

Aquí te presento algunos de los atajos más útiles y que más te ayudarán a optimizar tu flujo de trabajo:

Gestión de Ventanas y Splits (Paneles)¶

ctrl+shift+enter: Abre una nueva ventana de Kitty.
ctrl+shift+w: Cierra la ventana actual de Kitty.
ctrl+shift+o: Divide la ventana actual verticalmente (nuevo panel a la derecha).
ctrl+shift+e: Divide la ventana actual horizontalmente (nuevo panel abajo).
ctrl+shift+f: Alterna entre paneles divididos (focus).
ctrl+shift+[ / ctrl+shift+]: Navega entre paneles (izquierda/derecha).
ctrl+shift+alt+[ / ctrl+shift+alt+]: Mueve el panel activo (izquierda/derecha).

Gestión de Pestañas¶

ctrl+shift+t: Abre una nueva pestaña.
ctrl+shift+q: Cierra la pestaña actual.
ctrl+shift+.: Mueve a la siguiente pestaña.
ctrl+shift+,: Mueve a la pestaña anterior.
ctrl+shift+alt+.: Mueve la pestaña actual a la derecha.
ctrl+shift+alt+,: Mueve la pestaña actual a la izquierda.

Copiar y Pegar¶

Kitty tiene su propia implementación de copiar/pegar, que puede ser más fiable que la del sistema cuando trabajas en entornos remotos o con multiplexores:

ctrl+shift+c: Copia el texto seleccionado al portapapeles del sistema.
ctrl+shift+v: Pega el texto del portapapeles del sistema.

Control de Fuentes y Apariencia¶

ctrl+shift+= (o +): Aumenta el tamaño de la fuente.
ctrl+shift+-: Disminuye el tamaño de la fuente.
ctrl+shift+backspace: Restablece el tamaño de la fuente al valor predeterminado.
ctrl+shift+k: Entra en modo "scrollback" (para buscar o seleccionar texto histórico).

Personalizando tus Atajos en `kitty.conf`¶

Puedes añadir o modificar atajos de teclado en tu archivo de configuración ~/.config/kitty/kitty.conf usando la directiva map. Por ejemplo, para mapear F1 para un script personalizado:

map f1 launch --type=overlay bash -c "my_custom_script.sh"

Dominar estos atajos transformará tu interacción con la terminal, haciéndola más fluida e intuitiva. ¡Experimenta y personaliza Kitty para que se adapte perfectamente a tu estilo de trabajo!

De Yakuake a Kitty: Mi transición a un terminal moderno

2025-12-25T12:00:00+01:00

Durante años, Yakuake ha sido mi terminal de cabecera en entornos de escritorio KDE. Su comodidad de acceso rápido, desplegándose y ocultándose con una simple pulsación de tecla, es innegable. Sin embargo, en mi búsqueda constante de optimización y rendimiento, decidí explorar alternativas, y Kitty emergió como una opción destacada.

¿Por qué el cambio?¶

Aunque Yakuake es excelente en su nicho, Kitty ofrece una serie de ventajas que se alinean mejor con las demandas de un flujo de trabajo moderno y exigente:

Rendimiento Acelerado por GPU: Kitty está diseñado para aprovechar la tarjeta gráfica, lo que resulta en un renderizado de texto extremadamente rápido y fluido, especialmente noticeable en terminales con mucho scroll o salida de datos intensa.
Multiplexación Integrada: A diferencia de Yakuake, que se basa en sesiones de pestañas/ventanas tradicionales, Kitty incorpora su propio sistema de multiplexación (similar a tmux o screen) que permite dividir ventanas, crear pestañas y organizar paneles de forma nativa y eficiente.
Configurabilidad Extensa: kitty.conf permite una personalización profunda, desde atajos de teclado hasta la apariencia, temas y comportamiento.
Soporte Moderno: Excelente soporte para Wayland (el futuro de Linux en el escritorio), ligaduras de fuentes (como las de Fira Code), y un ecosistema de "kittens" (scripts y funcionalidades extendidas).
Cross-platform: Aunque mi uso principal es en Linux, la capacidad de tener una experiencia de terminal consistente en diferentes sistemas operativos es un plus.

Adaptándose a Kitty¶

La transición requirió ajustar algunas costumbres, principalmente la forma de gestionar las sesiones y el acceso rápido. Sin embargo, las ventajas superan con creces la curva de aprendizaje inicial. La velocidad, la fluidez y la potencia de las características integradas de Kitty lo convierten en una herramienta indispensable para mi día a día.

Configurar Kitty es un proceso sencillo a través de su archivo kitty.conf, donde se definen todos los aspectos del terminal. Exploraremos más sobre su configuración y atajos de teclado en próximas entradas.

Si buscas llevar tu experiencia de terminal al siguiente nivel, la migración a Kitty es un paso que recomiendo encarecidamente.

Poe the Poet: Automatizando tareas en proyectos Python con uv

2025-12-25T11:00:00+01:00

La gestión de proyectos Python a menudo implica la ejecución de diversas tareas personalizadas, desde la construcción de documentación hasta la ejecución de tests o scripts auxiliares. Si bien uv ha simplificado enormemente la gestión de dependencias, la forma de integrar y ejecutar estos comandos directamente desde pyproject.toml ha sido un punto de debate. Aquí es donde Poe the Poet emerge como una solución elegante y efectiva.

¿Qué es Poe the Poet?¶

Poe the Poet es una herramienta que permite definir "scripts" o "tareas" personalizadas directamente en tu archivo pyproject.toml. Estas tareas pueden ser cualquier comando que quieras ejecutar en el contexto de tu entorno Python, haciendo que la automatización del flujo de trabajo sea mucho más limpia y centralizada. Resuelve el problema de tener que recurrir a Makefile u otros scripts externos para tareas específicas del proyecto.

Cómo Usar Poe the Poet con uv¶

La integración de Poe the Poet en un proyecto que usa uv es sencilla:

Añadir poethepoet a tus dependencias de desarrollo: Primero, asegúrate de que poethepoet esté incluido en tu grupo de dependencias de desarrollo (por ejemplo, dev) en pyproject.toml.

[project]
# ... otras configuraciones del proyecto ...

[tool.uv]
dev-dependencies = [
    "black",
    "ruff",
    "poethepoet>=0.38.0", # Añade Poe the Poet aquí
]

Definir tareas personalizadas: Luego, puedes añadir una sección [tool.poe.tasks] en tu pyproject.toml para definir tus comandos personalizados.

[tool.poe.tasks]
docs = "sphinx-build -M html docs docs/_build"
livehtml = "sphinx-autobuild -b html docs docs/_build"
cog = "cog -r docs/*.md"

Ejecutando Tareas con `uv run`¶

Una vez que Poe the Poet está configurado y tus tareas están definidas, puedes ejecutarlas fácilmente usando uv run:

# Para construir la documentación
uv run poe docs

# Para el servidor de previsualización en vivo
uv run poe livehtml

# Para ejecutar el comando 'cog'
uv run poe cog

Beneficios¶

Centralización: Todas tus tareas personalizadas viven en pyproject.toml, junto a tus dependencias.
Integración con uv: Las tareas se ejecutan en el entorno virtual gestionado por uv, asegurando que todas las herramientas necesarias estén disponibles.
Simplificación: Evita la necesidad de Makefile o scripts bash complejos para tareas comunes.
Consistencia: Promueve un flujo de trabajo más consistente y fácil de compartir entre colaboradores.

Poe the Poet ofrece una forma robusta y elegante de extender las capacidades de uv para la automatización de tareas en proyectos Python, mejorando la experiencia de desarrollo.

Artículo original: Poe the Poet - Simon Willison's Weblog

Cómo uso git worktrees para trabajo concurrente

2025-07-23T06:12:00+02:00

Aleksey Kladov comparte su enfoque único para usar git worktrees, que va más allá del simple cambio de ramas y se convierte en una metodología completa para el trabajo concurrente.

La filosofía central

"Git no es un sistema de control de versiones, Git es una caja de herramientas para construir un VCS"

Esta perspectiva cambia completamente cómo pensamos sobre git. En lugar de limitarnos a las funcionalidades básicas, podemos crear nuestro propio flujo de trabajo optimizado.

Los 5 worktrees especializados

El autor mantiene 5 worktrees, cada uno con un propósito específico:

main - Snapshot de solo lectura - Reflejo limpio del main remoto - Referencia para comparaciones - Nunca se modifica localmente
work - Espacio de trabajo principal - Desarrollo activo día a día - Commits frecuentes con mensajes mínimos - HEAD desacoplado para máxima flexibilidad
review - Dedicado a revisiones de código - Contexto limpio para analizar PRs - Sin interferir con el trabajo en curso
fuzz - Pruebas de larga duración - Fuzzing y tests que duran horas - Corre en paralelo sin bloquear el desarrollo
scratch - Tareas rápidas no relacionadas - Experimentos - Fixes urgentes - Investigaciones puntuales

# Estructura típica de directorios
~/projects/my-project/
├── main/        # worktree principal
├── work/        # desarrollo activo
├── review/      # revisiones
├── fuzz/        # testing
└── scratch/     # experimentos

Ventajas del enfoque

Trabajo verdaderamente concurrente

Múltiples actividades de codificación simultáneas
Sin necesidad de stash o branch switching complejo
Separación limpia de contextos

Flujo de trabajo sin fricción

Cambio instantáneo entre tareas
Commits frecuentes sin presión por mensajes perfectos
Experimentación libre en HEAD desacoplado

Paralelización real

Fuzzing corriendo mientras desarrollas
Reviews sin interrumpir el trabajo principal
Tests en background sin bloqueos

Técnicas avanzadas

HEAD desacoplado estratégico

# En el worktree 'work', trabajar sin rama
git checkout --detach HEAD
# Commit frecuente, reorganizar después
git commit -m "wip"

Scripts personalizados para operaciones comunes

# Script para crear/cambiar worktrees rápidamente
#!/bin/bash
git worktree add "../$1" "$2"
cd "../$1"

Flujo de integración

# Desde el worktree 'work'
git log --oneline  # revisar commits
git reset HEAD~5   # deshacer commits temporales
git add -p         # seleccionar cambios
git commit         # commit final limpio

Lecciones clave

Git es flexible: No hay "una forma correcta" de usar git
Automatiza lo repetitivo: Scripts personalizados para operaciones comunes
Separa contextos: Cada tipo de trabajo merece su propio espacio
Commits baratos: Commitea frecuentemente, organiza después

Este enfoque transforma git de una herramienta de versionado en una plataforma completa de gestión de flujo de trabajo, maximizando la productividad a través del trabajo verdaderamente concurrente.

Artículo original: How I Use Git Worktrees

Búsqueda híbrida con SQLite: vector + texto completo

2024-10-06T11:43:00+02:00

Simon Willison presenta una aproximación fascinante para combinar búsqueda vectorial y tradicional búsqueda de texto completo en SQLite, usando una técnica llamada Reciprocal Rank Fusion (RRF).

El problema central

Cuando tenemos búsquedas vectoriales (basadas en similitud semántica) y búsquedas de texto completo (FTS), cada una devuelve puntuaciones en escalas completamente diferentes:

FTS devuelve puntuaciones de relevancia
Búsqueda vectorial devuelve distancias de similitud

¿Cómo combinar estos resultados de manera efectiva?

La solución: Reciprocal Rank Fusion

La técnica RRF evita comparar puntuaciones incompatibles y en su lugar se basa en el ranking de cada resultado dentro de su respectivo método de búsqueda.

SELECT
    content,
    1.0 / (:rrf_k + coalesce(fts_rank, 999)) * :fts_weight +
    1.0 / (:rrf_k + coalesce(vec_rank, 999)) * :vec_weight as combined_rank
FROM (
    -- Subconsulta FTS con row_number()
    SELECT *, row_number() OVER (ORDER BY rank) as fts_rank
    FROM fts_search(:query)
) fts
FULL OUTER JOIN (
    -- Subconsulta vectorial con row_number()
    SELECT *, row_number() OVER (ORDER BY distance) as vec_rank
    FROM vector_search(:query, :k)
) vec ON fts.id = vec.id
ORDER BY combined_rank DESC;

Ventajas del enfoque híbrido

Flexibilidad: Permite ajustar pesos entre FTS y búsqueda vectorial
Robustez: Los resultados pueden aparecer en uno o ambos métodos
Escalabilidad: No requiere normalización compleja de puntuaciones
Simplicidad: Una sola consulta SQL maneja toda la lógica

SQLite como plataforma unificada

Con extensiones como sqlite-vec, SQLite se convierte en una plataforma poderosa para:

Búsqueda de texto completo (FTS5 nativo)
Búsqueda vectorial de embeddings
Combinación híbrida de ambas técnicas

Esta aproximación democratiza las técnicas avanzadas de búsqueda, haciéndolas accesibles sin infraestructura compleja.

Artículo original: Hybrid full-text search and vector search with SQLite

Conflación de datos geoespaciales con DuckDB y embeddings

2024-10-01T07:12:00+02:00

Drew Breunig presenta un fascinante caso práctico de conflación de datos geoespaciales: el proceso de identificar y unir registros similares de fuentes diferentes.

El reto: Integrar datos de restaurantes

El objetivo era conectar dos fuentes de datos:

Inspecciones de restaurantes del condado de Alameda
Datos de lugares de Overture Maps Foundation

Dos datasets con información similar pero estructurada de forma diferente.

Herramientas del stack moderno

DuckDB como motor principal

Staging y consultas de grandes volúmenes de datos
Soporte nativo para formatos geoespaciales
Performance excepcional para análisis exploratorio

H3 para agrupación espacial

-- Agrupar lugares cercanos usando hexágonos H3
SELECT h3_cell_to_lat_lng(h3_latlng_to_cell(lat, lng, 9)) as h3_9
FROM places

Ollama para embeddings locales

Framework de ML ejecutándose localmente
Generación de embeddings contextuales
Sin dependencia de APIs externas

Tres enfoques de matching

1. Matching exacto por nombre

Resultado: ~31% de coincidencias
Limitaciones: Nombres de cadenas, números de unidad en direcciones

2. Similitud de strings (Jaro-Winkler)

-- Comparación combinando nombre y dirección
WHERE jaro_winkler_similarity(name1, name2) > 0.8
  AND levenshtein(address1, address2) < 5

Resultado: ~68% de coincidencias
Desventaja: SQL complejo con muchas reglas condicionales

3. Matching basado en embeddings

# Generar descripción contextual
description = f"{name} at {address} in {city}"
embedding = ollama.embeddings(description)

Resultado: ~71% de coincidencias
Ventajas: Pipeline más simple, mayor flexibilidad
Desventaja: Mayor tiempo de procesamiento

Insights clave

No existe la bala de plata - cada método tiene fortalezas específicas
Las herramientas locales son poderosas - DuckDB + Ollama permiten análisis sofisticados sin cloud
Los embeddings son prometedores - especialmente para casos con contexto complejo
La conflación requiere iteración - combinar múltiples técnicas mejora los resultados

El futuro de la integración de datos

Este trabajo muestra cómo las herramientas modernas democratizan técnicas que antes requerían infraestructura compleja. La combinación de:

Bases de datos analíticas (DuckDB)
Índices espaciales (H3)
ML local (Ollama)

...abre nuevas posibilidades para la integración inteligente de datos.

Artículo original: Conflating Overture Places Using DuckDB, Ollama, Embeddings, and More

HTTPX: Cliente HTTP moderno para Python

2024-09-23T00:07:00+02:00

HTTPX se presenta como la evolución natural de la popular biblioteca requests, manteniendo su simplicidad pero añadiendo capacidades modernas que las aplicaciones actuales necesitan.

¿Por qué HTTPX?

Mientras requests sigue siendo excelente para uso síncrono, HTTPX aborda las limitaciones que han surgido con el tiempo:

Sin soporte async nativo en requests
HTTP/2 no disponible
Type hints limitados
Timeouts menos precisos

Instalación y configuración

# Instalación básica
pip install httpx

# Con soporte HTTP/2
pip install httpx[http2]

# Con compresión avanzada
pip install httpx[brotli,zstd]

API familiar, capacidades modernas

Uso síncrono - Compatible con requests:

import httpx

# GET básico
r = httpx.get('https://api.github.com/users/octocat')
print(r.status_code)  # 200
print(r.json()['login'])  # 'octocat'

# POST con datos JSON
payload = {'key': 'value'}
r = httpx.post('https://httpbin.org/post', json=payload)

# Headers personalizados
headers = {'User-Agent': 'my-app/1.0'}
r = httpx.get('https://api.example.com/data', headers=headers)

El poder del async/await

Cliente asíncrono - La verdadera ventaja:

import asyncio
import httpx

async def fetch_user(client, username):
    r = await client.get(f'https://api.github.com/users/{username}')
    return r.json()

async def main():
    async with httpx.AsyncClient() as client:
        users = await asyncio.gather(
            fetch_user(client, 'octocat'),
            fetch_user(client, 'gvanrossum'),
            fetch_user(client, 'kennethreitz')
        )

    for user in users:
        print(f"{user['login']}: {user['public_repos']} repos")

asyncio.run(main())

Funcionalidades avanzadas

Timeouts estrictos:

# Timeout granular
timeout = httpx.Timeout(10.0, read=5.0)

async with httpx.AsyncClient(timeout=timeout) as client:
    r = await client.get('https://slow-api.example.com')

Streaming de datos:

# Descarga streaming
async with httpx.AsyncClient() as client:
    async with client.stream('GET', 'https://example.com/bigfile.zip') as r:
        async for chunk in r.aiter_bytes(chunk_size=8192):
            # Procesar chunk
            process_data(chunk)

Pruebas con aplicaciones WSGI/ASGI:

# Testear FastAPI directamente
from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

# Test directo sin servidor
with httpx.Client(app=app, base_url="http://testserver") as client:
    r = client.get("/")
    assert r.json() == {"message": "Hello World"}

HTTP/2 y conexiones persistentes

# Cliente con HTTP/2 y pool de conexiones
limits = httpx.Limits(max_keepalive_connections=5, max_connections=10)

async with httpx.AsyncClient(http2=True, limits=limits) as client:
    # Múltiples requests reutilizan conexiones
    tasks = [client.get(f'https://httpbin.org/get?page={i}')
             for i in range(50)]

    responses = await asyncio.gather(*tasks)
    print(f"Completed {len(responses)} requests")

Comparativa: requests vs HTTPX

Característica	requests	HTTPX
API familiar	✓	✓
Soporte async	✗	✓
HTTP/2	✗	✓
Type hints	Parcial	Completo
Timeouts precisos	Básico	Avanzado
Testing WSGI/ASGI	✗	✓
Streaming	Básico	Avanzado

Casos de uso ideales

HTTPX es perfecto para:

APIs concurrentes con async/await
Microservicios que necesitan HTTP/2
Testing de aplicaciones FastAPI/Django
Scraping a gran escala con streaming
Aplicaciones modernas con type safety

Mantén requests para:

Scripts simples sin concurrencia
Proyectos legacy ya establecidos
Código con dependencias que requieren requests

El futuro de HTTP en Python

HTTPX representa el camino hacia adelante para aplicaciones HTTP en Python, ofreciendo:

Performance moderna con async y HTTP/2
Developer experience mejorada con tipos
Ecosistema integrado con frameworks actuales
Compatibilidad que facilita migración

Es hora de considerar HTTPX como el cliente HTTP por defecto para nuevos proyectos Python.

Documentación oficial: python-httpx.org

Server-Sent Events: Comunicación en tiempo real simplificada

2024-09-23T00:01:00+02:00

Los Server-Sent Events (SSE) representan una solución elegante y simple para implementar comunicación en tiempo real en aplicaciones web cuando solo necesitamos que el servidor envíe datos al cliente.

¿Qué son los Server-Sent Events?¶

SSE es un estándar web que permite que un servidor envíe datos automáticamente a una página web usando una conexión HTTP persistente. A diferencia de WebSockets, la comunicación es unidireccional: solo el servidor puede enviar mensajes al cliente.

Implementación básica¶

Cliente (JavaScript)¶

// Crear conexión SSE
const eventSource = new EventSource('/api/events');

// Escuchar mensajes genéricos
eventSource.onmessage = function(event) {
    console.log('Mensaje recibido:', event.data);
    const data = JSON.parse(event.data);
    updateUI(data);
};

// Escuchar eventos personalizados
eventSource.addEventListener('notification', function(event) {
    const notification = JSON.parse(event.data);
    showNotification(notification.title, notification.message);
});

// Manejar errores
eventSource.onerror = function(event) {
    console.error('Error en SSE:', event);
};

// Cerrar conexión
// eventSource.close();

Servidor (Python/Flask)¶

from flask import Flask, Response
import json
import time
import threading

app = Flask(__name__)

def generate_events():
    """Generador que produce eventos SSE"""
    while True:
        # Evento genérico
        data = {
            'timestamp': time.time(),
            'users_online': get_users_count(),
            'server_status': 'running'
        }

        yield f"data: {json.dumps(data)}\n\n"

        time.sleep(10)  # Enviar cada 10 segundos

@app.route('/api/events')
def stream_events():
    """Endpoint SSE"""
    return Response(
        generate_events(),
        mimetype='text/event-stream',
        headers={
            'Cache-Control': 'no-cache',
            'Connection': 'keep-alive',
            'Access-Control-Allow-Origin': '*'
        }
    )

@app.route('/api/notify')
def send_notification():
    """Enviar notificación específica"""
    def notification_event():
        notification = {
            'title': 'Nueva actualización',
            'message': 'El sistema se actualizó correctamente'
        }

        # Evento con nombre personalizado
        yield f"event: notification\n"
        yield f"data: {json.dumps(notification)}\n\n"

    return Response(notification_event(), mimetype='text/event-stream')

Formato del stream de eventos¶

Los eventos SSE siguen un formato específico:

event: message-type
data: {"key": "value"}
id: unique-message-id
retry: 3000

event: Nombre del evento (opcional)
data: Contenido del mensaje
id: Identificador único para reconexión
retry: Tiempo de reintento en milisegundos

Casos de uso ideales¶

1. Feeds en tiempo real¶

const newsSource = new EventSource('/api/news-feed');

newsSource.addEventListener('article', function(event) {
    const article = JSON.parse(event.data);
    addArticleToFeed(article);
});

2. Notificaciones push¶

const notificationSource = new EventSource('/api/notifications');

notificationSource.onmessage = function(event) {
    const notification = JSON.parse(event.data);

    // Mostrar notificación del navegador
    if (Notification.permission === 'granted') {
        new Notification(notification.title, {
            body: notification.message,
            icon: '/icon.png'
        });
    }
};

3. Dashboard en tiempo real¶

const dashboardSource = new EventSource('/api/dashboard');

dashboardSource.addEventListener('metrics', function(event) {
    const metrics = JSON.parse(event.data);
    updateCharts(metrics);
    updateCounters(metrics);
});

dashboardSource.addEventListener('alert', function(event) {
    const alert = JSON.parse(event.data);
    showAlert(alert.level, alert.message);
});

Ventajas de SSE¶

Simplicidad: API más simple que WebSockets
Reconexión automática: El navegador reintenta automáticamente
Eficiencia: Menor overhead que polling
Compatibilidad: Funciona sobre HTTP/HTTPS estándar
Firewall-friendly: No requiere puertos especiales

Limitaciones importantes¶

Unidireccional: Solo servidor → cliente
Límites de conexión: Navegadores limitan conexiones simultáneas
Formato de datos: Solo texto (aunque JSON funciona bien)
Sin compresión nativa: A diferencia de WebSockets

SSE vs WebSockets: ¿Cuándo usar cada uno?¶

Usa SSE cuando:¶

Solo necesitas servidor → cliente
Simplicidad es prioritaria
Actualizaciones periódicas (feeds, notificaciones)
Compatibilidad con proxies/firewalls es importante

Usa WebSockets cuando:¶

Necesitas comunicación bidireccional
Latencia ultra-baja es crítica
Intercambio intensivo de datos
Control total sobre el protocolo

Manejo de errores y reconexión¶

const eventSource = new EventSource('/api/events');

let reconnectInterval = 1000;
const maxReconnectInterval = 30000;

eventSource.onopen = function() {
    console.log('Conexión SSE establecida');
    reconnectInterval = 1000; // Reset interval
};

eventSource.onerror = function(event) {
    console.error('Error SSE:', event);

    if (eventSource.readyState === EventSource.CLOSED) {
        // Reconexión manual con backoff exponencial
        setTimeout(() => {
            console.log('Intentando reconectar...');
            reconnectSSE();
        }, reconnectInterval);

        reconnectInterval = Math.min(reconnectInterval * 2, maxReconnectInterval);
    }
};

function reconnectSSE() {
    eventSource.close();
    eventSource = new EventSource('/api/events');
}

Conclusión¶

Server-Sent Events ofrece una solución pragmática para comunicación en tiempo real cuando WebSockets resulta excesivo. Su simplicidad, reconexión automática y compatibilidad lo convierten en una opción excelente para feeds, notificaciones y dashboards en tiempo real.

Para aplicaciones que requieren actualizaciones del servidor al cliente sin la complejidad de WebSockets, SSE es la herramienta perfecta.

Documentación oficial: Using server-sent events - MDN

Una de versiones

2017-05-01T18:04:00+02:00

¿Quieres saber la forma correcta de nombrar las versiones? Para eso está la PEP 440: Version Identification and Dependency Specification.

Quizá lo más digno de anotar sea el eso de esos sufijos .dev0, etc. para los eggs en desarrollo.

MobaXterm. Mucho más que un cliente ssh

2017-04-11T14:07:00+02:00

Como sabéis, no soy de Windows. Linuxero desde hace años, tras pasar por múltiples sabores de Debian, ahora lo mío es OpenSuse Tumbleweed. Pero también tengo un equipo de trabajo Windows 7 que uso ocasionalmente. Para eso viene muy bien MobaXterm.

MobaXterm es un conjunto de aplicaciones muy interesantes para trabajar como en Linux y conectarte a equipos remotos: terminal, cliente ssh, servidor X, rdp, vnc, etc.

PosteRazor: Crea pósters gigantes desde cualquier imagen

2017-02-24T20:06:00+01:00

PosteRazor es una herramienta gratuita y open source que resuelve un problema cotidiano: ¿cómo imprimir una imagen grande cuando solo tienes una impresora doméstica?

¿Qué hace PosteRazor?¶

PosteRazor toma una imagen raster y la "corta" en piezas que después pueden imprimirse y ensamblarse para formar un póster completo. Convierte una sola imagen en un documento PDF multipágina listo para imprimir.

Características principales¶

Interfaz tipo asistente con 5 pasos sencillos
Multiplataforma: Windows, macOS, Linux
Versión web disponible via WebAssembly
Completamente gratuito y open source

Casos de uso ideales¶

Pósters decorativos para casa, escuela u oficina
Proyectos DIY de decoración
Imprimir imágenes gigantes que exceden el tamaño de página estándar
Presentaciones visuales de gran formato

¿Cómo funciona?¶

Cargas tu imagen
Seleccionas el tamaño del póster deseado
Configuras el formato de página de tu impresora
PosteRazor calcula la división automáticamente
Generas el PDF e imprimes cada página

La solución perfecta¶

PosteRazor democratiza la creación de pósters grandes. Ya no necesitas servicios de impresión costosos - con cualquier impresora doméstica puedes crear pósters del tamaño que quieras.

Sitio oficial: PosteRazor

Correo no leído en pestaña principal de gmail

2016-07-28T18:00:00+02:00

Lo de siempre, otra nota recordatoria.

Si filtras el correo en gmail por no leído (is:unread), obtienes todo el correo no leído, que en mi caso siempre incluye cientos de notificaciones, social, promociones o foros que no suele ser lo que busco.

Para buscar los correos no leídos de la pestaña Principal la consulta a realizar es esta:

is:inbox -category:(updates OR promotions OR social OR forums) is:unread

Documentación técnica con Sphinx, Paver y Cog

2016-07-14T00:47:00+02:00

Doug Hellmann presenta un workflow robusto para documentación técnica que elimina el trabajo manual repetitivo y los errores en ejemplos de código.

El problema a resolver¶

"Automation is important for my sense of well being. I hate dealing with mundane repetitive tasks."

Desafíos comunes: - Mantener ejemplos de código actualizados - Múltiples formatos de salida (HTML, PDF, blog) - Tareas repetitivas de construcción y publicación - Errores de copy-paste en output de programas

La solución: Trio de herramientas¶

Sphinx: Motor de documentación¶

Conversión reStructuredText a múltiples formatos
Temas personalizables con Jinja templates
Generación automática de índices y referencias cruzadas

Paver: Automatización de builds¶

# pavement.py
@task
def html():
    """Build HTML documentation"""
    call_task('cog')
    sphinx_build('html')

@task  
def pdf():
    """Build PDF documentation"""
    call_task('cog')
    sphinx_build('latex')
    make_pdf()

Resuelve: Automatización de procesos repetitivos de construcción

Cog: Inserción automática de código¶

.. cog::

   import cog
   import subprocess

   result = subprocess.run(['python', 'ejemplo.py'], 
                          capture_output=True, text=True)
   cog.out(result.stdout)

.. cog::

Ventaja clave: El output de programas se actualiza automáticamente al regenerar la documentación.

Workflow de producción¶

1. Escritura en reStructuredText¶

Ejemplo de uso
==============

Ejecutamos el script:

.. cog::
   cog.out("$ python mi_script.py\n")
   result = subprocess.run(['python', 'mi_script.py'], 
                          capture_output=True, text=True)
   cog.out(result.stdout)
.. cog::

2. Construcción automatizada¶

# Un solo comando para todo
paver html

# O para múltiples destinos
paver all_formats

3. Publicación multi-destino¶

Python Module of the Week (PyMOTW)
Blog personal
Sitio web del proyecto
O'Reilly blog
Documentación PDF

Ventajas del enfoque¶

Consistencia garantizada¶

Ejemplos siempre actualizados con el código real
Formato uniforme across múltiples destinos
Sin errores de transcripción manual

Eficiencia maximizada¶

Un source, múltiples outputs
Automatización completa del pipeline
Focus en contenido, no en proceso

Mantenibilidad¶

Cambios en una sola fuente se propagan automáticamente
Testing integrado de ejemplos de código
Versionado único para toda la documentación

Implementación práctica¶

# pavement.py completo
from paver.easy import *
import paver.doctools

@task
def cog():
    """Run Cog to update code examples"""
    sh('cog -r *.rst')

@task
@needs('cog')
def html():
    """Build HTML docs"""
    paver.doctools.html()

@task
@needs('cog') 
def blog_post():
    """Generate blog post version"""
    # Custom blog formatting
    pass

Este workflow representa la automatización inteligente de documentación técnica: escribes una vez, publicas en todas partes, siempre actualizado.

Fuente original: Doug Hellmann

Determinar slots de RAM en uso en Linux

2016-07-13T20:28:00+02:00

¿Cuántos slots de RAM tienes ocupados y cuántos libres? Linux proporciona herramientas para inspeccionar la configuración de memoria sin abrir el ordenador.

dmidecode: La herramienta principal¶

Información básica de memoria¶

# Ver toda la información de memoria
sudo dmidecode -t memory

# Tipo específico de memoria (tabla 16)
sudo dmidecode -t 16

# Solo los tamaños instalados
sudo dmidecode -t memory | grep -i size

Salida típica:

Size: 8192 MB
Size: 8192 MB
Size: No Module Installed
Size: No Module Installed

Información detallada por slot¶

# Información granular de cada slot (tabla 17)
sudo dmidecode -t 17

# Resumen compacto
sudo dmidecode -t 17 | grep -E "(Size|Locator|Speed|Type:)"

Información proporcionada: - Locator: Identificador físico del slot (DIMM_A1, DIMM_B1, etc.) - Size: Capacidad instalada o "No Module Installed" - Type: DDR3, DDR4, etc. - Speed: Velocidad en MT/s

lshw: Alternativa con formato estructurado¶

# Información de memoria con lshw
sudo lshw -class memory

# Solo memoria física (sin caché)
sudo lshw -class memory | grep -A 10 "System Memory"

# Formato más compacto
sudo lshw -short -class memory

Scripts útiles para análisis¶

Contador de slots ocupados¶

#!/bin/bash
echo "=== Análisis de slots de RAM ==="
TOTAL_SLOTS=$(sudo dmidecode -t 17 | grep "Size:" | wc -l)
OCCUPIED_SLOTS=$(sudo dmidecode -t 17 | grep "Size:" | grep -v "No Module" | wc -l)
FREE_SLOTS=$((TOTAL_SLOTS - OCCUPIED_SLOTS))

echo "Slots totales: $TOTAL_SLOTS"
echo "Slots ocupados: $OCCUPIED_SLOTS" 
echo "Slots libres: $FREE_SLOTS"

Resumen detallado¶

#!/bin/bash
echo "=== Configuración actual de RAM ==="
sudo dmidecode -t 17 | awk '
/Memory Device/,/^$/ {
    if(/Locator:/) locator=$2
    if(/Size:/ && !/No Module/) {
        size=$2" "$3
        print locator": "size
    }
    if(/Size:.*No Module/) print locator": Vacío"
}'

Información adicional útil¶

Capacidad máxima soportada¶

# Máxima capacidad total
sudo dmidecode -t 16 | grep "Maximum Capacity"

# Número máximo de dispositivos
sudo dmidecode -t 16 | grep "Number Of Devices"

Verificación de velocidad y tipo¶

# Velocidad configurada
sudo dmidecode -t 17 | grep -E "(Speed|Configured)"

# Tipo de memoria
sudo dmidecode -t 17 | grep "Type:" | grep -v "Error"

Ejemplo de salida interpretada¶

$ sudo dmidecode -t 17 | grep -E "(Locator|Size|Type:)" | head -12

Locator: DIMM_A1
Size: 8192 MB  
Type: DDR4

Locator: DIMM_A2
Size: No Module Installed
Type: Unknown

Locator: DIMM_B1  
Size: 8192 MB
Type: DDR4

Locator: DIMM_B2
Size: No Module Installed
Type: Unknown

Interpretación: - 4 slots totales (DIMM_A1, A2, B1, B2) - 2 slots ocupados con 8GB DDR4 cada uno - 2 slots libres disponibles

Limitaciones importantes¶

⚠️ Precisión: Las herramientas de línea de comandos pueden no reflejar perfectamente el hardware físico

⚠️ Privilegios: Se requieren permisos de root para acceder a información DMI

⚠️ Compatibilidad: Algunos sistemas embebidos pueden no proporcionar información completa

Para máxima certeza, la inspección física sigue siendo recomendable, pero estas herramientas proporcionan información suficientemente precisa para la mayoría de casos.

Fuente original: Unix & Linux Stack Exchange

Introducción a los sistemas de trading de alta frecuencia

2016-06-27T11:51:00+02:00

Los programas de negociación de alta frecuencia (High-Frequency Trading o HFT) representan la automatización extrema de las inversiones financieras, operando a velocidades que superan cualquier capacidad humana.

¿Qué es el HFT?¶

Los sistemas HFT son programas diseñados para invertir en mercados financieros con las siguientes características:

Volumen masivo: Compran y venden hasta decenas de miles de acciones u opciones al día
Velocidad extrema: Cada operación puede durar fracciones de segundo
Márgenes pequeños: Beneficio muy reducido por operación individual
Efecto acumulativo: En su cómputo global se hace muy efectivo

Principios fundamentales¶

Velocidad como ventaja competitiva¶

Latencia ultra-baja: Cada milisegundo cuenta
Proximidad física: Servidores cerca de las bolsas
Hardware especializado: FPGA, cables de fibra óptica optimizados

Estrategias algorítmicas¶

Market making: Proveer liquidez constante
Arbitraje estadístico: Aprovechar discrepancias de precio
Arbitraje temporal: Explotar diferencias entre mercados

Tecnologías clave¶

Hardware optimizado¶

FPGA (Field-Programmable Gate Arrays) para procesamiento ultrarápido
Servidores co-ubicados en datacenters de intercambios
Redes de fibra óptica de alta velocidad

Software especializado¶

Algoritmos de baja latencia
Protocolos de red optimizados
Sistemas de gestión de riesgo en tiempo real

Impacto en los mercados¶

Beneficios¶

Mayor liquidez en los mercados
Spreads más ajustados entre bid/ask
Eficiencia de precios mejorada

Controversias¶

Volatilidad aumentada en momentos de estrés
Ventaja injusta sobre inversores tradicionales
Posibles manipulaciones de mercado

El futuro del HFT¶

La carrera por la velocidad continúa evolucionando hacia: - Inteligencia artificial y machine learning - Análisis de sentiment en tiempo real - Computación cuántica experimental

El HFT ejemplifica cómo la tecnología redefine completamente industrias tradicionales, creando nuevas oportunidades y desafíos éticos.

Fuente original: Alberto Magallón

Cómo encontrar hosts vivos en tu red local

2016-06-27T07:59:00+02:00

Descubrir qué dispositivos están activos en tu red local es una tarea fundamental para administradores de red y profesionales de seguridad. Estas son las técnicas más efectivas.

Nmap: La herramienta principal¶

Escaneo básico de hosts¶

# Ping scan simple
nmap -sn 192.168.1.1/24

# Escaneo con puertos TCP específicos
nmap -sP -PS22,3389 192.168.1.1/24

# Escaneo UDP para dispositivos especiales
nmap -sP -PU161 192.168.1.1/24

-sn: Solo descubrimiento de hosts, sin escaneo de puertos
-PS: TCP SYN discovery en puertos específicos
-PU: UDP discovery (útil para dispositivos embebidos)

Escaneos más exhaustivos¶

# Escaneo completo con detección de OS
nmap -A 192.168.1.1/24

# Escaneo TCP Connect (menos intrusivo)
nmap -sT 192.168.1.1/24

# Bypass de firewall con fragmentación
nmap -f -sS 192.168.1.1/24

Herramientas alternativas¶

arp-scan: Basado en ARP¶

# Escaneo de subred local
arp-scan 192.168.12.0/24

# Con interfaz específica
arp-scan -I eth0 172.16.17.0/24

# Scan local simplificado
arp-scan -l

Ventaja: Funciona incluso con firewalls estrictos

netdiscover: Descubrimiento pasivo/activo¶

# Descubrimiento activo
netdiscover -r 172.16.17.0/24

# Modo pasivo (solo escucha)
netdiscover -p

# Fast mode
netdiscover -f -r 192.168.1.0/24

fing: Scanner móvil¶

# Escaneo rápido
fing -r 1

# Con detalles del fabricante
fing -o table,csv

Verificación post-escaneo¶

Revisar tabla ARP¶

# Ver tabla ARP actual
arp -a -n

# En sistemas modernos
ip neigh show

# Limpiar y reescanear
sudo arp -d -a
ping -c 1 192.168.1.{1..254}
arp -a

Técnicas avanzadas¶

Wireshark para análisis pasivo¶

Capturar tráfico en la interfaz de red
Filtrar por ARP: arp
Analizar broadcast traffic
Identificar dispositivos por patrones de tráfico

Scripts de automatización¶

#!/bin/bash
# Scan completo de red local
echo "Escaneando red..."
nmap -sn $(ip route | grep -E "^192|^10|^172" | awk '{print $1}' | head -1)
echo "Verificando ARP..."
arp -a -n | grep -v "incomplete"

Consideraciones importantes¶

Limitaciones por firewall¶

Algunos dispositivos bloquean ping/ICMP
Firewalls corporativos pueden filtrar escaneos
Diferentes puertos pueden revelar dispositivos "ocultos"

Consideraciones legales¶

⚠️ Autorización necesaria: Solo escanea redes propias
⚠️ Políticas corporativas: Verifica antes de escanear en entornos empresariales

Optimización por tipo de red¶

# Red doméstica (routers, IoT)
nmap -sn --min-rate 1000 192.168.1.1/24

# Red corporativa (servidores, estaciones)
nmap -sP -PS80,443,22,3389 10.0.0.0/8

# Red industrial (dispositivos embebidos)
nmap -sP -PU161,502 172.16.0.0/12

La combinación de múltiples técnicas proporciona el panorama más completo de dispositivos activos en tu red.

Fuente original: Information Security Stack Exchange

Potentes herramientas para desarrolladores desde línea de comandos

2016-06-07T11:36:00+02:00

La línea de comandos sigue siendo el entorno más poderoso para desarrolladores. Estas herramientas especializadas amplían dramáticamente tus capacidades de debugging, testing y análisis.

Curl: El navajero suizo del HTTP¶

# Obtener tu IP pública
curl ifconfig.me

# Inspeccionar headers de respuesta
curl -I https://ejemplo.com

# POST con datos JSON
curl -X POST -H "Content-Type: application/json" \
     -d '{"key":"value"}' https://api.ejemplo.com

Uso principal: Transferencia de datos de red, testing de APIs, inspección HTTP.

Ngrep: Grep para tráfico de red¶

# Filtrar tráfico HTTP por palabra clave
ngrep -i "password" port 80

# Capturar por IP específica
ngrep host 192.168.1.100

# Monitorear tráfico en puerto específico
ngrep port 443

Uso principal: Análisis de paquetes de red, debugging de protocolos, monitoreo de tráfico.

Netcat (nc): La navaja suiza del networking¶

# Escaneo de puertos
nc -zv ejemplo.com 1-1000

# Transferir archivo entre servidores
# Receptor: nc -l 1234 > archivo_recibido
# Emisor: nc servidor_destino 1234 < archivo_enviar

# Crear servidor HTTP simple
echo "HTTP/1.1 200 OK\n\nHola mundo" | nc -l 8080

Uso principal: Escaneo de puertos, transferencia de archivos, testing de conectividad.

Sshuttle: VPN fácil con SSH¶

# Tunelar todo el tráfico
sshuttle -r usuario@servidor 0.0.0.0/0

# Tunelar solo una subred
sshuttle -r usuario@servidor 192.168.1.0/24

# Evitar geobloqueos
sshuttle -r servidor_remoto 0.0.0.0/0 --dns

Uso principal: Tunneling seguro, bypass de geo-restricciones, protección en WiFi público.

Siege: Bombardeo de carga HTTP¶

# Test de carga simple
siege -c 25 -t 60s https://ejemplo.com

# Test con múltiples URLs
siege -c 50 -t 30s -f urls.txt

# Benchmark específico
siege -c 100 -r 10 https://api.ejemplo.com/endpoint

Uso principal: Testing de rendimiento, benchmarking HTTP, simulación de carga.

Mitmproxy: Espía del tráfico HTTP/S¶

# Proxy básico
mitmproxy -p 8080

# Modo transparent
mitmproxy --mode transparent

# Guardar tráfico en archivo
mitmdump -w captura.flow

Uso principal: Debugging de aplicaciones web, inspección de tráfico HTTPS, análisis de APIs.

Flujo de trabajo típico¶

# 1. Escanear conectividad
nc -zv api.ejemplo.com 443

# 2. Analizar respuesta
curl -I https://api.ejemplo.com

# 3. Monitorear tráfico
ngrep -i "api" port 443

# 4. Test de carga
siege -c 20 -t 30s https://api.ejemplo.com

# 5. Debugging detallado
mitmproxy -p 8080

¿Por qué línea de comandos?¶

Velocidad: Sin overhead de GUI
Scriptabilidad: Automatización completa
Flexibilidad: Combinación con pipes y redirects
Universalidad: Disponible en cualquier servidor

Estas herramientas convierten tu terminal en un laboratorio completo de networking y testing.

Fuente original: Somos Apañados

Sysdig: Plataforma de seguridad cloud-nativa con IA

2016-02-10T14:37:00+01:00

Sysdig es una plataforma de seguridad cloud que proporciona soluciones de seguridad integrales y en tiempo real para entornos cloud-nativos, resolviendo el conflicto entre las necesidades de los equipos de seguridad y desarrollo.

Características principales¶

IA de seguridad inteligente¶

IA contextual que comprende entornos cloud y guía insights accionables
Reducción del 76% en el tiempo medio de resolución (MTTR)

Visibilidad en tiempo real¶

Monitoreo continuo de actividades cloud y riesgos potenciales
Detección de amenazas en 2 segundos
Filtra el ruido para destacar solo problemas críticos

Innovación abierta¶

Basado en tecnologías open source como Falco
Transparencia y personalización en seguridad cloud

Beneficios clave¶

95% de ahorro en tiempo de gestión de vulnerabilidades
98% de reducción en ruido de vulnerabilidades
Detección ultra-rápida de amenazas

Propuesta de valor¶

Sysdig permite que los equipos de seguridad y desarrollo trabajen de forma más efectiva, habilitando innovación rápida sin comprometer la seguridad. La plataforma es utilizada por grandes empresas como IBM, Booking.com y Neo4j para asegurar sus entornos cloud.

Esta herramienta representa el futuro de la seguridad cloud-nativa: inteligente, rápida y sin compromisos.

Sitio oficial: Sysdig

Python: Crear generadores repetibles (repeating generators)

2016-02-09T10:10:00+01:00

Los generadores en Python son "one-shot" - solo se pueden iterar una vez. ¿Cómo crear generadores que se puedan reutilizar múltiples veces?

El problema¶

def mi_generador():
    yield 1
    yield 2
    yield 3

gen = mi_generador()
print(list(gen))  # [1, 2, 3]
print(list(gen))  # [] - ¡Vacío!

Solución 1: Enfoque con clase (Más robusto)¶

def multigen(gen_func):
    class _multigen(object):
        def __init__(self, *args, **kwargs):
            self.__args = args
            self.__kwargs = kwargs
        def __iter__(self):
            return gen_func(*self.__args, **self.__kwargs)
    return _multigen

# Uso
@multigen
def mi_generador_repetible(max_num):
    for i in range(max_num):
        yield i

gen = mi_generador_repetible(3)
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [0, 1, 2] - ¡Funciona!

Solución 2: itertools.cycle() para secuencias infinitas¶

import itertools

# Repetir infinitamente una secuencia
repeating_gen = itertools.cycle([1, 2, 3])

# Tomar solo los primeros 9 elementos
resultado = list(itertools.islice(repeating_gen, 9))
print(resultado)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

Solución 3: Lambda wrapper (Simple)¶

def mi_generador():
    yield 1
    yield 2
    yield 3

# Wrapper para crear nueva instancia cada vez
generador_repetible = lambda: mi_generador()

print(list(generador_repetible()))  # [1, 2, 3]
print(list(generador_repetible()))  # [1, 2, 3]

Solución 4: Función factory¶

def crear_generador(datos):
    def generador():
        for item in datos:
            yield item
    return generador

# Uso
gen_factory = crear_generador([1, 2, 3])
gen1 = gen_factory()
gen2 = gen_factory()

print(list(gen1))  # [1, 2, 3]
print(list(gen2))  # [1, 2, 3]

¿Cuándo usar cada enfoque?¶

Clase decorador (`@multigen`)¶

Generadores complejos con parámetros
Máxima flexibilidad y reutilización
Preserva metadatos del generador original

`itertools.cycle()`¶

Repetición infinita de secuencias pequeñas
Patrones cíclicos conocidos
Muy eficiente en memoria

Lambda wrapper¶

Casos simples sin parámetros
Prototipado rápido
Generadores sin estado

Factory function¶

Balance entre simplicidad y flexibilidad
Generadores con configuración inicial
Código más explícito

Consideraciones de rendimiento¶

⚠️ Memoria: Los generadores repetibles pueden requerir almacenar parámetros iniciales
⚠️ CPU: Cada iteración recalcula desde el inicio

La elección depende de si necesitas repetición exacta o reutilización eficiente.

Fuente original: Stack Overflow

Botón central en firefox

2016-01-01T07:00:00+01:00

Otra nota recordatoria. Habitualmente abro los enlaces en nueva ventana en firefox usando el botón central. Me ocurre a menudo que tengo una url en el clipboard y firefox entonces me la abre en lugar del enlace. Para evitarlo, simplemente about:config y establecer la propiedad middlemouse.contentLoadURL a false.

Bootstrap: Dos enlaces en la misma fila en dropdown

2015-12-15T10:40:00+01:00

A veces necesitas colocar dos enlaces lado a lado en la misma fila dentro de un dropdown de Bootstrap. La solución combina HTML estructurado y CSS con flexbox.

El problema¶

Por defecto, Bootstrap renderiza los enlaces de dropdown como elementos de bloque, ocupando toda la fila:

<!-- Comportamiento por defecto: cada enlace en su fila -->
<li><a href="#">Enlace 1</a></li>
<li><a href="#">Enlace 2</a></li>

La solución¶

HTML estructurado¶

<li class="hz">
    <a href="#">En la tercera fila</a>
    <a href="#">También en la tercera fila</a>
</li>

Clave: Múltiples enlaces <a> dentro del mismo <li> con clase personalizada.

CSS con flexbox¶

.open > ul > li.hz {
    display: inline-flex !important;
}

Clave: inline-flex override el display block por defecto de Bootstrap.

Implementación completa¶

<div class="dropdown">
    <button class="btn btn-default dropdown-toggle" data-toggle="dropdown">
        Menú <span class="caret"></span>
    </button>
    <ul class="dropdown-menu">
        <li><a href="#">Primera opción</a></li>
        <li><a href="#">Segunda opción</a></li>
        <li class="hz">
            <a href="#">Opción A</a>
            <a href="#">Opción B</a>
        </li>
        <li><a href="#">Última opción</a></li>
    </ul>
</div>

Consideraciones adicionales¶

Espaciado entre enlaces¶

.hz a {
    margin-right: 10px;
}
.hz a:last-child {
    margin-right: 0;
}

Responsive¶

@media (max-width: 768px) {
    .open > ul > li.hz {
        display: block !important;
    }
}

¿Cuándo usarlo?¶

Acciones relacionadas (Editar/Eliminar)
Opciones binarias (Sí/No, Activar/Desactivar)
Navegación compacta en espacios reducidos

Esta técnica mantiene la semántica HTML correcta mientras aprovecha la flexibilidad de flexbox para layouts más complejos.

Fuente original: Stack Overflow

Galen Framework: Testing automatizado para diseño responsive

2015-11-13T18:20:00+01:00

Galen Framework es una herramienta de testing automatizado diseñada específicamente para probar diseños web responsivos. Su propósito principal es simplificar las pruebas de layout verificando el posicionamiento y apariencia de elementos web en diferentes tamaños de dispositivo.

Características principales¶

Testing de layout inteligente¶

"Layout testing seemed always a complex task. Galen Framework offers a simple solution: test location of objects relatively to each other on page."

Soporte responsive completo¶

Redimensionado automático del navegador a tamaños definidos
Testing cross-device en múltiples resoluciones
Verificación de reglas específicas por pantalla

Sintaxis humana y flexible¶

header
    width: 100% of screen/width
    height: 50px

sidebar
    below: header
    width: 200px
    left-of: content 10px

Capacidades avanzadas¶

Compatibilidad con Selenium Grid
Testing visual con comparación de imágenes
Verificación de esquemas de color
Reportes HTML detallados con errores destacados

Soporte multi-lenguaje¶

Tests escritos en: - JavaScript - Java - Otros lenguajes con parametrización integrada

¿Por qué Galen?¶

Antes de Galen, el testing de layouts era complejo y propenso a errores. Galen introduce:

Sintaxis declarativa fácil de leer
Verificación relacional entre elementos
Testing responsive nativo
Reportes visuales comprensibles

Caso de uso típico¶

// Abrir navegador, redimensionar y probar
test("Homepage on mobile", function() {
    var driver = createDriver();
    driver.get("http://example.com");
    driver.manage().window().setSize(375, 667);
    checkLayout(driver, "homepage-mobile.spec");
});

Galen democratiza el testing de diseño responsive, haciendo que las pruebas de layout sean tan fáciles como las pruebas funcionales.

Framework open source: Galen Framework (Apache License 2.0)

La historia detrás de X-Forwarded-For y X-Real-IP

2015-10-21T23:05:00+02:00

Determinar la IP real del cliente en arquitecturas con proxies es más complejo de lo que parece. Los headers X-Forwarded-For y X-Real-IP tienen diferentes propósitos y limitaciones.

X-Forwarded-For: La cadena completa¶

Formato y propósito¶

X-Forwarded-For: client, proxy1, proxy2

Rastrea la IP original del cliente a través de múltiples saltos
Acumula IPs conforme pasa por proxies
No es obligatorio para todos los proxies

Limitaciones críticas¶

⚠️ Fácilmente falsificable: Un cliente puede añadir IPs falsas
⚠️ Potencialmente no confiable para determinar la IP real

X-Real-IP: El enfoque directo¶

Características¶

Menos documentación oficial disponible
Comúnmente usado junto con X-Forwarded-For
Enfoque más simple para pasar la IP del cliente

Limitación¶

"Not many good info or specs about this one" - No hay estándares definitivos

Configuración Nginx recomendada¶

Para extraer la IP más precisa:

# Configurar proxies conocidos
set_real_ip_from 10.0.0.0/8;
set_real_ip_from 172.16.0.0/12;
set_real_ip_from 192.168.0.0/16;

# Activar procesamiento recursivo
real_ip_recursive on;

# Usar X-Forwarded-For como fuente
real_ip_header X-Forwarded-For;

El desafío real¶

Determinar la IP "real" del cliente es inherentemente complejo debido a:

Múltiples saltos de red
Proxies no cooperativos
Potencial spoofing de IP
Lack de estándares uniformes

Buenas prácticas¶

Validar fuentes confiables de headers
Configurar correctamente proxies conocidos
No confiar ciegamente en headers de cliente
Implementar logging para debugging

La confiabilidad real depende más de tu arquitectura de red que de los headers específicos utilizados.

Fuente original: Distinct Place

Nginx: Configurar X-Forwarded-For en reverse proxy

2015-10-21T23:05:00+02:00

Cuando usas Nginx como reverse proxy, necesitas que el servidor backend vea la IP real del cliente, no la IP del proxy. El header X-Forwarded-For resuelve este problema.

El problema¶

Sin configuración, el servidor backend solo ve la IP del proxy Nginx, perdiendo información crucial sobre el cliente real para: - Logs de acceso precisos - Geolocalización correcta
- Rate limiting por IP real - Análisis de tráfico fidedignos

Solución 1: IP simple¶

proxy_set_header X-Forwarded-For $remote_addr;

Uso: Cuando Nginx es el único proxy en la cadena.
Resultado: Header contiene solo la IP del cliente original.

Solución 2: Cadena de IPs¶

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

Uso: Cuando hay múltiples proxies en la cadena.
Resultado: Conserva IPs existentes y añade la actual.

Configuración práctica¶

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend-server;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Headers relacionados¶

X-Real-IP: IP del cliente más reciente
X-Forwarded-For: Cadena completa de IPs
X-Forwarded-Proto: Protocolo original (http/https)
Host: Hostname original

Verificación¶

# En el servidor backend, verifica los headers
tail -f /var/log/apache2/access.log
# O en tu aplicación
echo $_SERVER['HTTP_X_FORWARDED_FOR'];

Consideraciones de seguridad¶

⚠️ Importante: Los headers X-Forwarded-* pueden ser falsificados por clientes. En entornos de producción, asegúrate de que solo tu proxy los establezca.

Esta configuración es esencial para mantener trazabilidad completa en arquitecturas con reverse proxy.

Fuente original: Networking How To's

SQL: Seleccionar filas con valor máximo por grupo

2015-10-21T23:05:00+02:00

Un problema común en SQL: ¿cómo seleccionar las filas completas que contienen el valor máximo de una columna para cada grupo? No solo el valor máximo, sino la fila entera.

El problema¶

Dado una tabla con id y rev (revisión), queremos obtener la fila completa con la rev más alta para cada id.

Solución 1: Subquery con IN¶

SELECT * 
FROM YourTable 
WHERE (id, rev) IN (
    SELECT id, MAX(rev)
    FROM YourTable
    GROUP BY id
)

Ventajas: Simple y legible
Desventajas: Puede ser lento en tablas grandes

Solución 2: Join con subquery¶

SELECT a.*
FROM YourTable a
INNER JOIN (
    SELECT id, MAX(rev) as maxrev
    FROM YourTable
    GROUP BY id
) b ON a.id = b.id AND a.rev = b.maxrev

Ventajas: Mejor rendimiento que IN
Desventajas: Más verboso

Solución 3: Window Functions (MySQL 8+)¶

SELECT *
FROM (
    SELECT id, rev, 
    ROW_NUMBER() OVER (PARTITION BY id ORDER BY rev DESC) ranked_order
    FROM YourTable
) a
WHERE a.ranked_order = 1

Ventajas: Más eficiente para datasets grandes
Desventajas: Requiere versiones modernas de SQL

Consideraciones de rendimiento¶

Window functions suelen ser las más eficientes
Joins balancean legibilidad y rendimiento
Subqueries con IN son las más simples pero menos escalables

¿Cuándo usar cada una?¶

Subquery: Tablas pequeñas, código simple
Join: Balance entre rendimiento y compatibilidad
Window functions: Datasets grandes, SQL moderno disponible

El patrón más robusto y moderno son las window functions, que además permiten manejar empates y casos edge más elegantemente.

Fuente original: Stack Overflow

Repitiendo una función con hilos

2015-05-03T21:00:00+02:00

Tengo un servicio (con daemonocle del que ya hablaré otro día) corriendo todo el tiempo en una odroid c1. Consideré que era mejor controlar con hilos unas tareas periódicas que tengo que repetir (que ya estaba usando) en lugar de la típica entrada en cron.

Así puedo contrar mejor el funcionamiento de las mismas. Las ventajas para mí en este caso y para estas tareas concretas:

Ya tengo la configuración de logging realizada por el proceso principal. Estas tareas dejan su info en mis log rotacionales.
Parando (arrancando) el servicio lo paro todo y a la vez.
Mido el consumo de recursos en su conjunto

Dejo el snippet utilizado.

En utils.py:

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import threading


class RepeatedTimer(object):

    def __init__(self, interval, function, *args, **kwargs):
        self._timer = None
        self.interval = interval
        self.function = function
        self.args = args
        self.kwargs = kwargs
        self.is_running = False
        self.start()

    def _run(self):
        self.is_running = False
        self.start()
        self.function(*self.args, **self.kwargs)

    def start(self):
        if not self.is_running:
            self._timer = threading.Timer(self.interval, self._run)
            self._timer.start()
            self.is_running = True

    def stop(self):
        self._timer.cancel()
        self.is_running = False

En main.py podeís ver su uso, una de las funciones recibe un parámetro:

setup_logging()
youtube = youtube_api.get_authenticated_service(None)
events_thread = RepeatedTimer(UPDATE_EVENTS_SECONDS, backend_api.update_events_database)
streams_thread = RepeatedTimer(UPDATE_STREAM_SECONDS, youtube_api.update_streams_database, youtube)

Deciros que paro estos hilos y limpio recursos en el evento de callback para shutdown que es de lo mejor de daemonocle. Ya sabéis que python no es capaz de paralelizar del todo los hilos debido a al GIL, pero para tareas simples como estas con muy poca carga es simple y funciona a la perfección.

Instalar InSync en Opensuse

2015-04-20T18:18:00+02:00

Llevo varios dias probando insync y creo que lo voy a pagar con gusto.

Me he descargado dos paquetes, uno para el menu contextual de dolphin y otro (el de fedora) para el propio programa en sí:

20:39 $ rpm -qa | grep insync
insync-1.2.7.35123-fc20.x86_64
insync-dolphin-1.2.7.35123-fc17.noarch

Todo funcionando perfectamente en mi opensuse

NetHogs ver ancho de banda consumido

2015-04-16T11:37:00+02:00

Para medir el ancho de banda que estoy utilizando en este momento utilizo NetHogs

Por defecto busca una interfaz de red llamada "eth0" si no la encuenta se queja así:

ioctl failed while establishing local IP for selected device eth0. You may specify the device on the command line.

Puedes ver tu configuración de red con el comando ip:

$ ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: wlp3s0: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default qlen 1000
    link/ether 84:3a:4b:50:14:cc brd ff:ff:ff:ff:ff:ff
3: enp0s25: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 3c:97:0e:77:76:d3 brd ff:ff:ff:ff:ff:ff
    inet 192.168.1.39/24 brd 192.168.1.255 scope global dynamic enp0s25
       valid_lft 28955sec preferred_lft 28955sec
    inet6 fe80::3e97:eff:fe77:76d3/64 scope link
       valid_lft forever preferred_lft forever

Como podéis ver en mi equipo tengo dos interfaces (aparte de la de loopback) que son enp0s25 (mi tarjeta de red con cable) y la wifi wlp3s0, en la que estoy conectado ahora que es la que voy a usar (podría listar las dos).

De forma que ejecutando:

$ sudo nethogs enp0s25

Puedo ver los procesos que están consumiendo más ancho de banda.

La ayuda del comando es:

20:02 $ nethogs -h
usage: nethogs [-V] [-b] [-d seconds] [-t] [-p] [device [device [device ...]]]
                -V : prints version.
                -d : delay for update refresh rate in seconds. default is 1.
                -t : tracemode.
                -b : bughunt mode - implies tracemode.
                -p : sniff in promiscious mode (not recommended).
                device : device(s) to monitor. default is eth0

When nethogs is running, press:
 q: quit
 m: switch between total and kb/s mode

Cierra Google Code

2015-03-13T17:11:00+01:00

Lo dicho, Google anunció el cierre de Google Code.

Hoy mismo recibí el correo avisandome (tenía un proyecto de prueba alojado allí) de que podía mover mis proyectos de forma simple a github, el repositorio de facto hoy en día del software libre (lo siento por bitbucket y sobre todo por mercurial).

Su interfaz nunca fue la más amigable, ni tampoco consiguió gran popularidad pero todavía quedan proyectos interesantes en Google Code que supongo que pasarán a github o morirán para simpre.

pgcli el descubrimiento de hoy

2015-03-02T08:26:00+01:00

Leyendo mis feeds RSS acabo de dar con una herramienta muy útil. Se trata de pgcli que no es más que una interfaz de línea de comandos para Postgres con autocompletado y resaltado de sintáxis. Como soy de usar la consola con las bases de datos, y postgres siempre es mi primera elección, me biene de perlas. with auto-completion and syntax highlighting

Yo recommiendo instalarla mediante pipsi.

Reactivando el blog

2015-02-20T21:40:00+01:00

Después de casi mucho tiempo inactivo (incluso offline) he decido que es el momento de relanzar este blog para lo de siempre: como bloc de notas.

He recuperado un fichero dump sql que tenía como copía de seguridad (desfasada eso sí) y con un pequeño script he creado este blog que ahora pasa a funcionar con Pelican (abandona Wordpress) y a alojarse en github pages.

Decorador vista ajax

2014-11-21T11:12:00+01:00

Para obligar que una vista django sea llamada sólo mediante llamamas AJAX.

def ajax_required(f):
    """
    AJAX request required decorator
    use it in your views:

    @ajax_required
    def my_view(request):
        ....

    """
    def wrap(request, *args, **kwargs):
        if not request.is_ajax():
            return HttpResponseBadRequest()
        return f(request, *args, **kwargs)
    wrap.__doc__ = f.__doc__
    wrap.__name__ = f.__name__
    return wrap

Un posible ejemplo de uso:

@login_required
@ajax_required
def update_starts(request):
    ...
    return JsonResponse({'result': 'ok'})

Función genérica para usar como upload_to

2014-10-11T11:02:00+02:00

Los FileField en django necesitan ana función upload_to que determine donde se subirá el fichero. Yo suelo tener en utils.py una función genérica que los deja en una subcarpeta con el nombre del modelo.

import os

def generic_upload_to(instance, filename):
    """
    Generic `upload_to` function for models.FileField and models.ImageField
    which uploads files to `<app_label>/<model_name>/<file_name>`.
    """
    return os.path.join(instance._meta.app_label, instance._meta.model_name, filename)

El uso el previsible:

featured_image = ImageField(upload_to=generic_upload_to,
                            verbose_name='Imagen Destacada (770x490)',
                            max_length=250, blank=True, null=True)

Django: enlaces en listado de objectos

2014-05-21T10:42:00+02:00

En mis proyectos suelo usar enlaces a elementos relacionados en el change_list del admin.

Ficheros

utils.py
admin.py

utils.py

Tengo esto en utils.py

from django.contrib import admin
from django.contrib.contenttypes.models import ContentType
from django.core import urlresolvers
from django.utils.datastructures import SortedDict
from django.utils.functional import memoize

def get_change_url(obj):
    """ Utility method
        def server_link(self, obj):
             return self.get_change_url(obj.server)
        server_link.short_description = _('server')
        server_link.allow_tags = True
        server_link.admin_order_field = 'server__name'
    """
    if obj is None:
        return
    content_type = get_content_type(obj.__class__)

    change_url = urlresolvers.reverse(
        "%s:%s_%s_change" % (admin.site.app_name, content_type.app_label, content_type.model),
        args=[obj.pk])
    return '<a href="%s">%s</a>' % (change_url, obj)


def _get_content_type(klass):
    return ContentType.objects.get_for_model(klass)
get_content_type = memoize(_get_content_type, SortedDict(), 2)

Hago uso de memoize para aumentar la eficiencia. Creo que es el punto junto entre simplicidad en el código con facilidad de uso. He tenido también decoradores para repetir menos en el admin.py pero cuando otros veían el código no lo entendían a la primera.

admin.py

Un ejemplo de uso: en admin.py (suponiendo que el modelo Link tiene un FK llamado product):

from utils import get_change_url

class LinkAdmin(AdminImageMixin, admin.ModelAdmin):
    list_display = ['name', 'is_visible', 'product_link', 'updated_at']
    search_fields = ['name', ]

    def product_link(self, obj):
        return get_change_url(obj.product)
    product_link.short_description = 'Product'
    product_link.allow_tags = True
    product_link.admin_order_field = 'product__name'

Settings vars processor

2014-01-08T11:23:00+01:00

Lo suelo usar durante el principio de los proyectos.

from django.conf import settings as django_settings
from django.core.exceptions import ImproperlyConfigured


def settings(request):
    """
    Adds the settings specified in settings.TEMPLATE_VISIBLE_SETTINGS to
    the request context.
    """
    new_settings = {}
    for attr in django_settings.TEMPLATE_VISIBLE_SETTINGS:
        try:
            new_settings[attr] = getattr(django_settings, attr)
        except AttributeError:
            m = "TEMPLATE_VISIBLE_SETTINGS: '{0}' does not exist".format(attr)
            raise ImproperlyConfigured(m)
    return new_settings

Se usa así:

TEMPLATE_CONTEXT_PROCESSORS = (
    'django.contrib.auth.context_processors.auth',
    ...
    'web.context_processors.settings',
)

DEBUG = True
CLIENT_SLOGAN = 'Esto es un ejemplo'
TEMPLATE_VISIBLE_SETTINGS = (
    'DEBUG',
    'CLIENT_SLOGAN'
)

pyinotify: Ejecutar comando cuando se modifica un fichero

2013-04-03T05:09:00+02:00

Ya he comentado por aquí un comando when-changed. Ahora anoto otra alternativa, esta vez python. Se trata de pyinotify. Yo lo uso para generar la documentación de sphinx mientras estoy escribiendo:

python -m pyinotify -r -c "make html" -e IN_MODIFY source

A vueltas con suse

2013-03-25T11:01:00+01:00

Algunos comandos de zypper para recordar: Para borrar un paquete y también las dependencias:

zypper remove  --clean-deps packate

Listar paquetes huérfanos:

LC_ALL=C zypper se -s | fgrep '(System Packages)'

Paso de ubuntu a suse

2013-02-01T02:17:00+01:00

En mi nuevo portátil del trabajo he pasado de Ubuntu a OpenSuse. Una distribución muy estable y sobre todo con el mejor soporte de KDE. Pero hay una cuantas cosas que nunca recuerdo. Como este blog se llama anotaciones...

Debian	OpenSuse
dpkg -S fichero	rpm -q -f fichero
dpkg -L paquete	rpm -q -l paquete
dpkg –purge –dry-run paquete	rpm -q –whatrequires paquee

reducir recursos de KDE

2012-10-24T03:18:00+02:00

Mágnifica entrada que explica como acelerar un poco tu sistema kde: http://parduslife.com/2011/02/17/como-acelerar-el-entorno-de-escritorio-plasma-de-la-kde-sc/ No uso akonadi y siempre he querido pararlo. Así no tienes que hacer un

akonadictl stop

tras arrancar. http://mschlander.wordpress.com/2011/08/18/disable-akonadi-in-kde-sc-4-7/

Cambiar de lugar un virtualenv

2012-10-24T03:15:00+02:00

La opción --relocate no funciona bien. Lo mejor es usar virtualenv-tools.

Depurando Tomcat

2012-10-24T03:13:00+02:00

Se usa Java Platform Debuging Architecture JPDA https://confluence.sakaiproject.org/display/BOOT/Setting+Up+Tomcat+For+Remote+Debugging

Importar clave gpg. kgpg que gran programa

2012-10-24T02:22:00+02:00

        gpg --keyserver pgp.rediris.es --search-keys erevilla@yaco.es

gpg: buscando «erevilla@yaco.es» de hkp servidor pgp.rediris.es
(1) Ernesto Revilla Derksen (Yaco)
1024 bit DSA key 3E455F5A, creado: 2009-09-16
Keys 1-1 of 1 for "erevilla@yaco.es". Introduzca número(s), O)tro, o F)in > 1
gpg: solicitando clave 3E455F5A de hkp servidor pgp.rediris.es
gpg: clave 3E455F5A: clave pública "Ernesto Revilla Derksen (Yaco) " importada
gpg: no se encuentran claves totalmente fiables
gpg: Cantidad total procesada: 1
gpg: importadas: 1

kmail dice:
Mensaje firmado por erevilla@yaco.es (ID Clave: 0x4D76FA323E455F5A).
La firma es válida, pero no se conoce la validez de la clave.

Ver: http://www.gnupg.org/gph/en/manual/x56.html
Tengo que dar validez con una firma mía

pcaro@davinci$ gpg --edit-key 3E455F5A
gpg (GnuPG) 1.4.9; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

pub 1024D/3E455F5A creado: 2009-09-16 [caduca: 2011-09-16] uso: SC
confianza: desconocido validez: desconocido
sub 2048g/1AAA03F0 creado: 2009-09-16 [caduca: 2011-09-16] uso: E
desconocido (1). Ernesto Revilla Derksen (Yaco)

Orden> trust
pub 1024D/3E455F5A creado: 2009-09-16 [caduca: 2011-09-16] uso: SC
confianza: desconocido validez: desconocido
sub 2048g/1AAA03F0 creado: 2009-09-16 [caduca: 2011-09-16] uso: E
desconocido (1). Ernesto Revilla Derksen (Yaco)

Por favor, decida su nivel de confianza para que este usuario
verifique las claves de otros usuarios (mirando pasaportes,
comprobando huellas dactilares en diferentes fuentes...)

1 = No lo sé o prefiero no decirlo
2 = NO tengo confianza
3 = Confío un poco
4 = Confío totalmente
5 = confío absolutamente
m = volver al menú principal

¿Su decisión? 4

pub 1024D/3E455F5A creado: 2009-09-16 [caduca: 2011-09-16] uso: SC
confianza: total validez: desconocido
sub 2048g/1AAA03F0 creado: 2009-09-16 [caduca: 2011-09-16] uso: E
desconocido (1). Ernesto Revilla Derksen (Yaco)
Por favor, advierta que la validez de clave mostrada no es necesariamente
correcta a menos de que reinicie el programa.

http://www.fermu.com/content/view/231/2/lang,es/ http://www.rediris.es/pgp/


Generando mi propia clave:
pcaro@davinci$ gpg --gen-key
gpg (GnuPG) 1.4.9; Copyright (C) 2008 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor seleccione tipo de clave deseado:
(1) DSA y ElGamal (por defecto)
(2) DSA (sólo firmar)
(5) RSA (sólo firmar)
¿Su selección?: 1
El par de claves DSA tendrá 1024 bits.
las claves ELG-E pueden tener entre 1024 y 4096 bits de longitud.
¿De qué tamaño quiere la clave? (2048)
El tamaño requerido es de 2048 bits
Por favor, especifique el período de validez de la clave.
0 = la clave nunca caduca
= la clave caduca en n días
w = la clave caduca en n semanas
m = la clave caduca en n meses
y = la clave caduca en n años
¿Validez de la clave (0)? 3y
La clave caduca lun 29 oct 2012 12:01:25 CET
¿Es correcto? (s/n) s

Necesita un identificador de usuario para identificar su clave. El programa
construye el identificador a partir del Nombre Real, Comentario y Dirección
de Correo electrónico de esta forma:
"Heinrich Heine (Der Dichter)"

Nombre y apellidos: Pablo Caro Revuelta
Dirección de correo electrónico: pcaro@yaco.es
Comentario:
Ha seleccionado este ID de usuario:
Â«Pablo Caro RevueltaÂ»

¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? C
Comentario: pcaro
Ha seleccionado este ID de usuario:
Â«Pablo Caro Revuelta (pcaro)Â»

¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? V
Necesita una frase contraseña para proteger su clave secreta.

Es necesario generar muchos bytes aleatorios. Es una buena idea realizar
alguna otra tarea (trabajar en otra ventana/consola, mover el ratón, usar
la red y los discos) durante la generación de números primos. Esto da al
generador de números aleatorios mayor oportunidad de recoger suficiente
entropía.
++++++++++.++++++++++++++++++++.++++++++++...+++++++++++++++..++++++++++++++++++++++++++++++..+++++..++++++++++.+++++++++++++++.++++++++++++++++++++......>.+++++.................................+++++

No hay suficientes bytes aleatorios disponibles. Por favor, haga algún
otro trabajo para que el sistema pueda recolectar más entropía
(se necesitan 280 bytes más).

Es necesario generar muchos bytes aleatorios. Es una buena idea realizar
alguna otra tarea (trabajar en otra ventana/consola, mover el ratón, usar
la red y los discos) durante la generación de números primos. Esto da al
generador de números aleatorios mayor oportunidad de recoger suficiente
entropía.
+++++++++++++++.+++++.+++++++++++++++..+++++.+++++..++++++++++++++++++++..++++++++++++++++++++.+++++.++++++++++++++++++++...+++++.++++++++++++++++++++.+++++++++++++++..>..+++++........>+++++.+++++.+++++....................+++++.....................................................+++++............................+++++^^^
gpg: clave 4A52D5BA marcada como de confianza absoluta
claves pública y secreta creadas y firmadas.

gpg: comprobando base de datos de confianza
gpg: 3 dudosa(s) necesarias, 1 completa(s) necesarias,
modelo de confianza PGP
gpg: nivel: 0 validez: 1 firmada: 0 confianza: 0-, 0q, 0n, 0m, 0f, 1u
gpg: siguiente comprobación de base de datos de confianza el: 2012-10-29
pub 1024D/4A52D5BA 2009-10-30 [[caduca: 2012-10-29]]
Huella de clave = 483C F267 8A4B 0D27 3451 88A9 FE05 5E01 4A52 D5BA
uid Pablo Caro Revuelta (pcaro) sub 2048g/7436FA09 2009-10-30 [[caduca: 2012-10-29]]

programas graficos

sudo aptitude install kleopatra kgpg

Para que puedas enviar los correos firmados en kmail: http://randomguy3.wordpress.com/2008/07/24/kmail-trunk-signing/

Traducciones y APT

2012-10-24T02:20:00+02:00

http://mindref.blogspot.com.es/2012/10/apt-translations.html http://manpages.ubuntu.com/manpages/natty/man5/apt.conf.5.html

Mostrar Usuarios y roles existentes en postgres

2012-10-24T02:13:00+02:00

Se utiliza \du

$ sudo su - postgres
$ psql 
postgres=# \du
                           List of roles
 Role name |                   Attributes                   | Member of 
-----------+------------------------------------------------+-----------
 openerp   | Superuser, Create role, Create DB, Replication | {}
 postgres  | Superuser, Create role, Create DB, Replication | {}

postgres=#

Uso práctico de ngrep

2012-09-12T03:38:00+02:00

Ejemplo de uso común de ngrep:

sudo ngrep -d any port 80 -W byline

Esto es para examinar lo que circula por el puerto 80.

Autorelad en plone

2012-07-27T04:38:00+02:00

Otro recordatorio. Para recargar mientras desarrollo una browserview en plone:

$ when-changed.py *.py -c wget -q -O /dev/null  \
http://admin:admin@localhost:8080/@@reload?action=code

Basta pues con usar when-changed y plone.reload Se que existen extensiones para el navegador que recargan una pestaña cuando cambia un fichero, pero yo soy más de consola.

virtualbox: Actualizar las Guest Additions en máquinas ubuntu

2011-08-24T04:11:00+02:00

Si usas vagrant para gestionar máquinas virtuales con virtualbox, un buen lugar para obtener boxes es vagrantboxes. Pero a veces la versión que traen de las Guest Additions no coincide con el virtualbox que tienes (en mi caso el último). Vagrant se queja y puede ocasionar problemas. Lo más simple es arrancar la máquina en modo gráfico (config.vm.boot_mode = :gui en vagrant) e indicar en el menu de virtualbox en "Dispositivos" -> "CD/DVD" que se ponga VBoxGuestAddions.iso. Luego vasta con montar el cdrom y ejecutar el comando de instalación:

$ sudo mount -t auto /dev/cdrom /mnt
$ cd mnt
$ sudo ./VBoxLinuxAdditions.run

Puede que tengas de instalar dkms. Si el sistema no tiene sistema gráfico instalado (como en este caso), se quejará pero quedará instalado todo bien.

Cambiar mapa de teclado en linux

2011-08-24T03:59:00+02:00

Siempre olvido esto:

sudo keymap es

Deshabilitar autocompletado en vim

2011-06-20T04:42:00+02:00

Uso poco vim, sólo cuando en servidores no tengo jed. Para pegar texto en el fichero actual sin que te haga un horrible indentado en cascada:

:setlocal noautoindent
:setlocal nocindent
:setlocal nosmartindent
:setlocal indentexpr=

O su equivalente:

:setl noai nocin nosi inde=

Referencia: http://vim.wikia.com/wiki/How_to_stop_auto_indenting

Diccionario de español para komodo edit

2011-06-13T07:41:00+02:00

Para instalarlo se siguen estas instrucciones descargando previamente el addon. No he probado a ver si funciona en el perfil de usuario, pero eso estaría mejor.

21/3

2011-03-22T02:35:00+01:00

Han pasado ya tres días 21 en lo que llevamos de año. Ayer, fue un día de reivindicaciones, para exigir la visibilidad necesaria y el respecto que esta sociedad todavía niega. Cuando en el día de hoy se habla de guerra y emisiones radiactivas, yo he aprendido en este último año, que si gobernaran ellos no habría guerras, y que la sonrisa de un niño con el síndrome radia felicidad a Tera Sieverts por segundo. No se se afectará a la tiroides, pero os aseguro que se nota en el corazón.

scp con compresión

2011-03-04T03:49:00+01:00

La mejor forma de descargar una zodb:

scp -C -o CompressionLevel=9 user@yoursite.com:~/plonefolder/zinstance/var/filestorage/Data.fs .

Leído en: http://blog.mfabrik.com/2011/03/02/scp-file-copy-with-on-line-compression/

Actualizar Mercurial usando ppa en ubuntu

2011-02-25T05:12:00+01:00

Existen tres PPA para mercurial: https://launchpad.net/~mercurial-ppa/+archive/releases (última release, actualmente 1.7.5-0ppa1~maverick1) https://launchpad.net/~mercurial-ppa/+archive/stable-snapshots (snapshots de la rama estable, actualmente 1.7.5+2-5fc7c84ed9b0-0ppa1~maverick1) https://launchpad.net/~mercurial-ppa/+archive/snapshots (snapshots de lo último, actualmente 1.8~1.7.5+4-8f5c865b7b4a-0ppa1~maverick1) Como decía en la última anotación para añadir el PPA basta con:

$ sudo add-apt-repository ppa:mercurial-ppa/stable-snapshots
$ sudo aptitude update
$ sudo aptitude  install Mercurial

Añadiendo un repositio PPA en karmic

2011-02-23T07:22:00+01:00

Este comandito te añade sola la fuente (ojo, en el directorio /etc/apt/sources.list.d) y pide las claves:

sudo add-apt-repository ppa:chromium-daily

Dos pantallas al inicio de kdm

2011-02-01T02:32:00+01:00

Para que ya el mismo kdm se ejecute con dos pantallas basta con poner la configuración deseada (usando xrandr) en el fichero /etc/kde4/kdm/Xsetup. Por ejemplo, en mi caso uso dos pantallas en la oficina de modo que ese fichero contiene:

INT="LVDS1"
EXT="VGA1"
xrandr -q | grep -q "$EXT connected"   && {
xrandr --output $EXT --mode 1280x1024
xrandr --output $INT --mode 1280x800
xrandr --output $INT --bellow $EXT
xrandr --output $INT --primary
}

Estas lineas hacen que se consulte si tengo el segundo monitor conectado y en se caso se configure de la forma deseada.

Zen Coding y komodo edit

2010-10-15T14:41:00+02:00

Mi editor favorito Komodo Edit tiene un plugin de Zen Coding y este funciona muy bien también con plantillas zpt. Por ejemplo: Así una expresión como la siguente

dl>tal:rep[tal:repeat]>dt+dd

Se convierte en el siguiente trozo de html con los nesesarios tabstops:

Muy pero que muy cómodo

Progreso en un reindexado de zope

2010-09-18T06:06:00+02:00

Visto en el producto contentleadimage:

from Products.ZCatalog.ProgressHandler import ZLogHandler
ctool.reindexIndex(['hasContentLeadImage'], portal.REQUEST, pghandler=ZLogHandler())

Esto muestra un progreso en la consola si estás ejecutando en primer plano.

Zope y noatime

2010-07-25T05:33:00+02:00

Una fácil mejora para el rendimiento de un zope con problemas de acceso a disco es no actualizar la fecha de último acceso al fichero de la base de datos Data.fs:

chattr -R +A Data.fs

Simple y efectivo.

Subversion: Añadiendo contenido a un directorio sin descargarlo

2010-07-16T05:05:00+02:00

Caso práctico. Tengo un directorio dev dentro del subversión con un montón de código con sus correspondientes ramas de trunk, branches, tags, etc. Quiero añadir un nuevo producto pero no descargar todo ese enorme directorio dev:

svn co --depth empty https://repositorio/dev dev
cp loquesea nuevo_producto
svn add loquesea
svn ci

Gracias ctabasco por la anotación.

Restaurando objectos plone borrados

2010-07-14T01:33:00+02:00

Para esas situaciones donde no funciona el undo, la salvación se llama dm.historical Un claro ejemplo en esta entrada del Blog de Andreas Jung

Opciones típicas rsync

2010-07-08T05:56:00+02:00

Para usar un rsync como un scp (pero con las ventajas de rsync como que puedo parar y continuar después):

rsync -azPrv -e 'ssh' usuario@host:/path/to/folder /path/to/destination

Completar mientras se depura en zope

2010-04-28T03:33:00+02:00

Siempre tengo que buscar esto en google, para esto tengo el blog:

$ bin/instance debug

>>> import readline, rlcompleter
>>> readline.parse_and_bind('tab: complete')
>>> app.
Display all 760 possibilities? (y or n)
>>>

Kbabel es Lokalize en kde4

2010-03-25T10:41:00+01:00

Ya era la segunda vez que no encontraba el maravilloso kbabel y es que en kde4 su sucesor se llama lokalize

Descargar una web para visualización local con wget

2010-02-22T10:09:00+01:00

El comando es

$ wget -E -H -k -K -p  http://www.google.es

Con -p hacemos que se descarguen los enlaces requeridos (css, javascript), con -k convertimos los enlaces dentro del html para visualización local (-K copia de seguriad) y con -E aseguramos que los ficheros descargados tengan extensión html para la visualización en local.

Plone: Registrar pasos de importación con zcml

2010-01-27T04:38:00+01:00

Registrar un paso de importación con xml el el profile, puede fallar cuando quitas el paquete del buildout. Un paso roto se que queda dentro de portal_setup_tool. En algunas versiones de plone esto da un error, haciendo imposible aplicar el perfil nunca más. En otras versiones (plone 3.2 hacia arriba) sólo da un warning.

Esto es una traducción de un correo de Mauris Van Rees

Descargar código de un repositorio publicado con gitweb

2010-01-04T14:31:00+01:00

Quería probar un software disponible en la red (Perfect Sale). Sabía que tenía que usar git clone pero no la url.

No queda claro (al menos a mí) en el repositorio gitweb la url a usar.

Al fin, encontré la solución en un repositorio mejor documentado (gracias).

El protocolo es git y la url no incluye ese "projects" que vemos en el rastro de migas. Lo anoto para no volver a perder el tiempo otra vez.

Así que para el proyecto citado la orden queda así:

$ git clone git://git.hforge.org/shop.git

Crear base de datos mysql a partir de un backup

2009-12-17T05:06:00+01:00

Primero crear la base de datos:

pcaro@davinci$ mysql --user=root -p
mysql> show databases;
mysql> create database piwik;
mysql> GRANT ALL ON piwik.* TO pcaro@localhost IDENTIFIED BY "piwik"
mysql> show tables;

Luego restaurar el backup:

mysql --user=root --pass=*** --host=localhost piwik < piwik_Thursday.sql

Comprobar todo esta bien

pcaro@davinci$ mysql --user=root -p
mysql> show tables;

Parcheando, parcheando ...

2009-12-16T10:18:00+01:00

Siempre tengo que buscar cómo usar patch. Como tengo un blog que se llama anotaciones pues apunto:

$ patch -p1 < baz.diff

Donde el número 1 viene de mirar en el fichero .diff y contar las barras "/" que hay antes que el directorio donde estoy. Por ejemplo si veo /users/stephen/package/src/net/http.c y estoy en un directorio que contiene net/http.c pues es 5 (ojo, hay que contar la primera). Para referencia The Ten Minute Guide to diff and patch

Que las aplicaciones GTK+ luzcan mejor en kubuntu karmic

2009-12-10T06:32:00+01:00

Basta con seguir este tutorial, que indica como instalar el tema Oxygen-Molecule.

Añadir PPA desde la consola a ubuntu karmic

2009-12-09T03:18:00+01:00

Para añadir un PPA a ubuntu karmic desde la consola basta con:

 sudo add-apt-repository ppa:kubuntu-ppa/ppa

[sudo] password for pcaro:                                
Executing: gpg --ignore-time-conflict --no-options --no-default-keyring --secret-keyring /etc/apt/secring.gpg --trustdb-name /etc/apt/trustdb.gpg --keyring /etc/apt/trusted.gpg --keyserver keyserver.ubuntu.com --recv E4DFEC907DEDA4B8A670E8042836CB0A8AC93F7A                                                                                  
gpg: solicitando clave 8AC93F7A de hkp servidor keyserver.ubuntu.com                                             
gpg: clave 8AC93F7A: clave pública "Launchpad Kubuntu Updates" importada                                         
gpg: no se encuentran claves totalmente fiables                                                                  
gpg: Cantidad total procesada: 1                                                                                 
gpg:

Cambiar dpi en kde

2009-12-04T05:35:00+01:00

Siempre que reinstalo me encuentro con el mismo problema. No tengo el dpi estándar de 96, sino uno extraño de 113.

pcaro@davinci$ xdpyinfo | grep resolutio
  resolution:    113x113 dots per inch

Como resultado, muchas páginas webs no se visualizan correctamente. Para solucionarlo tengo que decirle al servidor X que arranque con un dpi predeterminado. Eso lo hago en los ficheros de configuración de kdm que es el encargado de ejecutar el servidor. Concretamente en /etc/kde4/kdm/kdmrc. Basta con indicar al servidor X qué valor de dpi usar. Para ello usamos la opción -dpi.

# This string is subject to word splitting.
# Default is ""
ServerArgsLocal=-br -nolisten tcp -dpi 96

Eso es todo. Reiniciar las X y listo. PD: No se el motivo pero el nuevo dpi y mi tarjeta gráfica intel integrada, yo tengo mucho mejor rendimiento en la aceleración gráfica.

Actualizando postgres en debian y derivados

2009-11-26T05:19:00+01:00

Siempre que se habla de debian, se alaba su paquetería. Y yo estoy de acuerdo de que es uno de los puntos fuertes de la distribución. Hoy me refiero a la facilidad de tener instaladas y conviviendo felices varias versiones de la base de datos postgres. Ya comenté esto en su momento en Instalar postgres 8.2 en jaunty. Pues el tener dos servidores instalados a la vez, permite la fácil migración de un versión a otra del motor de base de datos. En este caso detallo como migré las bases de datos de mi equipo ubuntu karmic de postgres 8.3 a 8.4.

Primero tener instalados los dos paquetes: postgresql-8.3 y postgresql-8.4.
Determinar en que puerto se ejecuta cada instancia. Esto lo podemos hacer mirando los ficheros /etc/postgresql/8.X/main/postgresql.conf (variable port). En mi caso 5482 y 5433 respectivamente. Lo puedes comprobar con:
```
$ sudo netstat -putan | grep postgres
```

Después lanzar los dos servidores:

$ sudo /etc/init.d/postgresql-8.3 start
$ sudo /etc/init.d/postgresql-8.4 start

Finalmente copiar los datos de una versión a otra

$ sudo su - postgres
$ pg_dumpall -p 5432 | psql -d postgres -p 5433

Probar que todo ha ido correctamente

Añadiendo lenguaje procedural a base de datos postgres: createlang

2009-11-12T05:20:00+01:00

Postgres 8.3 incluye 4 lenguajes procedurales en la distribución y se pueden instalar más, pero hay que activarlos por base de datos. Para ello, hay varios métodos (lo clásico es create language) pero los más cómodo es usar createlang. Usa droplang para eliminar el lenguaje.

Colores desde web developer tools

2009-11-10T04:55:00+01:00

Últimamente uso tanto firebug que ni me acuerdo de las Web Developer Tools. Escribo esto para recordar que sigue siendo muy útil esta extensión. Por ejemplo, puedo ver los colores (css) usados en una página web a través del menú Información, seleccionando Ver información del color.

Que apache sirva el contenido de un fichero .py

2009-10-13T05:36:00+02:00

Para que el servidor apache de webfaction no intentara ejecutar los scripts python que dejo para la descarga en este blog, me creé un fichero .htaccess y dentro:

removeHandler cgi-script .pl .py .cgi

Cambiar pantalla anunciadora de kde: Ksplash theme generator

2009-09-20T08:22:00+02:00

Lo dicho en la nota anterior sobre KDM Theme Generator aplica también para su aplicación hermana Ksplash theme generator

Cambiar el aspecto de kdm: kdm theme generator

2009-09-20T08:07:00+02:00

KDM Theme Generator es una de esas aplicaciones simples y sencillas (sin interfaz gráfica siquiera), con una utilidad concretísima pero que funciona tan bien que da gloria de usar. Siguiendo las instrucciones de instalación, te crea un tema para KDM basado en el tema plasma activo y tu fondo de escritorio actual. De esta forma tan simple mejorarás visualmente el arranque de tu kde.

Cambiar la codificación de un fichero de texto

2009-07-27T11:19:00+02:00

Una nota para recordar el comando iconv:

iconv -f fromEncoding -t toEncoding inputFile > outputFile

CSS: Estilos de selección de texto

2009-07-09T03:57:00+02:00

Una de esas declaraciones de CSS3 que ya aceptan muchos navegadores actuales es ::selection. Se puede utilizar así:

p::selection {
	background: #ccaacc; /* Safari */
	}
p::-moz-selection {
	background: #ccaacc; /* Firefox */
}

Manejo de árboles en bases de datos

2009-07-07T16:59:00+02:00

Hay cuatro formas de guardar árboles en bases de datos relacionales:

Adjacency List
Materialized Paths
Nested Sets o Modified Preorder Tree Traversal (MPTT)
Nested intervals

Dejo unos enlaces:

Trees in SQL: Nested Sets and Materialized Path El articulo y el hombre de referencia
Storing Hierarchical Data in a Database Todo muy clarito con muy buenos ejemplos
Mysql: datos jerárquicos Explicación clara y general
Materialized Path + Nested Sets Una forma de mezclar estos dos metodos

Algunas implentacionaciones:

sqlamp — Materialized Path for SQLAlchemy
Django Treebeard Adjacency List, Materialized Path y Nested Sets para django
django-mptt

Mostrar el código de funciones en postgres

2009-07-07T11:18:00+02:00

Puede resultar muy util ver el código de algún procedimiento almacenado en postgres. El código de a continuación tomado de Postgresql General Bits de A. Elein Mustain puede resultar muy útil.

create or replace view showfunctions as
select
l.lanname,
t.typname || ' = ' || n.nspname || '.' ||
    p.proname || '(' || pg_catalog.oidvectortypes(p.proargtypes) || ')'
as function_definition,
(select case when lanname <> 'c'
    then '\n\n'||prosrc ||'\n\n'
    else '\n'||prosrc ||'.so\n\n'
end) as source
from pg_proc p, pg_type t, pg_namespace n, pg_language l
where p.prorettype = t.oid and p.pronamespace = n.oid
    and p.prolang = l.oid;

-- Muestra todas las funciones en el schema public ( y cualquier funcion con
-- public en su nombre)
select * from showfunctions where function_definition like '%public%';

-- Muestra todas las funciones que toman o reciben booleanos
select * from showfunctions where function_definition like '%boolean%';

Instalar postgres 8.2 en jaunty

2009-06-30T10:52:00+02:00

Postgres 8.3 no me permitía crear una base de datos con un encoding distinto a los instalados en mi maquina, y yo debía recuperar una copia de seguridad de una base de datos para la ampliación de unos trabajos que vienen de antiguo. Si intentaba importar los datos fallaba por el encoding:

# createdb base_datos  -O owner ; 
# pg_restore -F c -d base_datos   viernes-27-feb-2009.dump
pg_restore: [archiver (db)] COPY failed: ERROR:  secuencia de bytes no válida para codificación «UTF8»: 0xa2

Y además no me dejaba crear la base de datos con el encoding correcto:

postgres@davinci$ createdb  base_datos -E latin1
createdb: falló la creación de la base de datos:
ERROR:  la codificación LATIN1 no coincide con la configuración regional del servidor es_ES.UTF-8
DETAIL:  La configuración regional LC_CTYPE del servidor requiere la codificación UTF8.

Para poder seguir adelante dos alternativas: cambiar el encoding de mi base de datos (no podía porque tengo otras bases de datos) o instalar postgres 8.2 (debian y derivados permiten tener varios postgres a la vez por paquetería) De esta forma que me dispuse a descargar los paquetes de haunty: postgresql-8.2 y postgresql-client-8.2 Una vez descargados los paquetes bastó:

pcaro@davinci$ sudo dpkg -i postgresql-client-8.2_8.2.7-1_i386.deb
pcaro@davinci$ sudo dpkg -i postgresql-8.2_8.2.7-1_i386.deb
sudo aptitude hold postgresql-client-8.2
sudo aptitude hold postgresql-8.2

Luego puedes configurar los postgres para que escuchen en distintos puertos o, si solo lo necesitas de forma temporal como yo, simplemente parar el 8.3 y levantar el 8.2 cuando sea necesario. PD: Gracias a Antonio por la ayuda.

Listar las bases de datos postgres que tengo instaladas

2009-06-29T03:54:00+02:00

Para ello:

pcaro@davinci$ sudo /etc/init.d/postgresql-8.3 start
pcaro@davinci$ sudo su - postgres
postgres@davinci:~$ psql -l

Un servidor web de bolsillo gracias a python

2009-06-16T10:31:00+02:00

Otra cosita para recordar. La forma más simple de servir unos ficheros vía web:

python -m SimpleHTTPServer 8080

Nota: Antes usaba:

python -c "import SimpleHTTPServer;SimpleHTTPServer.test()"

Pero no permite indicar el puerto y es más tedioso de escribir.

Convertir filtros de kmail a filtros sieve

2009-06-06T14:13:00+02:00

No hace mucho que dejé de usar POP en mis correos para pasarme al IMAP desconectado de kmail con toda las ventaja que ello supone. Pero todavía seguía utilizando los mismos filtros en kmail que me ordenan los correos por carpeta. Con este sistema el filtrado se realiza una vez descargado el correo, de forma que, ahora con imap, el kmail tiene que pasar los filtros y actualizar las carpetas en el servidor tras el moviento de correos. Desde luego no es lo más conveniente. Lo más util que el filtrado del correo se realice en el servidor. De esta forma nuestro correo ya se encuentra organizado accedas con el cliente que accedas al correo (webmail, móviles de última generación, etc). Para ello existen los filtros sieve. Pero yo ya tenía mis filtros en kmail, de forma que me hice un pequeño programita python que convirtiera mis filtros de kmail en un fichero con los filtros sieve. No discrimina entre cuentas y solo esta probado (y funciona) con mis filtros simples de moviento de correo, pero lo dejo aquí por si a alguien pudiera resultarle de utilidad. Para usarlo:

Guardar los filtros de kmail (Preferencias -> Configurar filtros -> Exportar) en un fichero (por ejemplo filtros_pcaro.ini)
Ejecutar python kmail_to_sieve.py filtros_pcaro.ini > filtros.sieve Por la salida de error indicará que no ha podido convertir.
Examinar filtros
Subir y activar desde el mismo kmail (Preferencias -> Gestionar guiones de Sieve.

Podeís descargarlo desde aquí: kmail_to_sieve PD: Arreglado el enlace. Gracias Helder por avisar.

Contenedor de Floats: How to IE & FF

2009-05-21T10:41:00+02:00

Espero no olvidar esto más así que dejo la notita. Si tienes un elemento (por ejemplo un div#padre), que contiene sólo flotantes (otros divs por ejemplo), no será capaz IE de calcular bien su tamaño (se ve muy claro con un background). Para que funcione con explorer y firefox la regla es ponerle al elemento contenedor las reglas css:

div#padre {
  overflow: hidden;
  zoom:1;
}

la regla del zoom es para aplicar el hasLayout en el ie6. No es estándar y es mejor ponerla en un condicional para este navegador. Nota personal: Pablo olvida el div con el clear:both que en este caso no es solución.

Comandos útiles en la consola de postgres (pgsql)

2009-03-30T06:04:00+02:00

Otra de las cosas que simpre olvido. Así que lo anoto. Para sacar el resultado de una consulta sql a un fichero desde el pgsql.

\a
\f ,
\o /tmp/salida.csv
select * from ...

Se trata de:

Cambiar entre modo de salida alineado y sin alinear
Definir separador de campos (en el ejemplo a una coma)
Envíar resultados de consultas a archivo
Ejecutar la consulta

Cambiar ipython para copiar y pegar luego como doctest

2009-02-02T04:23:00+01:00

Otra de las ordenes que nunca recuerdo. Estando dentro de ipython para cambiar el prompt de forma que luego sea fácil crear doctests: %doctest_mode Esto entra en el modo doctest de ipython. También puede ayudar %history -tnpara recordar los commandos introducidos previamente.

Importar claves gpg de repositorios ubuntu

2009-02-01T13:00:00+01:00

Ante un error como este: W: GPG error: http://ppa.launchpad.net intrepid Release: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 3B81A3FBA47394CE Hay que importar las claves:

gpg --keyserver keyserver.ubuntu.com --recv 3B81A3FBA47394CE
gpg --export --armor 3B81A3FBA47394CE | sudo apt-key add -

UPDATE:
Corregido el tema de los guiones, gracias a miguelbf por la indicación y perdón por la tardanza en arreglarlo

Formatear de la forma más fácil una tarjeta SD en ubuntu

2009-01-30T13:44:00+01:00

Otra anotación para recordar en un futuro. La forma más fácil de formatear una tarjeta SD es:

Identificar el dispositivo (si esta montada la tarjeta lo ves con el comando mount por ejemplo).
Si no lo tienes ya, instalar el paquete dosfstools.
Ejecutar (con el dispositivo desmontado): sudo mkdosfs DISPOSITIVO.

Siempre el último Dragonfly en Opera

2009-01-30T08:45:00+01:00

Para tener la versión de desarrollo de dragon fly en el opera basta con seguir la ruta: about:config -> Developer Tools -> Developer Tools url Luego, introducir la url siguiente http://dragonfly.opera.com/app/cutting-edge/

Feliz Navidad

2008-12-24T05:38:00+01:00

Ni árboles, ni reyes, ni trineos, simplemente eso, Feliz Navidad de corazón para todos.

La potencia de los permisos

2008-12-01T14:06:00+01:00

Recordar los comandos para controlar las listas de control de acceso en linux.

man setfacl
man getfacl

Tras "setfacl -m user:joe:rwx dir", verás que ls -d dir muestra un signo + al final que indica que se están utilizado permisos ampliados. Si quieres saber más, el tío google te lo dirá.

Usar find para detectar enlaces simbólicos rotos

2008-11-20T11:30:00+01:00

for f in $(find /usr/local/bin -type l); do if [ ! -e "$f" ]; then echo $f; fi; done

¿Cómo hacer un "svn export" con git?

2008-11-14T05:04:00+01:00

Si tienes que descargarte un árbol git pero sin los metadatos, porque por ejemplo sólo quieres el código para congerlarlo versionado en el subversion de tu proyecto, lo más fácil es: git clone {clone-url} rm -rf .gitignore .git

svn:ignore

2008-11-13T03:59:00+01:00

Esta entrada es para recordar los dos comandos: svn propedit svn:ignore ./some_path svn -R propset svn:ignore -F ../.svnignore . donde .svnignore contiene un patron por línea como *.pyc

Reproducir flash con Opera en Ubuntu

2008-11-12T13:47:00+01:00

Traducción de un comentario. A menudo Opera no pude encontrar el reproductor de flas sin tu ayuda. Te mostramos lo que puedes hacer. Primero, asegurate que flash está instalado y funciona en firefox. Una vez confirmado, abre un terminal: $ cd ~/.opera En este directorio verás un archivo denominado pluginpath.ini... el nombre lo dice todo. En la configuración por defecto, están las entradas: -- ; Do not edit this file while Opera is running ; This file is stored in UTF-8 encoding [Paths] /usr/lib/opera/plugins=1 /usr/lib/mozilla/plugins=1 -- Deberías tener en cuente el aviso y cerrar tu Opera si todavía lo tienes abierto (usa firefox o imprime para ver esta página) A partir de ahora tienes dos opciones: Configurar las librerías flash en cualquiera de las dos rutas indicadas arriba o Añadir otra línea a pluginpath.ini file de forma que opera también encuentre las librerías del directorio local del usuario que usa mozilla. Usaremos la segunda aproximación. Abre una segunda consola y cambia al directorio de plugins de mozilla. $ cd ~/.mozilla/plugins/ Una vez aquí, deberías ver (al menos) dos archivos cuyos nombres son fashplayer.xpt y libflashplayer.so. Son los archivos que Opera necesita para ejecutar flash. Supongamos que tu nombre de usuario es "qwerty". Añade la siguiente linea al final del archivo pluginpath.ini en el directorio ~/.opera: /home/qwerty/.mozilla/plugins=1 Arranca opera de nuevo y no deberías de tener problemas con flash. Esta solución funciona sólo para tí y necesetaría ser repetida para todos los usuarios de la máquina en cuestion. Date cuenta que la opción número 1. habilita a TODOS los usuarios para usar flash en opera. Para hacer esto necesitas colocar los dos archivos mencionados arriba en /usr/lib/opera/plugins o /usr/lib/mozilla/plugins. Pudes hacer esto directamente copiándolos usando cp or creando enlaces simbólicos a losby making symbolic links a los archivos en en tu directorio ~/.mozilla/plugins. En este último caso cuida de los permisos.

Varios monitores en linux

2008-11-10T03:27:00+01:00

Esta anotación es sólo para comentar el comando xrandr que uso en kubuntu intrepid para trabajar con dos monitores. sudo xrandr --output VGA --auto sudo xrandr --output VGA --above LVDS

Compartir ficheros gracias a python

2008-11-08T16:10:00+01:00

Para compartir de forma rápida unos ficheros vía web graias a python, lo más fácil es:

python -c "import SimpleHTTPServer;SimpleHTTPServer.test()"

Error con setuptools y subversion 1.5

2008-09-14T13:50:00+02:00

La actual versión de setuptools no se lleva bien el subversion 1.5 (también el actual en mi ubuntu). Normalmente acostumbro a usar virtualenv y me he encontrado con el error:

NameError: global name 'log' is not defined

Ya está arreglado en el desarrollo de setuptools. Una posible solución es:

easy_install setuptools==dev06'

Aquí temos más información.

Editores: Mostrar los números de linea en emacs y en jed

2008-09-11T16:24:00+02:00

Para evitar esos odiosos porcentajes cuandos editas un fichero (¿de verdad le sirven a alguien?) y poner en su lugar el número de la linea en que te encuentras dejo aquí la anotación.

En emacs:

;; ========== Enable Line and Column Numbering ==========
;; Show line-number in the mode line
(line-number-mode 1)
;; Show column-number in the mode line
(column-number-mode 1)

En jed:

LINENUMBERS = 2

Grabar CD de 800MB en linux

2008-07-23T05:07:00+02:00

Tenía que grabar unos datos. Eran 730MB aproximadamente, con un CD habitual (700MB) iba a ser imposible, pero tenía por ahí un CD philips de 90 minutos (800MB). Y teniendo ese CD ¿por qué usar un DVD que son más caros? Mi sorpresa llega cuando el k3b (que uso habitualmente) se niega a grabar, ¡por falta de espacio! a pesar de que le indico (graicias google) que use el modo DAO en la interfaz. Total que a grabar desde la consola :-D Aquí dejo el comandito como anotación para tenerlo de cerca la próxima vez:

cdrecord -dev=/dev/scd0 -v -overburn -dao -speed=4 -data -eject /tmp/LaBodademiNovia.iso

La opción necesaria además de "DAO" es "overburn". Podéis ver como cdrecord sí reconoce todo el tamaño del disco como indica la línea:

Total size:      810 MB (80:18.14) = 361361 sectors

ACTUALIZACIÓN: Ahora veo una opción en las preferencias de k3b para pervitir el sobregrabado. Si es que k3b no me podía fallar :-D

Buscando una fuente para escribir código

2008-07-22T09:43:00+02:00

Varios enlaces interesantes sobre este tema.

Personalmente, la Bitstream Vera Sans Mono, me parece una fuente bastante aceptable. Me gusta mucho también Envy Code R. ¿Qué tipo de letra es vuestra preferida para codificar?

Mi wordle

2008-06-13T02:17:00+02:00

Siguiendo una cadena,aquí tenéis mi wordle a partir de mis enlaces de del.icio.us: ¿Cómo es el tuyo?

Convertir disco vmware

2008-05-11T12:07:00+02:00

pcaro@davinci$ vmware-vdiskmanager -r Windows\ XP\ Professional.vmdk -t 0 WindowsXPProfessionalUnico.vmdk
Creating disk 'WindowsXPProfessionalUnico.vmdk'
Convert: 100% done.
Virtual disk conversion successful.

¿Qué ejecutas tu desde la consola?

2008-04-13T14:00:00+02:00

Un meme para ver que ejecutas desde la consola:

pcaro@davinci$ history|awk '{a[$2]++} END{for(i in a){printf "%5d\t%s\n",a[i],i}}'|sort -rn|head
95   sudo
71   ls
67   cd
33   svn
29   dentro
24   clear
18   ssh
15   i2e-cli
14   ps
13   man

A notar que dentro es un script que tengo para hacer un grep -r filtrando algunos resultados.i2e-cli es un diccionario.

Más comandos a recordar

2008-04-09T11:54:00+02:00

Otra nota para que no se me vuelvan a olvidar algunos de los super-mini-comandos unix.

Para desconectar un programa de la consola desde la que se está ejecutando y no pare por ejemplo si muere la conexión ssh, hay que usar disown. Es una de esas herramientas para control de trabajos como fg. Los pasos son:

Ejecutar la tarea en segudo plano "ejecutable.sh &", en la consola te saldrá el número de trabajo [1]
luego disown %1

watch: para ejecutar un programa periódicamente, mostrando su salida a pantalla completa y pudiendo señalar las diferencias. Lo uso con un ls -l por ejemplo para ver como va cambiando el tamaño de un fichero, etc.

PD: Gracias a mis compañeros de Yaco por enseñarme un poco todos los días. Nota post-post: Me comentan que es muy útil nohup.

Timing en "psql" la consola de postgres

2008-03-31T03:25:00+02:00

Recordar:

timing

También podemos utilizar para más información "explain analyze":

EXPLAIN ANALYZE select ...

Ejecutar comandos en python

2008-03-04T06:18:00+01:00

Hago a menudo pequeños scripts en python. Y muchas de las veces necesito ejecutar algún comando del sistema. Habitualmente importaba el módulo os y llamaba a alguna de sus funciones (las popen). Pero en general no hace falta importar os. Existe un módulo llamado commands (sólo para unix) que permite realizar esta tarea con suma facilidad y mejor lectura del código. Dejar claro que para cosas más avanzadas es mejor usar subprocess que pretende reemplazarlo.

Rendimiento y Monitorización de procesos en windows

2008-02-12T07:21:00+01:00

Prácticamente nunca uso windows, y por trabajo, cuando tengo que hacerlo es para ver errores. Resulta útil ver los procesos. Para no olvidarme como simpre dejo mi nota aquí:

Para ver el rendimiento del sistema, Monitor de rendimiento: Incio, ejecutar: perfmon
Un buen monitor de procesos se encuentra entres las utilidades que da microsoft

Continuar con una descarga

2008-01-27T08:37:00+01:00

scp no permite continuar con copias que se cortan, pero lo permite rsync. El comando para recordar es: alias scpresume="rsync --partial --progress --rsh=ssh"Eso claro, siempre que tengas rsync

ubuntu, wordpress, php5 y mysql

2007-11-25T06:03:00+01:00

Configurando un wordpress local para pruebas (con lighttpd), me encuentro con el siguiente error: Your PHP installation appears to be missing the MySQL which is required for WordPress. Sabía que php5 no tiene incluido el soporte para mysql pero para mi sorpresa en mi ubuntu yo sí tenía instalado el paquete adecuado. El problema es que no estaba activado. Por si les pasa a otros y para recordarlo en un futuro, la cosa se arregló con: sudo dpkg-reconfigure php5-mysql y el pertinente reinicio del servidor: sudo /etc/init.d/lighttpd restart

Para aprender javascript

2007-11-01T14:01:00+01:00

Para aprender una tecnología todos conocemos nuestro punto de referencia. Pero "El Buscador" no es punto de partida más recomendable para aprender javascript. Existen cientos, miles, millones, de tutoriales donde aprender mal javascript. No hablo de aprender las palabras clave y las sentencias de control. Para eso te vale cualquiera. Hablo de aprender los conceptos clave detrás del lenguaje y su implicación explicada de forma práctica. Para no perder el tiempo y comprender de verdad el lenguaje incomprendido hay que acudir a:

Mastering JavaScript — concept and resource guide gracias a Brian Reindel
Las presentaciones de Douglas Crockford. Los vídeos están recopilados en este enlace

Knetworkmanager

2007-10-06T05:28:00+02:00

Ahora una de esas entradas para que me sirva de recordatorio. Habitualmente estoy acostumbrado, cuando voy a un lugar y me dan conexión wifi, a configurarla a mano en /etc/network/interfaces. Esto hace que deje de funcionar el knetwormanager. Indica "configuración manual de red". Para que vuelva a tomar el control de las interaces de red tengo que comentar todas las líneas en ese fichero como bien se indica en la documentación de ubuntu. Para manejar el demonio NetWorkmanger tengo que usar: /etc/dbus-1/event.d/25NetworkManager {start|stop|restart|force-reload} /etc/dbus-1/event.d/26NetworkManagerDispatcher {start|stop|restart|force-reload}

Mi nueva cámara

2007-08-25T10:43:00+02:00

Me acabo de compar una cámara digital compacta. No soy muy dado a fotos pero ya hora de tener una cámara digital. La elegida ha sido una Panasonic DMC-FX10 de 6 Mpx y lentes Leica. La prueba de fuego la ha tenido en Granada. Es el peor sito para una cámara compacta (uno echa de menos un zoom potente y todas las características de una buena reflex con esas vista de la Alhambra al atardecer) pero me ha gustado el aparato y creo que ha sido una buena elección. Ya pondré unas fotos.

¡Que práctico es python!: svnrevisions.py

2007-04-10T09:55:00+02:00

Pongo a continuación un script rápido que hice hace ya un tiempo. En ese momento estaba realizando un backport de código y de forma sucia realicé varios

svn up -rTAL

De esa forma y con unos pequeños cambios obtuve el cambio que necesitaba. Pero después de un rato no recordaba que fichero cambié exactamente y a qué revisiones. Un poquito de terminal y listo. Se que es sucio, que podría usar las librerías de python para subversion, etc. Pero se hizo de forma rápida y funciona. El funcionamiento se puede ver en el código fuente, pero pongo una ayudita:

$ python svnrevisions.py
$ python svnrevisions.py 123
$ python svnrevisions.py ALL

Aquí dejo el código: svnrevisions

Error al grabar CDs con k3b

2006-12-18T05:18:00+01:00

Tengo un Dell latitude D610 y kubuntu edgy. Desde dapper siempre me ha ocurrido un error al copiar cds con k3b. El problema es que no tengo acceso al dispositivo /dev/sg0 con ~~sudo chown /dev/sg0 root:cdrom~~ sudo root:cdrom /dev/sg0 lo soluciono (doy grupo cdrom a quién quiera que use la grabadora). El problema es que al reiniciar se vuelve a colocar el grupo a root y no se como cambiar esto en el udev. ¿Alguna idea?

Siempre la coma como símbolo decimal en un formulario .net

2006-12-15T14:23:00+01:00

Entre los muchos lenguajes que me ha tocado codificar (únicamente no me arrepiento de hacerlo en python) se encuentra .net. Es una chusquería que me solicitó un cliente. Quería que en un formulario al pulsar el punto del teclado numérico la entrada fuera una coma (no dependiera de la configuración de los locales en el windows). Puede llegar a ser muy útil.

/**
* En este formulario el simbolo decimal del teclado numerico siempre la comma
*/
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
if (keyData == Keys.Decimal)
{
SendKeys.Send(",");
return true;
}
return base.ProcessCmdKey(ref msg, keyData);

Corrector ortográfico de firefox 2.0 en castellano

2006-11-14T07:18:00+01:00

En la url escribir: about:config Filtras las propiedades por "dic". Y estableces el valor de la propiedad "spellchecker.dictionary" a es_ES.

Primera anotación de prueba

2006-10-10T09:55:00+02:00

Como todo blog que comienza, es de obligado cumplimiento una primera entrada "sólo para probar". En la primera entrada además del maravilloso lorem ipsum aprovecho para felicitar al autor del tema que estoy probando a priori: Orange Dream de Buddha. Por cierto que luego veré si puedo traducir esto :-D Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Quisque vel quam. Morbi quis dolor. Pellentesque accumsan imperdiet tellus. Suspendisse eleifend, ante eu ullamcorper interdum, magna quam mattis tellus, ullamcorper pellentesque massa nibh laoreet tellus. Ut posuere risus eget massa rhoncus tincidunt. Integer commodo malesuada metus. Sed lacus urna, feugiat ut, lobortis id, pharetra quis, sem. Morbi vehicula, orci sed imperdiet viverra, magna tortor tincidunt erat, nec ultrices erat diam non nulla. Vivamus nulla. Cras ligula turpis, lacinia eu, elementum quis, facilisis vel, tortor. Vivamus venenatis tempor elit. Mauris in dui. Curabitur libero libero, ultrices id, lacinia nec, pellentesque eget, risus. Curabitur suscipit. Proin iaculis nisi ac ligula. Donec semper. Aliquam mauris nunc, tincidunt a, rhoncus consequat, fringilla quis, nunc. Duis facilisis pede eu orci. Praesent auctor nunc ut metus porta dignissim. Pellentesque posuere lectus. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Suspendisse vestibulum quam non lectus. Maecenas odio. Curabitur mollis vehicula erat. Sed pulvinar, lorem id malesuada ultricies, velit tortor volutpat orci, eu porta dolor lacus eu nunc. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Mauris ultricies magna mollis turpis. Proin ac ante nec mauris pulvinar accumsan. Donec euismod iaculis orci. Mauris tempor porttitor urna. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae;

Anotaciones por Pablo Caro

ku: Kubernetes desde la terminal como un ninja

Instalación¶

Lo que me ha convencido¶

Lo que no tiene (aún)¶

Pluggy — Un framework de plugins para usar en tus proyectos

¿Es Pluggy una shallow API?¶

Lo que realmente aporta Pluggy¶

Cómo se usa Pluggy en tests¶

Registrar plugins temporales en tests¶

Registrar múltiples hooks en un mismo fichero¶

Unsloth docs: la documentación más clara sobre requisitos hardware para LLMs locales

Tablas de VRAM para fine-tuning¶

Guías por modelo con requisitos específicos¶

Lo que hace buena esta documentación¶

AgentsView: analíticas locales para tus coding agents

Instalación¶

Qué te muestra¶

CLI para costes¶

Agentes soportados¶

PostgreSQL para equipos¶

Lo que no hace¶

Detectando secretos en git con gitleaks

Instalación con gah¶

Uso básico¶

¿Cuándo usarlo?¶

Pre-commit hook¶

Limpiando la caché escondida de npx

El problema¶

La trampa¶

Las extensiones de pi que uso en mi día a día

Subagentes — pi-subagents¶

Utilidades del sistema¶

pi-processes¶

pi-inspect¶

pi-slim¶

Gestión de sesiones¶

pi-smart-sessions (HazAT)¶

pi-slopchop¶

pi-add-dir (itisbryan)¶

Búsqueda y navegación web¶

@aliou/pi-linkup¶

agent-browser skill¶

chrome-cdp skill¶

Productividad y UI¶

pi-powerline-footer¶

@tmustier/pi-code-actions¶

@aliou/pi-guardrails¶

pi-ask-user y pi-schedule-prompt¶

pi-interactive-shell¶

Skills que uso todos los días¶

Del repositorio oficial de pi¶

De mi repositorio pcaropi¶

Extensiones¶

Skills¶

Prompt templates¶

MCP¶

pi-mcp-adapter (NicoBailon)¶

Pi de novato a avanzado — La guía completa

Nivel 1: Novato — Primeros pasos¶

Instalación¶

Autenticación¶

Tu primer prompt¶

Archivos de contexto (AGENTS.md)¶

Referenciar archivos con @¶

Nivel 2: Intermedio — Navegación y productividad¶

Atajos de teclado essenciales¶

Bash desde la TUI¶

La barra de estado¶

Cola de mensajes¶

Sesiones y branching¶

Intercambio rápido de modelos¶

Mensajes de sistema¶

Nivel 3: Avanzado — Skills, templates y extensiones¶

Skills¶

Prompt templates¶

Extensiones (pi packages)¶

Compaction¶

Temas¶

Nivel 4: Power user — Configuración total¶

`/grill-me`: el skill que lo cambia todo¶