Anotaciones por Pablo Caro

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?

From net-tools to iproute2: command equivalents

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

Over 30 years with Linux, and it's hard to change what you're already used to. In my case, I've always used ifconfig, arp, route, and netstat to configure and diagnose the network. But these commands belong to the net-tools package, which has been replaced by iproute2 years ago.

net-tools vs iproute2¶

There are traditionally two ways of configuring the network in Linux:

The old way: with commands like ifconfig, arp, route and netstat, which are part of the net-tools package
The new way: mostly (but not entirely!) wrapped in a single ip command, which is part of the iproute2 package

It seems like the latter was made "important" in Debian in 2008, which means every release since Debian 5 "lenny" (!) has featured the ip command.

I have been slowly training my brain to use the new commands but I sometimes forget some. So, here's a couple of equivalences from the old net-tools package to the new iproute2:

net-tools	iproute2	Shorter form	What it does
`ifconfig`	`ip address`	`ip a`	Show/configure IP addresses
`ifconfig -s`	`ip link`	`ip l`	Show link stats (up/down, packet counts)
`route`	`ip route`	`ip r`	Show or modify routing table
`arp`	`ip neigh`	`ip n`	Show ARP/neighbors table
`netstat`	`ss`	`ss`	Show socket statistics

Visual comparison¶

Here's the difference between using ip a and ip -br -c a:

`ip a` (full output)¶

`ip -br -c a` (brief and colored output)¶

My favorite alias¶

I often alias ip to provide much prettier output:

alias ip='ip -br -c'

This provides a much nicer and readable output, as you can see in the second image.

Do you still use the old commands or have you already switched to 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

Fixing Rodney Chrome Error on Wayland

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

Rodney is a CLI tool created by Simon Willison designed specifically for AI agents to control a Chrome instance using the Chrome DevTools Protocol. It's similar to Vercel's agent-browser, but uses CDP instead of Playwright.

The Problem¶

Running uvx rodney open https://google.es without first starting Rodney with rodney start fails because:

Rodney tries to start Chrome with the Chromium it automatically downloads to ~/.cache/rod/browser/
That Chromium (v128.0.6568.0) has a known bug with the Ozone backend on Wayland systems
The crash occurs due to the combination of flags --single-process + --ozone-platform=headless
The error in the logs shows: gl_factory_ozone.cc(62): "Expected Mock or Stub, actual:0"

The Solution¶

The easiest way to fix this is to configure Rodney to use your system's Chrome instead of the automatically downloaded Chromium. This is done via the ROD_CHROME_BIN environment variable:

# Add to ~/.bashrc or ~/.zshrc
echo 'export ROD_CHROME_BIN=/usr/bin/google-chrome' >> ~/.bashrc
source ~/.bashrc

After setting this up, Rodney will work correctly:

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

Working example¶

Once configured, the workflow looks like this:

~/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]

Why does this happen?¶

The Chromium that Rodney downloads automatically has a known bug with the Ozone backend on Linux systems that use Wayland (the alternative to X11). When certain Chrome flag combinations are used, the process fails because the graphics system isn't configured as "Mock" or "Stub" (which is what the development builds expect).

Using the system Chrome avoids this problem because: - System Chrome is compiled with full Wayland support - It's generally a more stable and updated version - It doesn't have the same development flags that cause conflicts

Link¶

Rodney GitHub Repository

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!

Record and Share your Terminal Sessions with asciinema

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

Often we need to share what's happening in our terminal, whether for a tutorial, demonstrating a bug, or simply documenting a process. While traditional video recording tools exist, asciinema offers a much more powerful and lightweight alternative.

What is asciinema?¶

asciinema doesn't record video in the traditional sense (pixels). Instead, it captures the terminal's text stream along with exact timings. This has several advantages:

Tiny files: Instead of megabytes of video, you get very small text files.
Selectable text: When playing back a session on the web, you can copy and paste the code directly.
Perfect quality: No loss of resolution or compression artifacts.

Installation and Help¶

I already have asciinema installed on my system. Here you can see the summary of available commands:## Interactive example

Below you can see a small demonstration of asciinema in action, running the command cowsay Muuuuu:

Basic commands¶

To start recording, simply run:

asciinema rec demo.cast

This will begin recording everything that happens in your current terminal session. When you're finished, simply press Ctrl-D or type exit. The result will be saved in the demo.cast file.

To play it back locally:

asciinema play demo.cast

And if you want to share it with the world, you can upload it to their free hosting service:

asciinema upload demo.cast

Why use it?¶

It's ideal for developers writing technical blogs (like this one), as it allows you to embed the recordings directly into the browser with a lightweight JavaScript-based player. Goodbye, blurry 20MB GIFs!

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

kitty-rbw: Fast Bitwarden access from your kitty terminal

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

In the previous post we talked about rbw, the Bitwarden CLI client written in Rust that stands out for its speed and for using an agent to manage vault unlocking.

Today I'm going a step further and introducing kitty-rbw, a kitten I've developed for the kitty terminal. Its goal is to let you search and use your Bitwarden credentials without leaving the terminal or typing complex commands, integrating perfectly into your workflow.

What is a kitten?¶

Kittens are small Python programs that extend the functionality of the kitty terminal. They can run in overlays, making them ideal for interactive tools that we don't want cluttering our terminal history.

Key Features¶

kitty-rbw uses fzf to provide extremely fast fuzzy searching over your rbw vault. Here are its most notable features:

Simultaneous search: Filter by name, username, and folder at the same time.
Direct injection: Types the password or username directly into the active terminal window where you launched the kitten. Ideal for sudo prompts or SSH logins.
Clipboard support: Copy the username, password, or TOTP code with a single keyboard shortcut.
Usage prioritization: The 10 entries you use most frequently appear at the top of the list, making it easy to access common credentials.
Folder shortcuts: You can configure the kitten to open pre-filtered by a specific folder (e.g., one for work and one for personal).

Installation¶

To install it, simply clone the repository into your kitty configuration directory:```bash cd ~/.config/kitty git clone https://github.com/pcaro/kitty_rbw

Then, add a keyboard shortcut to your `kitty.conf`:

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

Usage and Shortcuts¶

Once configured, pressing the shortcut (Ctrl+Shift+b by default) will open a panel with your credentials.

Key	Action
`Enter`	Type password into the terminal
`Ctrl+u`	Type username
`Ctrl+b`	Type username, press `Tab`, then password
`Ctrl+t`	Copy TOTP code to clipboard
`Alt+p`	Copy password to clipboard
`Alt+u`	Copy username to clipboard
`Alt+s`	Sync the vault (`rbw sync`)

If you want to know more or contribute to the project, you can find it on 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:```bash 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:

```bash
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.

rbw: The Bitwarden terminal client you should be using

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

While Bitwarden has an official command-line client, it can be slow as it is Node.js-based. For those of us looking for something more agile, rbw is the ideal solution. It is an unofficial Rust implementation that stands out for being extremely fast and for managing vault unlocking through an agent, preventing you from having to enter your master password for every command.

Installation¶

The easiest way to install it is by downloading the binary directly from its GitHub releases. I use gah for this purpose:```bash gah install doy/rbw

This command will download the `rbw` binary and the `rbw-agent` binary.

## Initial Setup

The first thing is to configure your account and the server:

```bash
rbw login

It will ask for your email and the server URL (you can leave it blank if you use the official Bitwarden one or enter the URL of your Vaultwarden instance).

To start using it, unlock the vault:

rbw unlock

Unlike the official client, you don't need to export environment variables with session tokens. The rbw agent takes care of everything in the background.

Basic Usage¶

To get a password quickly:

rbw get "Item Name"

If there are multiple items with the same name, you can use filters or the ID. You can also get custom fields or the username:

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

Integration with pi-agent¶

One of the greatest advantages of having a fast and secure CLI client is the ability to integrate secrets into your development tools.

pi-agent allows executing commands to obtain API keys dynamically. This avoids having to save keys in plain text configuration files. In your settings.json, you can configure access to a key as follows:

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

The ! prefix tells pi-agent to execute the command and use its standard output as the key. Thanks to the rbw agent, this command will run instantly without asking for your master password every time, as long as the vault is unlocked.

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.

DeepDiff: The Swiss Army Knife for Data Comparison in Python

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

When working with structured data in Python, we often need to compare two dictionaries, JSONs, or complex objects to find out what has changed. While direct comparison (==) is useful, sometimes we need to understand exactly what is different: which keys were added, which were removed, or where values have changed, even in deeply nested structures.

This is where DeepDiff comes in.

DeepDiff is an incredibly powerful Python library that offers much more than simple comparison. It is an essential tool for testing, data validation, and API debugging.

Key Features¶

DeepDiff is not just a tool, it's a suite of utilities:

DeepDiff: Recursively compares dictionaries, iterables, strings, and other objects. It can ignore order in lists, ignore specific types, or exclude paths from comparison.
DeepSearch: Searches for objects within other objects, like a grep for in-memory data structures.
DeepHash: Calculates hashes of objects based on their content. Very useful for deduplication of complex data where key order doesn't matter.
Delta: Generates "deltas" (differences) that can be applied to other objects, similar to a git patch but for Python objects.

Installation¶

The modern and recommended way to install Python tools is using uv.

As a Command Line Interface (CLI) Tool¶

If you just want to use the deep command in your terminal to compare JSON or YAML files:```bash uv tool install "deepdiff[cli]"

This will install the `deep` command on your system in an isolated environment. Make sure to include `[cli]` to install the necessary dependencies.

### As a Library in Your Project

If you are going to use it within your Python scripts:

```bash
uv add "deepdiff"

Or if you need the CLI inside your virtual environment as well:

uv add "deepdiff[cli]"

Usage Examples¶

In Python¶

Imagine you have two slightly different API responses and want to know what changed:

from deepdiff import DeepDiff

t1 = {
    "id": 1,
    "name": "Product A",
    "tags": ["new", "sale"],
    "details": {"price": 100, "stock": 50}
}

t2 = {
    "id": 1,
    "name": "Product A",
    "tags": ["sale", "new"],  # Different order
    "details": {"price": 120, "stock": 50}
}

# By default, order matters in lists
diff = DeepDiff(t1, t2)
# Result shows changes in 'tags' list and 'details.price'

# If we ignore order in iterables
diff_ignore_order = DeepDiff(t1, t2, ignore_order=True)
print(diff_ignore_order)

Output:

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

As you can see, it detected the price change but ignored the order change in tags.

In the Terminal (CLI)¶

The deep command is very useful for quickly comparing files:

# Compare two JSON files
deep diff production.json development.json

You can also use it to extract information or search within large JSON/YAML files without having to write a script.

Conclusion¶

DeepDiff is one of those libraries that, once you know about it, you can't stop using. Its flexibility to ignore certain fields (like timestamps or auto-generated IDs) makes it perfect for integration tests and data validation.

You can view the full documentation at zepworks.com/deepdiff.

Rendering Markdown in the terminal with Glow

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

Glow is a command-line Markdown renderer. It allows you to read local or remote Markdown files, rendering them with syntax highlighting and styles, directly in your terminal.

I find this tool especially useful now that I spend more time using the terminal with Kitty, as it allows me to consult documentation and READMEs without having to open a browser or a graphical editor.

Installation¶

To install Glow, we will use gah, a tool that simplifies installing binaries from GitHub Releases.```bash gah install charmbracelet/glow

The installation process is very simple:

```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!

Once installed, simply run glow followed by the file you want to view, or even the URL of a README on GitHub.

Shot-scraper: Automated Web Screenshots

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

Have you ever needed to take screenshots of a web page programmatically? Perhaps to document your project, monitor UI changes, or generate images for social media. There are many ways to do it, but shot-scraper stands out for its ease of use and power.

Created by Simon Willison, shot-scraper is a command line interface (CLI) tool that wraps Playwright to make taking screenshots trivial.

Installation¶

As with other modern Python tools, the best way to install it is using uv:```bash uv tool install shot-scraper

Once installed, you'll need to download the browser it uses under the hood (Chromium):

```bash
shot-scraper install

Basic Usage¶

The simplest way to use it is to give it a URL and a filename:

shot-scraper https://pablocaro.es/en/ blog.png

This will generate an image named blog.png with the screenshot of the page.

Capturing Specific Selectors¶

One of the most powerful features is the ability to capture only a specific element of the page using CSS selectors:

shot-scraper https://github.com/pcaro -s ".js-calendar-graph" calendar.png

This command will capture only the GitHub contribution graph.

Interacting with JavaScript¶

Sometimes you need to execute some code before taking the shot. For example, to hide a cookie banner or wait for something to load.

shot-scraper https://pablocaro.es/en/ \
  --javascript "document.querySelector('header').style.display = 'none';" \
  -o no-header.png

Advanced Automation¶

If you need to take many screenshots, you can define a YAML configuration file:

# shots.yml
- url: https://pablocaro.es/en/
  output: home.png
  height: 800
- url: https://pablocaro.es/en/archives.html
  output: archives.png
  wait: 1000  # Wait 1 second

And run them all at once:

shot-scraper multi shots.yml

Beyond Screenshots¶

shot-scraper also includes utilities for:

Accessibility: Dump the accessibility tree of a page (shot-scraper accessibility).
PDF: Generate PDFs of web pages (shot-scraper pdf).
HAR: Record HAR files to analyze network traffic (shot-scraper har).

It's one of those tools that, once installed, you find uses for constantly. Perfect for integrating into CI/CD pipelines to generate documentation visuals automatically.

More info in the official documentation.

Stern: Kubernetes Logs on Steroids

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

If you work with Kubernetes, you've probably suffered through the kubectl logs command. It's useful for viewing the logs of a specific pod, but it falls short when you have multiple replicas of a service or when pods restart and change names.

This is where Stern comes in.

Stern allows you to "tail" logs from multiple pods and containers within Kubernetes simultaneously. Best of all, it uses regular expressions to select pods, so you don't need to copy and paste those random IDs (pod-1234567890-abcde).

Installation¶

Stern is very popular and available in most package managers.### Using Krew (recommended) If you already use kubectl, Krew is the most natural way to install plugins:

kubectl krew install stern

Using Homebrew¶

brew install stern

Direct Binary¶

You can also download the binary directly from their GitHub releases.

If you use a helper like gah (GitHub Asset Helper) or custom scripts, installation is as simple as:

gah install stern/stern

Key Features¶

1. Multi-pod Tailing¶

Instead of searching for the exact pod name, you can use a regex:

stern backend

This will show logs from all pods containing "backend" in their name (backend-api, backend-worker, etc.), interleaved and colored to easily distinguish them.

2. Filtering and Exclusion¶

You can filter log content on the fly without needing grep:

# Only show lines containing "Error"
stern backend -i Error

# Exclude lines containing "Health check"
stern backend -e "Health check"

3. Kubernetes Selectors¶

In addition to regex by name, you can use label selectors, which is much more precise for production environments:

stern -l app=my-app -l tier=frontend

4. Output Formatting¶

If your logs are in JSON (as is best practice), Stern can pass them through as is so you can process them with tools like jq or fx:

stern backend -o raw | fx

Conclusion¶

Stern is one of those tools you install on day one and wonder how you ever lived without it. It makes debugging in distributed environments much less painful by aggregating information coherently.

Give it a try and your debugging sessions will thank you.

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.

Managing GitHub installations with gah

2026-02-11T20:23:00+01:00

gah is a tool that simplifies installing programs distributed via GitHub releases. It's a lightweight alternative when you don't want to rely on your distro's package manager or when you need a newer version.

Installation

To install gah, you can use the official script:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/get-gah/gah/refs/heads/master/tools/install.sh)"

Usage

Once installed, usage is very straightforward. Here are a couple of examples I've used recently to install popular Rust tools:

To install fd (a fast alternative to find):

gah install sharkdp/fd

To install ripgrep (a fast alternative to grep):

gah install BurntSushi/ripgrep

Gah handles downloading the correct asset for your architecture, unpacking it, and placing it in your path.

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

Multiline YAML: Understanding and testing complex strings

2025-12-25T16:10:00+01:00

YAML has become the de facto format for configuration in many projects, from Kubernetes to CI/CD scripts. One of its most powerful, and sometimes confusing, features is the management of multiline strings. Fortunately, there is an exceptional interactive tool to master this aspect: yaml-multiline.info.

Formats for Multiline Strings in YAML¶

YAML mainly offers two approaches for defining strings that span multiple lines:

Flow Scalars:
- They are simple strings, often quoted ('...' or "...") or unquoted.
- They ignore indentations and, by default, replace line breaks with spaces.
- Double-quoted strings allow using escape sequences like \n.
Block Scalars:
- They offer much more precise control over line breaks and indentation.
- They are indicated with a special character at the beginning of the line where the string starts.

Keys for Block Multiline Strings¶

The two most important style indicators for block scalars are:

| (Literal Style): Keeps all line breaks and indentation as is. It is ideal for blocks of text where formatting is crucial (e.g., code, long messages). yaml literal_string: | This is a line. This is another. With its own indentation. Result: "This is a line.\nThis is another.\n With its own indentation.\n"
> (Folded Style): Replaces line breaks with spaces, joining lines into a single one. Only double line breaks (blank lines) or lines with greater indentation are kept as line breaks. It is useful for long paragraphs. yaml folded_string: > This is a string folded into multiple lines. It will keep the paragraph format. Result: "This is a string folded into multiple lines. It will keep the paragraph format.\n"

In addition to this, there are "chomping" indicators (- to remove trailing line breaks, + to keep them, or the default behavior) and indentation indicators that offer even more control.

Real-Time Demo!¶

What makes yaml-multiline.info an invaluable tool is its interactive demo. You can test different YAML syntaxes in real-time and see how the resulting string is interpreted. It is the best way to visually understand how literal and folded styles work, and how chomping and indentation indicators affect the final result.

Conclusion¶

Understanding how to handle multiline strings in YAML not only improves the readability of your configuration files but also prevents unexpected errors. The real-time demo of yaml-multiline.info is a fantastic resource for anyone who regularly works with YAML and wants to master this aspect.

Website: 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

Pandas Styler: Improve the Presentation of your DataFrames

2025-12-25T15:55:00+01:00

When working with data in Python, Pandas DataFrames are our main tool. However, their default presentation in consoles or notebooks can be very basic. This is where the Pandas Styler object becomes a fundamental ally to transform simple DataFrames into visually attractive and informative tables.

What is Pandas `Styler`?¶

The Styler object allows you to apply conditional formatting and CSS styles directly to your Pandas DataFrames. With it, you can highlight patterns, emphasize important values, and improve readability without having to export the data to another tool.

Key Features¶

Conditional Formatting: Highlight cells, rows, or columns based on conditions defined by you (e.g., values above a threshold, duplicates, etc.).
CSS Styles: Apply CSS styles such as background colors, fonts, borders, or alignments to customize the appearance.
Predefined Styles: Includes methods like background_gradient() to apply color gradients that visualize the distribution of values.
Excel Integration: Maintains styles when exporting DataFrames to Excel files, facilitating professional reports.

Conclusion¶

The Pandas Styler object is a simple but powerful tool to take your data presentation to the next level. With a few lines of code, you can make your DataFrames not only a data source but also an effective communication tool.

Original article: 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

`fresh`: My preferred terminal editor for daily use

2025-12-25T15:45:00+01:00

Although vim is an incredibly powerful tool and nano stands out for its extreme simplicity, I often look for a middle ground for file editing in the terminal. An editor that is fast, modern, and doesn't force me to remember modes or complex key combinations for simple tasks. That's how I discovered fresh, and it has quickly become my preferred terminal editor for daily use.

What is `fresh`?¶

fresh is a text editor for the terminal designed to be simple, fast, and efficient. Unlike vim, fresh is a modeless editor, which means you can start typing and editing text immediately, just like you would in a graphical editor. Unlike nano, fresh offers a more modern experience with features you expect from a current text editor.

Why do I prefer it over `nano` or `vim` for regular use?¶

Modeless: The main advantage over vim. You don't need to learn to switch between insert, normal, visual modes, etc. You simply open the file and edit.
Modern and Fast: Despite running in the terminal, fresh feels responsive and offers a clean interface.
Syntax Highlighting: Support for syntax coloring for a wide variety of languages.
Mouse Support: You can click to move the cursor, select text, or even use the wheel to scroll.
Multi-Cursor: A very powerful feature that nano does not offer and vim requires more complexity to use.
Undo/Redo: Full undo/redo functionality.
Search and Replace: Simple and intuitive search and replace functions.

While vim remains my choice for complex edits or advanced scripting, for "opening a .conf", modifying a .bashrc, or writing a small note, fresh is unbeatable in speed and convenience. nano is perhaps too basic for my needs, lacking most of the modern features that fresh offers.

Installation¶

fresh is easy to install on most Linux distributions. For example, on Debian/Ubuntu-based systems:

sudo apt install fresh

Or you can follow the instructions in the official repository to compile it from source or use other package managers.

Conclusion¶

If you are looking for a terminal editor that is a perfect hybrid between the power of vim and the simplicity of nano, but with a modern touch and focused on immediate usability, fresh is an excellent choice. Give it a try, it might become your new favorite!

Official repository: fresh on 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

How to View Files in an RPM Package on Linux

2025-12-25T15:15:00+01:00

On RPM-based Linux systems (like Red Hat, CentOS, Fedora, openSUSE), it is common to interact with packages in .rpm format. Often, we need to know what files a package contains before installing it, or which package is responsible for a specific file already installed on the system. For this, the rpm tool offers several useful options.

1. List Files of an RPM Package Without Installing¶

If you have a downloaded .rpm file and want to see what files it will install (and where) without installing it, you can use the -qlp option:

rpm -qlp package_name.rpm

-q: Query mode.
-l: List files.
-p: Query a package file instead of an installed one.

Example:

rpm -qlp nginx-1.20.1-1.el8.x86_64.rpm

2. Find the Owner Package of an Installed File¶

If you find a file on your system and want to know which RPM package it belongs to (useful for debugging or knowing if you can safely delete it), use the -qf option:

rpm -qf /path/to/file

Example:

rpm -qf /etc/nginx/nginx.conf
# Expected output: nginx-1.20.1-1.el8.x86_64

3. Get Detailed Information about a Package¶

To see complete information about a package (version, description, dependencies, etc.), whether installed or an .rpm file, you can use -qi (for installed packages) or -qip (for package files):

rpm -qi installed_package_name
# Example: rpm -qi nginx

rpm -qip package_name.rpm
# Example: rpm -qip nginx-1.20.1-1.el8.x86_64.rpm

Conclusion¶

Mastering these simple options of the rpm command gives you much greater control over packages and files on your Linux system, facilitating administration and debugging. They are essential tools for any system administrator or developer working with RPM-based distributions.

Original article: 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

Kooha: Simple and Elegant Screen Recording on Linux

2025-12-25T15:00:00+01:00

In Linux, the need to record the screen simply and efficiently is common, whether to create tutorials, presentations, bug reports, or simply share an experience. Although there are many tools, Kooha stands out for its minimalist approach and its intuitive user interface, based on GTK.

What is Kooha?¶

Kooha is a free and open-source screen recording application, designed specifically for Linux desktop environments. Its main goal is to offer a hassle-free user experience, focusing on the essential functionalities of a screen recorder.

Why Choose Kooha?¶

Ease of Use: Its interface is clear and direct. No complex menus or overwhelming options, making it ideal for users of all levels.
Minimalist Design: It integrates perfectly with the look of GNOME and other GTK environments, offering a clean and pleasant visual experience.
Key Features: Despite its simplicity, it includes all the necessary options for most recording tasks.
Open Source: Being open-source, it benefits from the community and allows users to inspect and contribute to the code.

Main Features¶

Full Screen Recording: Captures everything that happens on your monitor.
Specific Window Recording: Choose a particular application or window to record.
Selected Area Recording: Define a rectangular area on your screen for capture.
Audio Recording: Includes audio from your microphone.
Webcam Recording: Integrates your webcam image into the recording.
Common Formats: Support for popular formats like WebM and MP4.
Quality Options: Settings for frame rate (FPS) and video quality.

Installation¶

The most recommended way to install Kooha is via Flatpak, which ensures you get the latest version and all necessary dependencies:

flatpak install flathub com.github.SeaDve.Kooha

It may also be available in the repositories of some Linux distributions or as a Snap package.

Conclusion¶

Kooha is the perfect tool for those looking for a screen recording solution on Linux that is powerful without being complicated. Its elegance and simplicity make it an excellent addition to any Linux user's productivity arsenal.

Official repository: SeaDve/Kooha on 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

OpenEvidence: The Leading Medical Information Platform for Professionals

2025-12-25T14:45:00+01:00

In the healthcare field, quick and reliable access to the latest and relevant medical information is crucial for clinical decision-making. OpenEvidence positions itself as a leading platform designed to consolidate and present this information in an accessible way to healthcare professionals.

What Does OpenEvidence Offer?¶

OpenEvidence acts as a nerve center for medical information, signing content agreements with some of the most prestigious publications and organizations in the sector. Its collaborators include:

The New England Journal of Medicine (NEJM)
JAMA Network
National Comprehensive Cancer Network (NCCN), including its clinical guidelines and pathways.
Mayo Clinic Platform

This ensures that professionals have at their fingertips an authoritative and updated source of knowledge.

Key Features for Professionals¶

The platform is designed to meet the specific needs of healthcare professionals, offering:

Primary Evidence: Direct access to clinical findings and original research.
Patient Documents: Tools to create informative brochures for patients, facilitating communication.
Capabilities Exploration: An intuitive system to navigate through a vast library of resources.
Clinical Guidelines and Pathways: Access to the latest recommendations for the treatment and management of various conditions.

Who is it For?¶

OpenEvidence is aimed primarily at verified healthcare professionals in the US and is offered free of charge for this group. It is available through iOS and Android apps, allowing convenient and mobile access to information.

Conclusion¶

OpenEvidence represents a significant advance in the democratization of access to high-quality medical information. By consolidating resources from various authoritative sources and offering them on an easy-to-use platform, it allows healthcare professionals to make more informed decisions and, ultimately, improve patient care.

Official website: 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

`direnv`: Manage your development environments intelligently

2025-12-25T14:30:00+01:00

In the daily life of a developer, it is common to work with multiple projects, each with its own environment variables, paths (PATH), tool versions, or credentials. Manually managing these variables can lead to messy configurations in your .profile or .bashrc, or errors due to using the wrong environment. This is where direnv shines, offering an elegant and automatic solution.

What is `direnv`?¶

direnv is an extension for your shell (Bash, Zsh, Fish, etc.) that automatically detects when you change directories. When you enter a directory containing an .envrc file, direnv loads it; when you leave it, it unloads it. This means your shell environment dynamically adapts to your current project without you having to do anything manually.

How does it work?¶

direnv integrates with your shell through a hook in the cd command. Every time you change directories, direnv checks if there is an .envrc file in the current directory or any of its ancestors. If it finds one (and you have granted permission to load it), it executes the commands defined in that file to modify your environment. Upon leaving the directory, it reverts those changes, cleaning up your environment.

Common Use Cases¶

PATH Management: Adding project-specific binaries to your PATH temporarily.
Python Virtual Environments: Automatically activating a virtualenv or uv venv when entering a Python project.
Credentials and API Keys: Loading environment variables with database credentials, API keys, or tokens securely (without leaving them in the shell history).
Project-Specific Environment Variables: RAILS_ENV, NODE_ENV, etc.
Tool Version Switching: Integrating with tools like nvm or pyenv to automatically switch Node.js or Python versions.

Basic Installation (Bash example)¶

Install direnv: You can install it from your package manager (sudo apt install direnv, brew install direnv, etc.).
Activate the hook in your shell: Add the following line to your ~/.bashrc (or ~/.zshrc):

bash eval "$(direnv hook bash)"
Create an .envrc file: In the root of your project, create an .envrc file with the variables and commands you want.

```bash

.envrc in the root of your Python project¶

layout python # Automatically activates a virtual environment export MY_API_KEY="super_secret_project_key" ```
Allow loading: The first time you enter the directory with a new .envrc, direnv will ask for confirmation:

bash direnv: error .envrc is blocked. Run `direnv allow` to approve its contents Run direnv allow.

The `direnv` Standard Library¶

direnv comes with a powerful standard library that includes predefined functions for common tasks, such as layout python (to manage virtualenvs), use nix, use node, etc., greatly simplifying the configuration of your .envrc files.

Key Benefits¶

Clean environments: Your .profile stays tidy.
Consistency: Each project has exactly the environment it needs.
Productivity: No more manual source venv/bin/activate or remembering to set variables.

direnv is a small but powerful tool that transforms the way you manage your development environments, making your life in the terminal much more efficient and error-free.

Original article: 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

`docker-http-https-echo`: An Essential Tool for Network Debugging

2025-12-25T14:15:00+01:00

In the complex world of distributed applications, debugging network issues, proxies, load balancers, or firewall rules can be an arduous task. We need a simple way to verify what a server is receiving. This is where a tool like mendhak/docker-http-https-echo becomes indispensable.

What is `mendhak/docker-http-https-echo`?¶

It is an extremely lightweight and simple Docker container that functions as an "echo" HTTP and HTTPS server. Its main function is to respond to any HTTP or HTTPS request with a detailed description of the request itself. This includes:

Request headers.
HTTP method (GET, POST, PUT, etc.).
Request URL and parameters.
Request body.
Remote IP address of the client.
TLS/SSL information (if HTTPS).

Why is it useful?¶

This type of echo server is invaluable for a variety of debugging scenarios:

Proxy and Load Balancer Debugging: Verify if a reverse proxy or load balancer is rewriting headers, modifying URLs, or passing the request body as you expect.
Firewall and Security Rules: Confirm that traffic is reaching the correct destination and is not being blocked or altered.
HTTP/HTTPS Header Inspection: Useful to see exactly what headers your client or a specific application sends.
Integration Testing: A predictable target for automated tests of how different services communicate via HTTP/HTTPS.
Mixed Content Diagnosis: You can use it to verify if HTTP resources are loading correctly in an HTTPS context.

How to Use It¶

Using it is straightforward via Docker:

For HTTP (port 8080)¶

docker run -p 8080:8080 mendhak/http-https-echo

Then, you can access http://localhost:8080 with your browser or curl:

curl http://localhost:8080/path?query=value -H "X-Custom-Header: test"

For HTTPS (port 8443)¶

To use HTTPS, you must map the container's HTTPS port. The image already comes with a self-signed certificate for testing.

docker run -p 8443:8443 mendhak/http-https-echo

Access https://localhost:8443 (your browser may warn you about the self-signed certificate).

Conclusion¶

mendhak/docker-http-https-echo is one of those simple but incredibly useful tools that every developer and system operator should have on hand. It facilitates understanding network flows and speeds up debugging connectivity issues in any container-based environment.

Original repository: mendhak/docker-http-https-echo on 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

Kubegres: Simplified PostgreSQL Management on Kubernetes

2025-12-25T14:00:00+01:00

Deploying and managing relational databases on Kubernetes can be challenging. Although containers and orchestration offer flexibility, data persistence, high availability, and backups for a database like PostgreSQL require careful consideration. This is where Kubegres comes into play.

What is Kubegres?¶

Kubegres is a Kubernetes operator that allows you to deploy and manage PostgreSQL clusters on Kubernetes simply and efficiently. An operator is an application that extends Kubernetes functionalities, automating complex operational tasks that typically require manual intervention.

Why use Kubegres?¶

Kubegres abstracts much of the complexity of running PostgreSQL in an orchestrated environment, offering key features such as:

High Availability (HA): Automatic configuration of PostgreSQL replicas to ensure service continuity in the event of failures.
Replication: Support for streaming replication (Primary/Standby) for redundancy and read scalability.
Backups and Restore: Facilitates the configuration of backup policies and data recovery.
Scalability: Allows scaling PostgreSQL read replicas to handle growing workloads.
Easy Updates: Manages PostgreSQL version updates within the cluster.
Monitoring: Integrates mechanisms to monitor the cluster status.

How does it work?¶

Kubegres uses Kubernetes Custom Resources (CRs). This means you interact with your PostgreSQL cluster using standard Kubernetes objects (YAML). You define the desired state of your cluster (number of replicas, PostgreSQL version, backup policies) in a YAML file, and Kubegres ensures that state is maintained at all times.

apiVersion: kubegres.reactive-tech.io/v1
kind: Kubegres
metadata:
  name: my-postgres
spec:
  replicas: 3
  image: postgres:13.2
  database:
    size: 10Gi
  # ... other settings for backups, etc.

Benefits for Developers and Operations¶

Simplification: Drastically reduces the complexity of operating PostgreSQL on Kubernetes.
Automation: Tasks like failover, replication, and backups are managed automatically.
Consistency: Ensures that the state of your database always reflects your desired configuration.
DevOps Friendly: Allows you to integrate database management into your CI/CD pipelines using the same tools and workflows as for the rest of your K8s applications.

Kubegres is an excellent choice for teams looking for a robust and automated solution for their PostgreSQL needs on Kubernetes.

Original article: 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

TCP Connection States in GNU/Linux: netstat and ss

2025-12-25T13:30:00+01:00

In the GNU/Linux world, tools like netstat and ss are indispensable for monitoring and diagnosing the state of network connections on our systems. To correctly interpret their output, it is fundamental to understand the different states a TCP connection goes through. This post explores those states, from establishment to termination of a connection.

Phases of a TCP Connection¶

A TCP connection is managed through three main phases:

Connection Establishment: A multi-step handshake process that initiates the connection.
Data Transfer: Once established, data is sent between the two endpoints.
Connection Termination: Closes the connection and releases associated resources.

During these phases, the Internet socket (the local endpoint of the communication) experiences a series of state changes.

TCP Socket States Explained¶

Here are the most common states you might encounter when listing connections with netstat or ss:

ESTABLISHED: The TCP connection is established and ready to transfer data. This is the desired state for an active connection.
SYN_SENT: The local socket has sent a SYN packet to the remote server and is waiting for a SYN-ACK response. Indicates that a connection attempt is being made.
SYN_RECV: The server has received a SYN packet from a client and has responded with a SYN-ACK, now waiting for an ACK from the client. It is part of the three-way handshake.
FIN_WAIT1: The local socket has closed its side of the connection and has sent a FIN packet, waiting for an ACK from the remote peer. The connection is closing actively.
FIN_WAIT2: The local socket has received the ACK to its FIN, but is still waiting for a FIN packet from the remote peer to fully close the connection.
TIME_WAIT: The socket has waited after closing the connection to ensure that all packets have been transmitted and received by both sides, and to allow duplicate packets to die out in the network. It is a necessary wait state before fully releasing resources.
CLOSE: The socket is not in use and there is no connection.
CLOSE_WAIT: The remote peer has closed its side of the connection (sent a FIN and been ACKed), and the local socket is waiting for the local application to close its own side.
LAST_ACK: The local socket has sent its FIN to the remote peer, and is waiting for the final ACK from the remote peer. This happens after a CLOSE_WAIT.
LISTEN: The socket is waiting for incoming connections. Only seen with the --listening (-l) or --all (-a) options of netstat/ss.
CLOSING: Both sides of the connection have tried to close simultaneously, and the local socket is in the process of sending/receiving FIN and ACK.
UNKNOWN: The socket state is unknown or cannot be determined.

Tools: `netstat` and `ss`¶

You can see these states using commands like:

netstat -tn   # Shows TCP connections, without name resolution (-n)
ss -tn        # Modern and faster version of netstat

The -t option filters for TCP connections and -n avoids name resolution, which speeds up the output and shows IPs directly.

Conclusion¶

Understanding TCP connection states is vital for diagnosing network issues, identifying unresponsive or stuck processes, and understanding how applications behave in terms of connectivity. Knowing what each state means allows you to debug problems more effectively on your GNU/Linux system.

Original article: 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

Reduce Noise in Your Python Logs: A Smart Approach

2025-12-25T13:00:00+01:00

Python's logging module is a powerful tool, but it can quickly become a source of "noise" when third-party libraries flood your logs with messages that are not relevant to debugging your application. Keeping logs clean is crucial for efficiently identifying issues and understanding the actual behavior of your code.

The Problem with `basicConfig()`¶

Many Python developers start using logging with logging.basicConfig(). While convenient, this function configures the "root logger" of your application. The problem is that all loggers in your application, including third-party libraries, are children of the root logger.

This means that if you configure the root logger to the DEBUG level, you will start seeing debug messages from all the libraries you use, which can be overwhelming and hide the truly important information from your own code.

The Recommended Solution: Granular Configuration¶

To avoid this overload, the strategy involves taking more granular control of logging levels.

Name Your Loggers: Follow the best practice of creating a specific logger for each module of your application using logging.getLogger(__name__). This creates a hierarchy of loggers that you can control individually.

```python

my_module.py¶

import logging logger = logging.getLogger(name)

def my_function(): logger.info("My function is running.") logger.debug("Debug message in my function.") ```
Configure Levels on Application-Specific Loggers: Instead of modifying the root logger, set the logging level on the highest-level logger of your own application. This allows your modules to log messages at detailed levels (e.g., DEBUG), while third-party libraries (which will remain children of the unconfigured root logger, or with a less verbose default configuration) will only show more critical messages (e.g., WARNING or ERROR).

```python

main.py (or your main entry point)¶

import logging from my_package.my_module import my_function

Create a logger for your main application¶

app_logger = logging.getLogger('my_package') # Or the name of your main package app_logger.setLevel(logging.DEBUG)

Create a handler for output (e.g., to console)¶

handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter)

Add the handler to your application logger¶

app_logger.addHandler(handler)

Now, the root logger (and its children, the libraries) will not be directly affected¶

You can control the level of specific libraries if you need to¶

logging.getLogger('requests').setLevel(logging.WARNING) # Example for a library

my_function() ```

Advanced Tip: First-Party Dependency Management¶

For projects with multiple internal modules or "first-party" dependencies (that you develop yourself), you can wrap getLogger() to always prefix the logger name with your organization or project name (e.g., ORG_NAME.my_module). This allows you to control the logging level of an entire set of internal loggers more easily.

Conclusion¶

Reducing noise in your logs not only makes them more readable but also more reliable as a debugging tool. By adopting a granular approach to Python's logging configuration, you ensure that critical information from your application is not lost in a sea of messages from third-party libraries.

Original article: 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!

Kitty as a Quick Access Terminal: The Convenience of a Dropdown

2025-12-25T12:30:00+01:00

One of the most appreciated features of terminals like Yakuake or Guake is their ability to appear and disappear instantly with a single keystroke, offering quick access without interrupting the workflow. Kitty, the GPU-accelerated terminal, can also replicate and improve this experience, combining its power with the convenience of a dropdown terminal.

The idea is simple: a terminal that resides in the background and shows or hides on demand. This is especially useful for quick commands, monitoring, or any task that requires brief interaction with the command line.

Kitty for Quick Access¶

Kitty does not have a native "dropdown" function like Yakuake, but its flexibility and scripting capabilities allow it to be configured for this purpose. The key lies in:

Dedicated Kitty instances: You can launch a Kitty instance in a "daemon" or background mode, ready to be activated.
Remote control: Kitty offers a remote control protocol (kitty @) that allows interacting with already open instances.
Window Manager: Using the rules of your window manager (KDE, Gnome, i3, Sway, etc.) to assign a hotkey that shows or hides the Kitty window.

Example Configuration¶

Here is a conceptual approach to achieve a quick access terminal with Kitty and a window manager (e.g., with xdotool for Xorg environments, or similar functions in Wayland):

Launch Kitty in the background: You can have a Kitty instance that starts automatically with your session and is configured to be "floating" and with a specific size.
Toggle Script: Create a small script that checks if the "always visible" Kitty window is active and, if it is, hides it; if not, shows it.

```bash

!/bin/bash¶

KITTY_CLASS="kitty-dropdown" # A custom class for the Kitty window KITTY_ID=$(xdotool search --class "$KITTY_CLASS" | head -n 1)

if [ -z "$KITTY_ID" ]; then # If it doesn't exist, launch it kitty --class "$KITTY_CLASS" & else # If it exists, toggle visibility if xdotool getwindowfocus getwindowpid | grep -q "$(xdotool getwindowpid "$KITTY_ID")"; then xdotool windowminimize "$KITTY_ID" else xdotool windowmap "$KITTY_ID" # Show the window xdotool windowraise "$KITTY_ID" # Make sure it's on top xdotool windowfocus "$KITTY_ID" # Give it focus fi fi ```
Keyboard shortcut in your window manager: Assign a global key (e.g., F12) to run this script.

```

Example in ~/.config/i3/config or similar¶

bindsym $mod+F12 exec --no-startup-id /path/to/your/toggle-kitty-dropdown.sh ```

And in your kitty.conf, you can configure the Kitty instance to have the specific class and a suitable position/size:

```

kitty.conf (configuration for the dropdown instance)¶

window_class_members kitty-dropdown initial_window_width 80% initial_window_height 40% window_border_width 0

... other appearance settings ...¶

```

This method gives you the speed and convenience of a dropdown terminal, but with all the power and customization that Kitty offers. It's the best of both worlds!

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!

Essential Keyboard Shortcuts in Kitty: Mastering Your Terminal

2025-12-25T12:15:00+01:00

Kitty is a terminal that shines for its performance and high customizability, but where it truly excels is in its keyboard-driven interface. Mastering its shortcuts will allow you to navigate, manage, and manipulate your terminal sessions with amazing efficiency.

Discover Your Shortcuts: `show_shortcuts`¶

The fastest way to know all the keyboard shortcuts configured in your Kitty instance is by using its own functionality:

kitty +kitten show_shortcuts

This will open an interactive window where you can see all shortcuts, both the default ones and those customized in your kitty.conf.

Essential Shortcuts for Every Day¶

Here are some of the most useful shortcuts that will help you optimize your workflow the most:

Window and Split Management (Panes)¶

ctrl+shift+enter: Opens a new Kitty window.
ctrl+shift+w: Closes the current Kitty window.
ctrl+shift+o: Splits the current window vertically (new pane to the right).
ctrl+shift+e: Splits the current window horizontally (new pane below).
ctrl+shift+f: Toggles between split panes (focus).
ctrl+shift+[ / ctrl+shift+]: Navigates between panes (left/right).
ctrl+shift+alt+[ / ctrl+shift+alt+]: Moves the active pane (left/right).

Tab Management¶

ctrl+shift+t: Opens a new tab.
ctrl+shift+q: Closes the current tab.
ctrl+shift+.: Moves to the next tab.
ctrl+shift+,: Moves to the previous tab.
ctrl+shift+alt+.: Moves the current tab to the right.
ctrl+shift+alt+,: Moves the current tab to the left.

Copy and Paste¶

Kitty has its own copy/paste implementation, which can be more reliable than the system one when working in remote environments or with multiplexers:

ctrl+shift+c: Copies the selected text to the system clipboard.
ctrl+shift+v: Pastes text from the system clipboard.

Font and Appearance Control¶

ctrl+shift+= (or +): Increases the font size.
ctrl+shift+-: Decreases the font size.
ctrl+shift+backspace: Resets the font size to the default value.
ctrl+shift+k: Enters "scrollback" mode (to search or select historical text).

Customizing Your Shortcuts in `kitty.conf`¶

You can add or modify keyboard shortcuts in your configuration file ~/.config/kitty/kitty.conf using the map directive. For example, to map F1 for a custom script:

map f1 launch --type=overlay bash -c "my_custom_script.sh"

Mastering these shortcuts will transform your interaction with the terminal, making it more fluid and intuitive. Experiment and customize Kitty to perfectly adapt to your work style!

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.

From Yakuake to Kitty: My Transition to a Modern Terminal

2025-12-25T12:00:00+01:00

For years, Yakuake has been my go-to terminal in KDE desktop environments. Its quick access convenience, dropping down and hiding with a simple keystroke, is undeniable. However, in my constant search for optimization and performance, I decided to explore alternatives, and Kitty emerged as a standout option.

Why the Switch?¶

Although Yakuake is excellent in its niche, Kitty offers a series of advantages that align better with the demands of a modern and demanding workflow:

GPU Accelerated Performance: Kitty is designed to leverage the graphics card, resulting in extremely fast and fluid text rendering, especially noticeable in terminals with a lot of scrolling or intense output.
Integrated Multiplexing: Unlike Yakuake, which relies on traditional tab/window sessions, Kitty incorporates its own multiplexing system (similar to tmux or screen) that allows splitting windows, creating tabs, and organizing panes natively and efficiently.
Extensive Configurability: kitty.conf allows deep customization, from keyboard shortcuts to appearance, themes, and behavior.
Modern Support: Excellent support for Wayland (the future of Linux on the desktop), font ligatures (like Fira Code), and an ecosystem of "kittens" (scripts and extended functionalities).
Cross-platform: Although my main use is on Linux, the ability to have a consistent terminal experience across different operating systems is a plus.

Adapting to Kitty¶

The transition required adjusting some habits, mainly the way sessions and quick access are managed. However, the advantages far outweigh the initial learning curve. The speed, fluidity, and power of Kitty's built-in features make it an indispensable tool for my daily life.

Configuring Kitty is a simple process through its kitty.conf file, where all aspects of the terminal are defined. We will explore more about its configuration and keyboard shortcuts in future posts.

If you are looking to take your terminal experience to the next level, migrating to Kitty is a step I highly recommend.

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

Poe the Poet: Automating Tasks in Python Projects with uv

2025-12-25T11:00:00+01:00

Managing Python projects often involves executing various custom tasks, from building documentation to running tests or helper scripts. While uv has greatly simplified dependency management, how to integrate and execute these commands directly from pyproject.toml has been a point of debate. This is where Poe the Poet emerges as an elegant and effective solution.

What is Poe the Poet?¶

Poe the Poet is a tool that allows you to define custom "scripts" or "tasks" directly in your pyproject.toml file. These tasks can be any command you want to run in the context of your Python environment, making workflow automation much cleaner and centralized. It solves the problem of having to resort to Makefile or other external scripts for project-specific tasks.

How to Use Poe the Poet with uv¶

Integrating Poe the Poet into a project using uv is straightforward:

Add poethepoet to your dev dependencies: First, ensure that poethepoet is included in your development dependencies group (e.g., dev) in pyproject.toml.

[project]
# ... other project configurations ...

[tool.uv]
dev-dependencies = [
    "black",
    "ruff",
    "poethepoet>=0.38.0", # Add Poe the Poet here
]

Define custom tasks: Then, you can add a [tool.poe.tasks] section in your pyproject.toml to define your custom commands.

[tool.poe.tasks]
docs = "sphinx-build -M html docs docs/_build"
livehtml = "sphinx-autobuild -b html docs docs/_build"
cog = "cog -r docs/*.md"

Running Tasks with `uv run`¶

Once Poe the Poet is configured and your tasks are defined, you can easily execute them using uv run:

# To build the documentation
uv run poe docs

# For the live preview server
uv run poe livehtml

# To run the 'cog' command
uv run poe cog

Benefits¶

Centralization: All your custom tasks live in pyproject.toml, alongside your dependencies.
Integration with uv: Tasks run in the virtual environment managed by uv, ensuring all necessary tools are available.
Simplification: Avoids the need for Makefile or complex bash scripts for common tasks.
Consistency: Promotes a more consistent and shareable workflow among collaborators.

Poe the Poet offers a robust and elegant way to extend the capabilities of uv for task automation in Python projects, enhancing the development experience.

Original article: 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

How I Use Git Worktrees for Concurrent Work

2025-07-23T06:12:00+02:00

Aleksey Kladov shares his unique approach to using git worktrees, which goes beyond simply switching branches and becomes a complete methodology for concurrent work.

The Core Philosophy

"Git is not a version control system, Git is a toolbox for building a VCS"

This perspective completely changes how we think about git. Instead of limiting ourselves to basic functionalities, we can create our own optimized workflow.

The 5 Specialized Worktrees

The author maintains 5 worktrees, each with a specific purpose:

main - Read-only snapshot - Clean reflection of remote main - Reference for comparisons - Never modified locally
work - Main workspace - Day-to-day active development - Frequent commits with minimal messages - Detached HEAD for maximum flexibility
review - Dedicated to code reviews - Clean context to analyze PRs - Without interfering with ongoing work
fuzz - Long-running tests - Fuzzing and tests that last hours - Runs in parallel without blocking development
scratch - Unrelated quick tasks - Experiments - Urgent fixes - Ad-hoc investigations

# Typical directory structure
~/projects/my-project/
├── main/        # main worktree
├── work/        # active development
├── review/      # reviews
├── fuzz/        # testing
└── scratch/     # experiments

Advantages of the Approach

Truly Concurrent Work

Multiple coding activities simultaneously
No need for stash or complex branch switching
Clean separation of contexts

Frictionless Workflow

Instant switching between tasks
Frequent commits without pressure for perfect messages
Free experimentation on detached HEAD

Real Parallelization

Fuzzing running while you develop
Reviews without interrupting main work
Background tests without blocks

Advanced Techniques

Strategic Detached HEAD

# In the 'work' worktree, work without a branch
git checkout --detach HEAD
# Frequent commit, reorganize later
git commit -m "wip"

Custom Scripts for Common Operations

# Script to quickly create/switch worktrees
#!/bin/bash
git worktree add "../$1" "$2"
cd "../$1"

Integration Flow

# From the 'work' worktree
git log --oneline  # review commits
git reset HEAD~5   # undo temporary commits
git add -p         # select changes
git commit         # clean final commit

Key Lessons

Git is flexible: There is no "one right way" to use git
Automate the repetitive: Custom scripts for common operations
Separate contexts: Each type of work deserves its own space
Cheap commits: Commit frequently, organize later

This approach transforms git from a versioning tool into a complete workflow management platform, maximizing productivity through truly concurrent work.

Original article: 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

Hybrid Search with SQLite: Vector + Full-Text

2024-10-06T11:43:00+02:00

Simon Willison presents a fascinating approach to combining vector search and traditional full-text search in SQLite, using a technique called Reciprocal Rank Fusion (RRF).

The Core Problem

When we have vector searches (based on semantic similarity) and full-text searches (FTS), each returns scores on completely different scales:

FTS returns relevance scores
Vector search returns similarity distances

How to combine these results effectively?

The Solution: Reciprocal Rank Fusion

The RRF technique avoids comparing incompatible scores and instead relies on the ranking of each result within its respective search method.

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 (
    -- FTS subquery with row_number()
    SELECT *, row_number() OVER (ORDER BY rank) as fts_rank
    FROM fts_search(:query)
) fts
FULL OUTER JOIN (
    -- Vector subquery with 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;

Advantages of the Hybrid Approach

Flexibility: Allows adjusting weights between FTS and vector search
Robustness: Results can appear in one or both methods
Scalability: Does not require complex score normalization
Simplicity: A single SQL query handles all the logic

SQLite as a Unified Platform

With extensions like sqlite-vec, SQLite becomes a powerful platform for:

Full-text search (Native FTS5)
Vector embedding search
Hybrid combination of both techniques

This approach democratizes advanced search techniques, making them accessible without complex infrastructure.

Original article: 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

Geospatial Data Conflation with DuckDB and Embeddings

2024-10-01T07:12:00+02:00

Drew Breunig presents a fascinating case study of geospatial data conflation: the process of identifying and merging similar records from different sources.

The Challenge: Integrating Restaurant Data

The goal was to connect two data sources:

Restaurant inspections from Alameda County
Place data from Overture Maps Foundation

Two datasets with similar information but structured differently.

Modern Stack Tools

DuckDB as the main engine

Staging and querying large volumes of data
Native support for geospatial formats
Exceptional performance for exploratory analysis

H3 for spatial grouping

-- Group nearby places using H3 hexagons
SELECT h3_cell_to_lat_lng(h3_latlng_to_cell(lat, lng, 9)) as h3_9
FROM places

Ollama for local embeddings

ML framework running locally
Generation of contextual embeddings
No dependence on external APIs

Three Matching Approaches

1. Exact Name Matching

Result: ~31% matches
Limitations: Chain names, unit numbers in addresses

2. String Similarity (Jaro-Winkler)

-- Comparison combining name and address
WHERE jaro_winkler_similarity(name1, name2) > 0.8
  AND levenshtein(address1, address2) < 5

Result: ~68% matches
Disadvantage: Complex SQL with many conditional rules

3. Embedding-Based Matching

# Generate contextual description
description = f"{name} at {address} in {city}"
embedding = ollama.embeddings(description)

Result: ~71% matches
Advantages: Simpler pipeline, greater flexibility
Disadvantage: Longer processing time

Key Insights

There is no silver bullet - each method has specific strengths
Local tools are powerful - DuckDB + Ollama allow sophisticated analysis without cloud
Embeddings are promising - especially for cases with complex context
Conflation requires iteration - combining multiple techniques improves results

The Future of Data Integration

This work shows how modern tools democratize techniques that previously required complex infrastructure. The combination of:

Analytical databases (DuckDB)
Spatial indices (H3)
Local ML (Ollama)

...opens new possibilities for intelligent data integration.

Original article: 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

HTTPX: Modern HTTP Client for Python

2024-09-23T00:07:00+02:00

HTTPX presents itself as the natural evolution of the popular requests library, maintaining its simplicity but adding modern capabilities that current applications need.

Why HTTPX?

While requests remains excellent for synchronous use, HTTPX addresses limitations that have arisen over time:

No native async support in requests
HTTP/2 not available
Limited type hints
Less precise timeouts

Installation and Configuration

# Basic installation
pip install httpx

# With HTTP/2 support
pip install httpx[http2]

# With advanced compression
pip install httpx[brotli,zstd]

Familiar API, Modern Capabilities

Synchronous usage - Compatible with requests:

import httpx

# Basic GET
r = httpx.get('https://api.github.com/users/octocat')
print(r.status_code)  # 200
print(r.json()['login'])  # 'octocat'

# POST with JSON data
payload = {'key': 'value'}
r = httpx.post('https://httpbin.org/post', json=payload)

# Custom headers
headers = {'User-Agent': 'my-app/1.0'}
r = httpx.get('https://api.example.com/data', headers=headers)

The Power of Async/Await

Asynchronous client - The real advantage:

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())

Advanced Features

Strict Timeouts:

# Granular timeout
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')

Data Streaming:

# Streaming download
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):
            # Process chunk
            process_data(chunk)

Testing with WSGI/ASGI Applications:

# Test FastAPI directly
from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

# Direct test without server
with httpx.Client(app=app, base_url="http://testserver") as client:
    r = client.get("/")
    assert r.json() == {"message": "Hello World"}

HTTP/2 and Persistent Connections

# Client with HTTP/2 and connection pooling
limits = httpx.Limits(max_keepalive_connections=5, max_connections=10)

async with httpx.AsyncClient(http2=True, limits=limits) as client:
    # Multiple requests reuse connections
    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")

Comparison: requests vs HTTPX

Feature	requests	HTTPX
Familiar API	✓	✓
Async support	✗	✓
HTTP/2	✗	✓
Type hints	Partial	Full
Precise timeouts	Basic	Advanced
WSGI/ASGI Testing	✗	✓
Streaming	Basic	Advanced

Ideal Use Cases

HTTPX is perfect for:

Concurrent APIs with async/await
Microservices that need HTTP/2
Application testing FastAPI/Django
Large-scale scraping with streaming
Modern applications with type safety

Keep requests for:

Simple scripts without concurrency
Legacy projects already established
Code with dependencies that require requests

The Future of HTTP in Python

HTTPX represents the way forward for HTTP applications in Python, offering:

Modern performance with async and HTTP/2
Developer experience improved with types
Integrated ecosystem with current frameworks
Compatibility that eases migration

It's time to consider HTTPX as the default HTTP client for new Python projects.

Official documentation: 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

Server-Sent Events: Simplified Real-Time Communication

2024-09-23T00:01:00+02:00

Server-Sent Events (SSE) represent an elegant and simple solution for implementing real-time communication in web applications when we only need the server to send data to the client.

What are Server-Sent Events?¶

SSE is a web standard that allows a server to automatically send data to a web page using a persistent HTTP connection. Unlike WebSockets, communication is unidirectional: only the server can send messages to the client.

Basic Implementation¶

Client (JavaScript)¶

// Create SSE connection
const eventSource = new EventSource('/api/events');

// Listen for generic messages
eventSource.onmessage = function(event) {
    console.log('Message received:', event.data);
    const data = JSON.parse(event.data);
    updateUI(data);
};

// Listen for custom events
eventSource.addEventListener('notification', function(event) {
    const notification = JSON.parse(event.data);
    showNotification(notification.title, notification.message);
});

// Handle errors
eventSource.onerror = function(event) {
    console.error('SSE Error:', event);
};

// Close connection
// eventSource.close();

Server (Python/Flask)¶

from flask import Flask, Response
import json
import time
import threading

app = Flask(__name__)

def generate_events():
    """Generator producing SSE events"""
    while True:
        # Generic event
        data = {
            'timestamp': time.time(),
            'users_online': get_users_count(),
            'server_status': 'running'
        }

        yield f"data: {json.dumps(data)}\n\n"

        time.sleep(10)  # Send every 10 seconds

@app.route('/api/events')
def stream_events():
    """SSE Endpoint"""
    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():
    """Send specific notification"""
    def notification_event():
        notification = {
            'title': 'New Update',
            'message': 'System updated successfully'
        }

        # Event with custom name
        yield f"event: notification\n"
        yield f"data: {json.dumps(notification)}\n\n"

    return Response(notification_event(), mimetype='text/event-stream')

Event Stream Format¶

SSE events follow a specific format:

event: message-type
data: {"key": "value"}
id: unique-message-id
retry: 3000

event: Event name (optional)
data: Message content
id: Unique identifier for reconnection
retry: Retry time in milliseconds

Ideal Use Cases¶

1. Real-Time Feeds¶

const newsSource = new EventSource('/api/news-feed');

newsSource.addEventListener('article', function(event) {
    const article = JSON.parse(event.data);
    addArticleToFeed(article);
});

2. Push Notifications¶

const notificationSource = new EventSource('/api/notifications');

notificationSource.onmessage = function(event) {
    const notification = JSON.parse(event.data);

    // Show browser notification
    if (Notification.permission === 'granted') {
        new Notification(notification.title, {
            body: notification.message,
            icon: '/icon.png'
        });
    }
};

3. Real-Time Dashboard¶

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);
});

Advantages of SSE¶

Simplicity: Simpler API than WebSockets
Automatic Reconnection: Browser retries automatically
Efficiency: Lower overhead than polling
Compatibility: Works over standard HTTP/HTTPS
Firewall-friendly: Does not require special ports

Important Limitations¶

Unidirectional: Only server → client
Connection Limits: Browsers limit simultaneous connections
Data Format: Text only (though JSON works fine)
No Native Compression: Unlike WebSockets

SSE vs WebSockets: When to Use Which?¶

Use SSE when:¶

You only need server → client
Simplicity is a priority
Periodic updates (feeds, notifications)
Compatibility with proxies/firewalls is important

Use WebSockets when:¶

You need bidirectional communication
Ultra-low latency is critical
Intensive data exchange
Full control over the protocol

Error Handling and Reconnection¶

const eventSource = new EventSource('/api/events');

let reconnectInterval = 1000;
const maxReconnectInterval = 30000;

eventSource.onopen = function() {
    console.log('SSE connection established');
    reconnectInterval = 1000; // Reset interval
};

eventSource.onerror = function(event) {
    console.error('SSE Error:', event);

    if (eventSource.readyState === EventSource.CLOSED) {
        // Manual reconnection with exponential backoff
        setTimeout(() => {
            console.log('Attempting to reconnect...');
            reconnectSSE();
        }, reconnectInterval);

        reconnectInterval = Math.min(reconnectInterval * 2, maxReconnectInterval);
    }
};

function reconnectSSE() {
    eventSource.close();
    eventSource = new EventSource('/api/events');
}

Conclusion¶

Server-Sent Events offers a pragmatic solution for real-time communication when WebSockets is overkill. Its simplicity, automatic reconnection, and compatibility make it an excellent choice for feeds, notifications, and real-time dashboards.

For applications requiring server-to-client updates without the complexity of WebSockets, SSE is the perfect tool.

Official documentation: 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.

About Versions

2017-05-01T18:04:00+02:00

Do you want to know the correct way to name versions? That's what PEP 440 is for: Version Identification and Dependency Specification.

Perhaps the most noteworthy thing is the use of those suffixes .dev0, etc. for eggs in development.

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.

MobaXterm. Much more than an ssh client

2017-04-11T14:07:00+02:00

As you know, I am not a Windows person. A Linux user for years, after going through multiple flavors of Debian, now my thing is OpenSuse Tumbleweed. But I also have a Windows 7 work computer that I use occasionally. For that, MobaXterm comes in very handy.

MobaXterm is a set of very interesting applications to work as in Linux and connect to remote computers: terminal, ssh client, X server, 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

PosteRazor: Create Giant Posters from Any Image

2017-02-24T20:06:00+01:00

PosteRazor is a free and open source tool that solves a daily problem: how to print a large image when you only have a home printer?

What does PosteRazor do?¶

PosteRazor takes a raster image and "cuts" it into pieces that can then be printed and assembled to form a complete poster. It converts a single image into a multi-page PDF document ready for printing.

Key Features¶

Wizard-like interface with 5 simple steps
Multi-platform: Windows, macOS, Linux
Web version available via WebAssembly
Completely free and open source

Ideal Use Cases¶

Decorative posters for home, school, or office
DIY projects for decoration
Printing giant images that exceed standard page size
Large format visual presentations

How does it work?¶

You load your image
You select the desired poster size
You configure your printer's page format
PosteRazor calculates the division automatically
You generate the PDF and print each page

The Perfect Solution¶

PosteRazor democratizes the creation of large posters. You no longer need expensive printing services - with any home printer you can create posters of any size you want.

Official site: 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

Unread Mail in Gmail's Primary Tab

2016-07-28T18:00:00+02:00

As always, another reminder note.

If you filter mail in gmail by unread (is:unread), you get all unread mail, which in my case always includes hundreds of notifications, social, promotions, or forums which is usually not what I'm looking for.

To search for unread emails from the Primary tab the query to perform is this:

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

Technical Documentation with Sphinx, Paver, and Cog

2016-07-14T00:47:00+02:00

Doug Hellmann presents a robust workflow for technical documentation that eliminates repetitive manual work and errors in code examples.

The Problem to Solve¶

"Automation is important for my sense of well being. I hate dealing with mundane repetitive tasks."

Common Challenges: - Keeping code examples updated - Multiple output formats (HTML, PDF, blog) - Repetitive tasks of building and publishing - Copy-paste errors in program output

The Solution: Trio of Tools¶

Sphinx: Documentation Engine¶

reStructuredText conversion to multiple formats
Customizable themes with Jinja templates
Automatic generation of indices and cross-references

Paver: Build Automation¶

# 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()

Solves: Automation of repetitive build processes

Cog: Automatic Code Insertion¶

.. cog::

   import cog
   import subprocess

   result = subprocess.run(['python', 'example.py'], 
                          capture_output=True, text=True)
   cog.out(result.stdout)

.. cog::

Key Advantage: Program output is automatically updated when regenerating documentation.

Production Workflow¶

1. Writing in reStructuredText¶

Usage Example
=============

We run the script:

.. cog::
   cog.out("$ python my_script.py\n")
   result = subprocess.run(['python', 'my_script.py'], 
                          capture_output=True, text=True)
   cog.out(result.stdout)
.. cog::

2. Automated Build¶

# A single command for everything
paver html

# Or for multiple destinations
paver all_formats

3. Multi-Destination Publishing¶

Python Module of the Week (PyMOTW)
Personal Blog
Project Website
O'Reilly Blog
PDF Documentation

Advantages of the Approach¶

Guaranteed Consistency¶

Examples always updated with real code
Uniform format across multiple destinations
No manual transcription errors

Maximized Efficiency¶

One source, multiple outputs
Complete automation of the pipeline
Focus on content, not process

Maintainability¶

Changes in a single source propagate automatically
Integrated testing of code examples
Unique versioning for all documentation

Practical Implementation¶

# full pavement.py
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

This workflow represents intelligent automation of technical documentation: write once, publish everywhere, always updated.

Original source: 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

Determining RAM slots in use on Linux

2016-07-13T20:28:00+02:00

How many RAM slots do you have occupied and how many are free? Linux provides tools to inspect memory configuration without opening the computer.

dmidecode: The Main Tool¶

Basic Memory Information¶

# View all memory information
sudo dmidecode -t memory

# Specific memory type (table 16)
sudo dmidecode -t 16

# Installed sizes only
sudo dmidecode -t memory | grep -i size

Typical Output:

Size: 8192 MB
Size: 8192 MB
Size: No Module Installed
Size: No Module Installed

Detailed Information per Slot¶

# Granular information for each slot (table 17)
sudo dmidecode -t 17

# Compact summary
sudo dmidecode -t 17 | grep -E "(Size|Locator|Speed|Type:)"

Information Provided: - Locator: Physical slot identifier (DIMM_A1, DIMM_B1, etc.) - Size: Installed capacity or "No Module Installed" - Type: DDR3, DDR4, etc. - Speed: Speed in MT/s

lshw: Alternative with Structured Format¶

# Memory information with lshw
sudo lshw -class memory

# Physical memory only (no cache)
sudo lshw -class memory | grep -A 10 "System Memory"

# More compact format
sudo lshw -short -class memory

Useful Scripts for Analysis¶

Occupied Slots Counter¶

#!/bin/bash
echo "=== RAM Slot Analysis ==="
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 "Total Slots: $TOTAL_SLOTS"
echo "Occupied Slots: $OCCUPIED_SLOTS" 
echo "Free Slots: $FREE_SLOTS"

Detailed Summary¶

#!/bin/bash
echo "=== Current RAM Configuration ==="
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": Empty"
}'

Additional Useful Information¶

Maximum Supported Capacity¶

# Maximum total capacity
sudo dmidecode -t 16 | grep "Maximum Capacity"

# Maximum number of devices
sudo dmidecode -t 16 | grep "Number Of Devices"

Speed and Type Verification¶

# Configured speed
sudo dmidecode -t 17 | grep -E "(Speed|Configured)"

# Memory type
sudo dmidecode -t 17 | grep "Type:" | grep -v "Error"

Example of Interpreted Output¶

$ 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

Interpretation: - 4 total slots (DIMM_A1, A2, B1, B2) - 2 slots occupied with 8GB DDR4 each - 2 free slots available

Important Limitations¶

⚠️ Accuracy: Command-line tools may not perfectly reflect physical hardware

⚠️ Privileges: Root permissions are required to access DMI information

⚠️ Compatibility: Some embedded systems may not provide complete information

For maximum certainty, physical inspection is still recommended, but these tools provide sufficiently accurate information for most cases.

Original source: 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

Introduction to High-Frequency Trading Systems

2016-06-27T11:51:00+02:00

High-Frequency Trading (HFT) programs represent the extreme automation of financial investments, operating at speeds that surpass any human capability.

What is HFT?¶

HFT systems are programs designed to invest in financial markets with the following characteristics:

Massive volume: They buy and sell up to tens of thousands of stocks or options per day
Extreme speed: Each operation can last fractions of a second
Small margins: Very reduced profit per individual operation
Cumulative effect: In their global computation, they become very effective

Fundamental Principles¶

Speed as a Competitive Advantage¶

Ultra-low latency: Every millisecond counts
Physical proximity: Servers close to exchanges
Specialized hardware: FPGA, optimized fiber optic cables

Algorithmic Strategies¶

Market making: Providing constant liquidity
Statistical arbitrage: Taking advantage of price discrepancies
Temporal arbitrage: Exploiting differences between markets

Key Technologies¶

Optimized Hardware¶

FPGA (Field-Programmable Gate Arrays) for ultra-fast processing
Co-located servers in exchange datacenters
High-speed fiber optic networks

Specialized Software¶

Low-latency algorithms
Optimized network protocols
Real-time risk management systems

Impact on Markets¶

Benefits¶

Greater liquidity in markets
Tighter spreads between bid/ask
Improved price efficiency

Controversies¶

Increased volatility in times of stress
Unfair advantage over traditional investors
Potential market manipulations

The Future of HFT¶

The race for speed continues to evolve towards: - Artificial Intelligence and machine learning - Real-time sentiment analysis - Quantum computing experimental

HFT exemplifies how technology completely redefines traditional industries, creating new opportunities and ethical challenges.

Original source: 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

How to Find Live Hosts on Your Local Network

2016-06-27T07:59:00+02:00

Discovering which devices are active on your local network is a fundamental task for network administrators and security professionals. Here are the most effective techniques.

Nmap: The Main Tool¶

Basic Host Scan¶

# Simple Ping scan
nmap -sn 192.168.1.1/24

# Scan with specific TCP ports
nmap -sP -PS22,3389 192.168.1.1/24

# UDP scan for special devices
nmap -sP -PU161 192.168.1.1/24

-sn: Host discovery only, no port scan -PS: TCP SYN discovery on specific ports -PU: UDP discovery (useful for embedded devices)

More Exhaustive Scans¶

# Full scan with OS detection
nmap -A 192.168.1.1/24

# TCP Connect Scan (less intrusive)
nmap -sT 192.168.1.1/24

# Firewall bypass with fragmentation
nmap -f -sS 192.168.1.1/24

Alternative Tools¶

arp-scan: ARP Based¶

# Local subnet scan
arp-scan 192.168.12.0/24

# With specific interface
arp-scan -I eth0 172.16.17.0/24

# Simplified local scan
arp-scan -l

Advantage: Works even with strict firewalls

netdiscover: Passive/Active Discovery¶

# Active discovery
netdiscover -r 172.16.17.0/24

# Passive mode (listen only)
netdiscover -p

# Fast mode
netdiscover -f -r 192.168.1.0/24

fing: Mobile Scanner¶

# Fast scan
fing -r 1

# With manufacturer details
fing -o table,csv

Post-Scan Verification¶

Check ARP Table¶

# View current ARP table
arp -a -n

# On modern systems
ip neigh show

# Clear and rescan
sudo arp -d -a
ping -c 1 192.168.1.{1..254}
arp -a

Advanced Techniques¶

Wireshark for Passive Analysis¶

Capture traffic on the network interface
Filter by ARP: arp
Analyze broadcast traffic
Identify devices by traffic patterns

Automation Scripts¶

#!/bin/bash
# Full local network scan
echo "Scanning network..."
nmap -sn $(ip route | grep -E "^192|^10|^172" | awk '{print $1}' | head -1)
echo "Verifying ARP..."
arp -a -n | grep -v "incomplete"

Important Considerations¶

Firewall Limitations¶

Some devices block ping/ICMP
Corporate firewalls may filter scans
Different ports may reveal "hidden" devices

Legal Considerations¶

⚠️ Authorization needed: Only scan your own networks ⚠️ Corporate policies: Verify before scanning in enterprise environments

Optimization by Network Type¶

# Home network (routers, IoT)
nmap -sn --min-rate 1000 192.168.1.1/24

# Corporate network (servers, stations)
nmap -sP -PS80,443,22,3389 10.0.0.0/8

# Industrial network (embedded devices)
nmap -sP -PU161,502 172.16.0.0/12

The combination of multiple techniques provides the most complete picture of active devices on your network.

Original source: 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

Powerful Command Line Tools for Developers

2016-06-07T11:36:00+02:00

The command line remains the most powerful environment for developers. These specialized tools dramatically expand your debugging, testing, and analysis capabilities.

Curl: The HTTP Swiss Army Knife¶

# Get your public IP
curl ifconfig.me

# Inspect response headers
curl -I https://example.com

# POST with JSON data
curl -X POST -H "Content-Type: application/json" \
     -d '{"key":"value"}' https://api.example.com

Main usage: Network data transfer, API testing, HTTP inspection.

Ngrep: Grep for Network Traffic¶

# Filter HTTP traffic by keyword
ngrep -i "password" port 80

# Capture by specific IP
ngrep host 192.168.1.100

# Monitor traffic on specific port
ngrep port 443

Main usage: Network packet analysis, protocol debugging, traffic monitoring.

Netcat (nc): The Networking Swiss Army Knife¶

# Port scanning
nc -zv example.com 1-1000

# Transfer file between servers
# Receiver: nc -l 1234 > received_file
# Sender: nc destination_server 1234 < file_to_send

# Create simple HTTP server
echo "HTTP/1.1 200 OK\n\nHello world" | nc -l 8080

Main usage: Port scanning, file transfer, connectivity testing.

Sshuttle: Easy VPN with SSH¶

# Tunnel all traffic
sshuttle -r user@server 0.0.0.0/0

# Tunnel only a subnet
sshuttle -r user@server 192.168.1.0/24

# Bypass geo-blocking
sshuttle -r remote_server 0.0.0.0/0 --dns

Main usage: Secure tunneling, geo-restriction bypass, protection on public WiFi.

Siege: HTTP Load Bombardment¶

# Simple load test
siege -c 25 -t 60s https://example.com

# Test with multiple URLs
siege -c 50 -t 30s -f urls.txt

# Specific benchmark
siege -c 100 -r 10 https://api.example.com/endpoint

Main usage: Performance testing, HTTP benchmarking, load simulation.

Mitmproxy: Spy on HTTP/S Traffic¶

# Basic proxy
mitmproxy -p 8080

# Transparent mode
mitmproxy --mode transparent

# Save traffic to file
mitmdump -w capture.flow

Main usage: Web application debugging, HTTPS traffic inspection, API analysis.

Typical Workflow¶

# 1. Scan connectivity
nc -zv api.example.com 443

# 2. Analyze response
curl -I https://api.example.com

# 3. Monitor traffic
ngrep -i "api" port 443

# 4. Load test
siege -c 20 -t 30s https://api.example.com

# 5. Detailed debugging
mitmproxy -p 8080

Why Command Line?¶

Speed: No GUI overhead
Scriptability: Complete automation
Flexibility: Combination with pipes and redirects
Universality: Available on any server

These tools turn your terminal into a complete networking and testing laboratory.

Original source: 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

Sysdig: Cloud-Native Security Platform with AI

2016-02-10T14:37:00+01:00

Sysdig is a cloud security platform that provides comprehensive, real-time security solutions for cloud-native environments, resolving the conflict between the needs of security and development teams.

Key Features¶

Intelligent Security AI¶

Contextual AI that understands cloud environments and guides actionable insights
76% reduction in mean time to resolution (MTTR)

Real-Time Visibility¶

Continuous monitoring of cloud activities and potential risks
Threat detection in 2 seconds
Filters noise to highlight only critical issues

Open Innovation¶

Based on open source technologies like Falco
Transparency and customization in cloud security

Key Benefits¶

95% savings in vulnerability management time
98% reduction in vulnerability noise
Ultra-fast threat detection

Value Proposition¶

Sysdig enables security and development teams to work more effectively, enabling rapid innovation without compromising security. The platform is used by major companies like IBM, Booking.com, and Neo4j to secure their cloud environments.

This tool represents the future of cloud-native security: intelligent, fast, and uncompromising.

Official site: 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

Python: Create Repeating Generators

2016-02-09T10:10:00+01:00

Generators in Python are "one-shot" - they can only be iterated once. How to create generators that can be reused multiple times?

The Problem¶

def my_generator():
    yield 1
    yield 2
    yield 3

gen = my_generator()
print(list(gen))  # [1, 2, 3]
print(list(gen))  # [] - Empty!

Solution 1: Class Approach (Most Robust)¶

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

# Usage
@multigen
def my_repeatable_generator(max_num):
    for i in range(max_num):
        yield i

gen = my_repeatable_generator(3)
print(list(gen))  # [0, 1, 2]
print(list(gen))  # [0, 1, 2] - Works!

Solution 2: itertools.cycle() for Infinite Sequences¶

import itertools

# Repeat a sequence infinitely
repeating_gen = itertools.cycle([1, 2, 3])

# Take only the first 9 elements
result = list(itertools.islice(repeating_gen, 9))
print(result)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

Solution 3: Lambda Wrapper (Simple)¶

def my_generator():
    yield 1
    yield 2
    yield 3

# Wrapper to create new instance each time
repeatable_generator = lambda: my_generator()

print(list(repeatable_generator()))  # [1, 2, 3]
print(list(repeatable_generator()))  # [1, 2, 3]

Solution 4: Factory Function¶

def create_generator(data):
    def generator():
        for item in data:
            yield item
    return generator

# Usage
gen_factory = create_generator([1, 2, 3])
gen1 = gen_factory()
gen2 = gen_factory()

print(list(gen1))  # [1, 2, 3]
print(list(gen2))  # [1, 2, 3]

When to use each approach?¶

Decorator Class (`@multigen`)¶

Complex generators with parameters
Maximum flexibility and reuse
Preserves metadata of the original generator

`itertools.cycle()`¶

Infinite repetition of small sequences
Known cyclic patterns
Very efficient in memory

Lambda Wrapper¶

Simple cases without parameters
Rapid prototyping
Stateless generators

Factory Function¶

Balance between simplicity and flexibility
Generators with initial configuration
More explicit code

Performance Considerations¶

⚠️ Memory: Repeatable generators may require storing initial parameters ⚠️ CPU: Each iteration recalculates from the start

The choice depends on whether you need exact repetition or efficient reuse.

Original source: 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.

Middle click in firefox

2016-01-01T07:00:00+01:00

Another reminder note. I usually open links in a new window in firefox using the middle button. It often happens to me that I have a url in the clipboard and firefox then opens it for me instead of the link. To avoid this, simply go to about:config and set the property middlemouse.contentLoadURL to 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

Bootstrap: Two Links in the Same Row in Dropdown

2015-12-15T10:40:00+01:00

Sometimes you need to place two links side by side in the same row within a Bootstrap dropdown. The solution combines structured HTML and CSS with flexbox.

The Problem¶

By default, Bootstrap renders dropdown links as block elements, occupying the entire row:

<!-- Default behavior: each link on its row -->
<li><a href="#">Link 1</a></li>
<li><a href="#">Link 2</a></li>

The Solution¶

Structured HTML¶

<li class="hz">
    <a href="#">On the third row</a>
    <a href="#">Also on the third row</a>
</li>

Key: Multiple <a> links within the same <li> with a custom class.

CSS with Flexbox¶

.open > ul > li.hz {
    display: inline-flex !important;
}

Key: inline-flex overrides Bootstrap's default block display.

Complete Implementation¶

<div class="dropdown">
    <button class="btn btn-default dropdown-toggle" data-toggle="dropdown">
        Menu <span class="caret"></span>
    </button>
    <ul class="dropdown-menu">
        <li><a href="#">First option</a></li>
        <li><a href="#">Second option</a></li>
        <li class="hz">
            <a href="#">Option A</a>
            <a href="#">Option B</a>
        </li>
        <li><a href="#">Last option</a></li>
    </ul>
</div>

Additional Considerations¶

Spacing between links¶

.hz a {
    margin-right: 10px;
}
.hz a:last-child {
    margin-right: 0;
}

Responsive¶

@media (max-width: 768px) {
    .open > ul > li.hz {
        display: block !important;
    }
}

When to use it?¶

Related actions (Edit/Delete)
Binary options (Yes/No, Enable/Disable)
Compact navigation in tight spaces

This technique maintains correct HTML semantics while leveraging the flexibility of flexbox for more complex layouts.

Original source: 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)

Galen Framework: Automated Testing for Responsive Design

2015-11-13T18:20:00+01:00

Galen Framework is an automated testing tool designed specifically to test responsive web designs. Its main purpose is to simplify layout testing by verifying the positioning and appearance of web elements on different device sizes.

Key Features¶

Intelligent Layout Testing¶

"Layout testing seemed always a complex task. Galen Framework offers a simple solution: test location of objects relatively to each other on page."

Full Responsive Support¶

Automatic resizing of the browser to defined sizes
Cross-device testing in multiple resolutions
Rule verification specific per screen

Human and Flexible Syntax¶

header
    width: 100% of screen/width
    height: 50px

sidebar
    below: header
    width: 200px
    left-of: content 10px

Advanced Capabilities¶

Selenium Grid compatibility
Visual testing with image comparison
Color scheme verification
Detailed HTML reports with highlighted errors

Multi-Language Support¶

Tests written in: - JavaScript - Java - Other languages with integrated parameterization

Why Galen?¶

Before Galen, layout testing was complex and error-prone. Galen introduces:

Declarative syntax easy to read
Relational verification between elements
Native responsive testing
Visual reports understandable

Typical Use Case¶

// Open browser, resize and test
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 democratizes responsive design testing, making layout testing as easy as functional testing.

Open source framework: 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

The Story Behind X-Forwarded-For and X-Real-IP

2015-10-21T23:05:00+02:00

Determining the client's real IP in proxy architectures is more complex than it seems. The X-Forwarded-For and X-Real-IP headers have different purposes and limitations.

X-Forwarded-For: The Full Chain¶

Format and Purpose¶

X-Forwarded-For: client, proxy1, proxy2

Tracks the original IP of the client through multiple hops
Accumulates IPs as it passes through proxies
Not mandatory for all proxies

Critical Limitations¶

⚠️ Easily forgeable: A client can add fake IPs ⚠️ Potentially unreliable for determining the real IP

X-Real-IP: The Direct Approach¶

Characteristics¶

Less documentation officially available
Commonly used alongside X-Forwarded-For
Simpler approach to passing the client IP

Limitation¶

"Not many good info or specs about this one" - No definitive standards

Recommended Nginx Configuration¶

To extract the most accurate IP:

# Configure known proxies
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;

# Enable recursive processing
real_ip_recursive on;

# Use X-Forwarded-For as source
real_ip_header X-Forwarded-For;

The Real Challenge¶

Determining the "real" client IP is inherently complex due to:

Multiple network hops
Uncooperative proxies
Potential IP spoofing
Lack of uniform standards

Best Practices¶

Validate trusted sources of headers
Correctly configure known proxies
Do not blindly trust client headers
Implement logging for debugging

Real reliability depends more on your network architecture than on the specific headers used.

Original source: Distinct Place

Nginx: Configuring X-Forwarded-For in Reverse Proxy

2015-10-21T23:05:00+02:00

When you use Nginx as a reverse proxy, you need the backend server to see the client's real IP, not the proxy's IP. The X-Forwarded-For header solves this problem.

The Problem¶

Without configuration, the backend server only sees the Nginx proxy IP, losing crucial information about the real client for: - Accurate access logs - Correct geolocation - Rate limiting by real IP - Reliable traffic analysis

Solution 1: Simple IP¶

proxy_set_header X-Forwarded-For $remote_addr;

Usage: When Nginx is the only proxy in the chain. Result: Header contains only the original client IP.

Solution 2: IP Chain¶

proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

Usage: When there are multiple proxies in the chain. Result: Preserves existing IPs and adds the current one.

Practical Configuration¶

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;
    }
}

X-Real-IP: Most recent client IP
X-Forwarded-For: Complete chain of IPs
X-Forwarded-Proto: Original protocol (http/https)
Host: Original hostname

Verification¶

# On the backend server, check the headers
tail -f /var/log/apache2/access.log
# Or in your application
echo $_SERVER['HTTP_X_FORWARDED_FOR'];

Security Considerations¶

⚠️ Important: X-Forwarded-* headers can be forged by clients. In production environments, ensure that only your proxy sets them.

This configuration is essential to maintain full traceability in reverse proxy architectures.

Original source: Networking How To's

SQL: Select Rows with Max Value per Group

2015-10-21T23:05:00+02:00

A common problem in SQL: how to select the complete rows that contain the maximum value of a column for each group? Not just the maximum value, but the entire row.

The Problem¶

Given a table with id and rev (revision), we want to get the complete row with the highest rev for each id.

Solution 1: Subquery with IN¶

SELECT * 
FROM YourTable 
WHERE (id, rev) IN (
    SELECT id, MAX(rev)
    FROM YourTable
    GROUP BY id
)

Pros: Simple and readable Cons: Can be slow on large tables

Solution 2: Join with 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

Pros: Better performance than IN Cons: More verbose

Solution 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

Pros: More efficient for large datasets Cons: Requires modern SQL versions

Performance Considerations¶

Window functions are usually the most efficient
Joins balance readability and performance
Subqueries with IN are the simplest but less scalable

When to Use Each?¶

Subquery: Small tables, simple code
Join: Balance between performance and compatibility
Window functions: Large datasets, modern SQL available

The most robust and modern pattern is window functions, which also allow handling ties and edge cases more elegantly.

Original source: 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.

Repeating a function with threads

2015-05-03T21:00:00+02:00

I have a service (with daemonocle which I will talk about another day) running all the time on an odroid c1. I considered it was better to control with threads some periodic tasks that I have to repeat (which I was already using) instead of the typical cron entry.

This way I can better control their operation. The advantages for me in this case and for these specific tasks:

I already have the logging configuration performed by the main process. These tasks leave their info in my rotational logs.
Stopping (starting) the service stops everything at once.
I measure resource consumption as a whole

Here is the snippet used.

In 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

In main.py you can see its usage, one of the functions receives a parameter:

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)

I should tell you that I stop these threads and clean resources in the shutdown callback event which is one of the best things about daemonocle. You already know that python is not capable of fully parallelizing threads due to the GIL, but for simple tasks like these with very little load it is simple and works perfectly.

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

Install InSync on Opensuse

2015-04-20T18:18:00+02:00

I've been testing insync for several days and I think I'll happily pay for it.

I downloaded two packages, one for the dolphin context menu and another (the fedora one) for the program itself:

20:39 $ rpm -qa | grep insync
insync-1.2.7.35123-fc20.x86_64
insync-dolphin-1.2.7.35123-fc17.noarch

Everything working perfectly on my 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

NetHogs see consumed bandwidth

2015-04-16T11:37:00+02:00

To measure the bandwidth I am using right now, I use NetHogs

By default, it looks for a network interface called "eth0". If it doesn't find it, it complains like this:

ioctl failed while establishing local IP for selected device eth0. You may specify the device on the command line.

You can see your network configuration with the ip command:

$ 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

As you can see on my computer, I have two interfaces (apart from the loopback one) which are enp0s25 (my wired network card) and the wifi wlp3s0, which I am connected to now and is the one I will use (I could list both).

So by running:

$ sudo nethogs enp0s25

I can see the processes that are consuming the most bandwidth.

The command help is:

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

Anotaciones por Pablo Caro

De net-tools a iproute2: equivalents de comandos

net-tools vs iproute2¶

Comparación visual¶

ip a (salida completa)¶

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

Mi alias favorito¶

From net-tools to iproute2: command equivalents

net-tools vs iproute2¶

Visual comparison¶

ip a (full output)¶

ip -br -c a (brief and colored output)¶

My favorite alias¶

Solución al Error de Rodney con Chrome en Wayland

El Problema¶

La Solución¶

Ejemplo de funcionamiento¶

¿Por qué pasa esto?¶

Enlace¶

Fixing Rodney Chrome Error on Wayland

The Problem¶

The Solution¶

Working example¶

Why does this happen?¶

Link¶

Graba y Comparte tus Sesiones de Terminal con asciinema

¿Qué es asciinema?¶

Instalación y Ayuda¶

Comandos básicos¶

¿Por qué usarlo?¶

Record and Share your Terminal Sessions with asciinema

What is asciinema?¶

Installation and Help¶

Basic commands¶

Why use it?¶

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

¿Qué es un kitten?¶

Características principales¶

Instalación¶

Uso y atajos¶

kitty-rbw: Fast Bitwarden access from your kitty terminal

What is a kitten?¶

Key Features¶

Installation¶

Usage and Shortcuts¶

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

Instalación¶

Uso básico¶

Integración con pi-agent¶

rbw: The Bitwarden terminal client you should be using

Installation¶

Basic Usage¶

Integration with pi-agent¶

DeepDiff: La navaja suiza para comparar datos en Python

Características principales¶

Instalación¶

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

Ejemplos de uso¶

En Python¶

En la terminal (CLI)¶

Conclusión¶

Renderizando Markdown en la terminal con Glow

Instalación¶

Shot-scraper: Capturas de pantalla automatizadas para la web

Instalación¶

Uso básico¶

Capturando selectores específicos¶

Interactuando con JavaScript¶

Automatización avanzada¶

Más allá de las capturas¶

Stern: Logs de Kubernetes con esteroides

Instalación¶

Usando Homebrew¶

Binario directo¶

Características principales¶

1. Tailing de múltiples pods¶

2. Filtrado y exclusión¶

3. Selectores de Kubernetes¶

4. Formato de salida¶

Conclusión¶

`ip a` (salida completa)¶

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

`ip a` (full output)¶

`ip -br -c a` (brief and colored output)¶

¿Qué es Pandas `Styler`?¶

What is Pandas `Styler`?¶

¿Qué es `fresh`?¶

¿Por qué lo prefiero a `nano` o `vim` para mi uso habitual?¶

What is `fresh`?¶

Why do I prefer it over `nano` or `vim` for regular use?¶