Jorge Dobón Blanco

88x31

2026-08-15T00:00:00+00:00

Quizá te haya llamado la atención la imagen abstracta 88x31 de tonos verdosos que se encuentra al pie de todas las páginas de este sitio web. Se trata de una versión reducida del logotipo principal de dobon.dev.

<picture>
    
    
    

    <source srcset="https://dobon.dev/processed_images/me.d7909b6ed2f8f277.avif" type="image/avif">
    <source srcset="https://dobon.dev/processed_images/me.74fcbc10b115f317.webp" type="image/webp">
    
    <!--|
        | If the picture is inside a figure, the `alt` information should be
        | removed to avoid the screen reader reading the same text twice.
        |
        | See also <https://stackoverflow.com/a/58468470>.
        |-->
    <img
            src="https://dobon.dev/processed_images/me.a2dc909c1bde0ed8.jpg"
            loading="lazy"
            width="88"
            height="31"
            
    >
</picture>


<figcaption>La imagen 88x31 representativa de este sitio web.</figcaption>

Dada la tradición de la IndieWeb sobre este tipo de imágenes, doy completo permiso de que sea usada en otros sitios web como una forma de expresar apoyo o recomendación hacia mi proyecto artístico.

Ruego, por favor, que se evite realizar hot-linking sobre la imagen; descargue una copia de la misma al alojamiento de su página personal y enlace dicha copia.

Dada la baja resolución de estas imágenes, y el uso sobre las mismas de técnicas pixel art, recomiendo aplicar las siguientes propiedades CSS sobre toda imagen 88x31:

.pixel-art {
    image-rendering: auto;
    image-rendering: crisp-edges;
    image-rendering: pixelated;
}

Favoritos

2026-08-14T00:00:00+00:00

Inspirado en la página Recommendations de Vlad-Stefan Harbuz.

Directorio web

Listar todas las páginas web que frecuento sería tarea imposible; no busco que esta lista sea exhaustiva, tomalá como una serie de recomendaciones:

Sitio	Fuentes	Descripción
Xe Iaso	RSS, JSON Feed	Sitio web personal con publicaciones sobre tecnología, principlamente sobre gestión de infraestructura.
Unsung	Atom	El blog sobre tecnología de Marcin Wichary, numerosos escritos sobre UI/UX.
lobste.rs		Agregador de enlaces comunitario.
April Cools		Iniciativa para hacer del 1 de abril un día más interesante en la IndieWeb.
Vlad-Stefan Harbuz	RSS	Sitio web personal sobre filosofía y Open Source.
xxiivv	RSS (Entradas) RSS (Imágenes)	Wiki personal de Devine Lu Linvega, artista y programador.
kokorobot	RSS	Sitio web personal de Rek Bellum, artista e ilustradora.
Hundred Rabbits	RSS	Proyecto artístico y de vida de Devine Lu Livega y Rek Bellum.
Michael Stapelberg	Atom	Sitio web personal con publicación sobre diversos temas de la informática, por un ex-maintainer de Debian.
Faultlore	RSS	Sitio y blog personal de Aria Desires, multitud de artículos sobre informática a bajo nivel.
Robb Knight	Atom, RSS y JSON Feed	Blog personal con artículos sobre informática y otros temas varios.
OONI		Organización que busca documentar y registrar casos de censura de Internet por instituciones, recomiendo encarecidamente apoyarles.

Música

Soy amante de muchos géneros de música, escuchando todo lo que se asemeje al hip-hop, al rock, al rap o al jazz. Tengo un perfil de Last.fm donde aparece y se actualiza la música que escucho día a día.

There's only one beer left...

Miscelánea

Mi color favorito es el rojo.
Mi caracter Unicode preferido es el Angzarr ⍼.

Libro de visitas

2026-08-14T00:00:00+00:00

En esta página, vosotros, los lectores de este sitio web, podéis dejar mensajes al mundo. Para dejar un mensaje, manda un correo electrónico a guestbook@dobon.dev con su nombre, el cuerpo del mensaje y opcionalmente un enlace a su sitio web.

Se permiten los siguientes formatos:

Texto plano.
Markdown CommonMark (se permite híbrido con HTML).
HTML (siempre que no sea molesto o malicioso).

Para aparecer como un lector anónimo indíquelo explícitamente.

Fuentes

2026-08-12T00:00:00+00:00

Las siguientes fuentes Atom se encuentran disponibles para estar al tanto de nuevas publicaciones o actualizaciones:

Fuente global: Lista todo aquello publicado o actualizado en el sitio web.
- Fuente de artículos: Nuevos artículos o actualizaciones de estos.
- Fuente de notas: Nuevas notas o actualizaciones de estos.

Explorando los arrays paginados

2026-08-10T00:00:00+00:00

A lo largo de este texto se trabaja únicamente con números con signo, esto es debido a que uno de mis requisitos personales es que mis librerías sea compatible con el acuerdo de independencia CLS descrito en el estándar ECMA-335 CLI.

Recientemente, me encontraba trabajando un proyecto personal desarrollado en C# que por diversas razones, y con el afán de experimentar un poco, necesitaba de un array que pudiera tomar como índice un entero long, es decir, con 64 bits de indexación.

El entorno de ejecución .NET solo soporta nativamente arrays con enteros int, 32 bits, como índices. Esto no solo se trata de una limitación de su librería estándar sino de su propio recolector de basura (GC); a menos que se active una configuración en concreto, los objetos se encuentran limitados a 2 GiB.

Elemento <gcAllowVeryLargeObjects>

En plataformas de 64 bits, habilita matrices que tienen un tamaño total de más de 2 gigabytes (GB).
<gcAllowVeryLargeObjects enabled="true|false" />
— Microsoft Learn (fuente)

En todo caso, crear un array de tal tamaño tampoco sería ideal, pues supondría la aparición grandes monolíticos bloques de memoria manejada que serían problemáticos para el GC.

Arrays paginados

Decidí acudir a un recurso que solventaría los problemas de memoria y que, en mi cabeza, también me permitiría tener una indexación de 64 bits, los arrays paginados.

Un array paginado se trata de una estructura de datos en la que los elementos se almacenan en arrays de tamaño fijo denominados páginas. Mi teoría consistía en que con la suficiente cantidad de páginas podría simular una indexación de 64 bits.

Mi implementación consistía en una sparse list, una estructura de datos que permite el acceso a índices discontinuos introduciendo punteros nulos en aquellas páginas completamente vacías.

 1namespace Redacted.Collections;
 2
 3internal class SparseList<T>(int pageSize, T tombstone = default!)
 4{
 5    public T this[long index]
 6    {
 7        get => Get(index);
 8        set => Set(index, value);
 9    }
10
11    private readonly List<SparseListPage<T>?> _pages = [];
12
13    private T Get(long index)
14    {
15        var (pageIndex, elementIndex) = GetIndices(index);
16        if (pageIndex >= _pages.Count) return tombstone;
17
18        var page = _pages[pageIndex];
19        if (page == null) return tombstone;
20        
21        return _pages[pageIndex]![elementIndex];
22    }
23
24    private void Set(long index, T value)
25    {
26        var (pageIndex, elementIndex) = GetIndices(index);
27        var isValueTombstone = Equals(value, tombstone);
28
29        var missingPages = (pageIndex + 1) - _pages.Count;
30        if (missingPages > 0 && isValueTombstone) return;
31        
32        for (var i = 0; i < missingPages; i++)
33        {
34            _pages.Add(null);
35        }
36
37        _pages[pageIndex] ??= new SparseListPage<T>(pageSize, tombstone);
38        var page = _pages[pageIndex]!;
39        
40        if (page.Count == 1 && isValueTombstone)
41        {
42            _pages[pageIndex] = null;
43            return;   
44        }
45        
46        page[elementIndex] = value;
47    }
48    
49    private (int pageIndex, int elementIndex) GetIndices(long index)
50    {
51        return ((int)(index / pageSize), (int)(index % pageSize));
52    }
53}⏎

 1namespace Redacted.Collections;
 2
 3internal class SparseListPage<T>
 4{
 5    public int Size => _size;
 6    public int Count;
 7    
 8    public T this[int index]
 9    {
10        get => _data[index];
11        set
12        {
13            var isNewValueTombstone = Equals(value, _tombstone);
14            var isStoredValueTombstone = Equals(_data[index], _tombstone);
15            
16            if (!isNewValueTombstone && isStoredValueTombstone)
17            {
18                Count++;
19            }
20            else if (isNewValueTombstone && !isStoredValueTombstone)
21            {
22                Count--;
23            }
24            
25            _data[index] = value;
26        }
27    }
28    
29    private readonly int _size;
30    private readonly T _tombstone;
31
32    private readonly T[] _data;
33    
34    public SparseListPage(int size, T tombstone = default!)
35    {
36        _size = size;
37        _tombstone = tombstone;
38
39        _data = new T[size];
40        Array.Fill(_data, _tombstone);
41    }
42}

Con mi implementación funcionando y respondiendo correctamente a mis tests unitarios me dispuse a llevar estas estructuras al mundo real. Le dedico unas horas a mi proyecto, ejecuto dotnet run en la terminal y...

Unhandled exception. System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection. (Parameter 'index')
   at System.Collections.Generic.List`1.get_Item(Int32 index)
   at Redacted.Collections.SparseSet.SparseList`1.Get(Int64 index) in [...]
   at Redacted.Collections.SparseSet.SparseList`1.get_Item(Int64 index) in [...]

En ese momento me sorprendió, resulta que al intentar usar el índice más alto posible, long.MaxValue, es decir, con el número 9.223.372.036.854.775.807, el método GetIndices() devuelve el valor -1 como índice de página.

Esto es debído a que la operación index / pageSize no garantiza que sea un valor menor o igual a int.maxValue, es decir, el número 2.147.483.648. Esto tiene sentido, no es difícil ver que toda operación long / int no garantiza esto.

Justificación

La razón, que rompe cualquier posibilidad de que mi teoría fuese cierta, es sencilla.

Un array con índices de 32 bits puede almacenar hasta $ 2^{31} $ elementos, esto implica que cada página puede almacenar dicha cantidad; y dado que los punteros hacia las páginas también se almacenan en un array, puede haber hasta $ 2^{31} $ páginas.

Es significa que puede haber hasta $ 2^{31} * 2^{31} = 2^{31 + 31} = 2^{62} $ elementos en total en un array paginado, pero un array con índices de 64 bits puede acumular hasta $ 2^{63} $ elementos. Hay $ 2^{63} - 2^{62} $ elementos inaccesibles, es decir, los últimos $ 4.611.686.018.427.387.904 $ índices del array no son indexables.

¿Y si quitáramos el signo?

Si nos encontrásemos con un lenguaje que permitiese índices de 32 bits sin signo, se podrían almacenar hasta $ 2^{32} $ elementos; con el mismo razonamiento de antes, podríamos tener hasta $ 2^{32} $ páginas.

Esto nos permitiría llegar hasta los $ 2^{32} * 2^{32} = 2^{32 + 32} = 2^{64} $ elementos en total al dar uso de un array paginado. Es interesante que en este lenguaje hipotético, un array paginado no solo podría almacenar todos los elementos de un array de índices con signo de 64 bits ($ 2^{63} $ elementos) si no también de un array de índices sin signo de 64 bits ($ 2^{64} $ elementos).

Demostración

Vistos los resultados anteriores es natural que surja interés de en hallar una demostración matemática:

Planteamos $ a \gt b$, donde $ a \in \mathbb{N^+} $ es el número de bits de los índices del array que queremos replicar, y $ b \in \mathbb{N^+} $ el número de bits de los índices de los arrays que conforman nuestro array paginado (la réplica).

Para que la réplica sea válida todos los elementos del array original deben poder ser introducidos en la réplica:

$$ 2^a = 2^b * 2^b \implies 2^a = 2^{b + b} \implies a = 2b \implies a / 2 = b$$

Y dado que nos encontramos trabajando con aritmética entera, la expresión $ a / 2 $ solo existe si $ a \bmod 2 = 0 $; dicho de otro modo, $ a $ debe ser un número par $ \blacksquare $.

Alternativas

Dudo que existan alternativas para cubrir este concreto caso, la mayoría de sistemas donde puede surgir una necesidad así son capaces usar índices de 64 bits. Este intento mio ha resultado ser poco más que un curioso experimento que quería compartir.

Aventuras con SSGs

2026-08-09T00:00:00+00:00

Es ley que todo usuario de la IndieWeb tenga como primera publicación un texto explicando sus primeras desventuras creando y desplegando su página web personal.

Mi caso no es una excepción, originalmente intenté dar vida a mi página, primero creando mi propio SSG (Static Site Generator), del que aún quedan resquicios. Poco después me di cuenta de la complejidad que esta tarea tenía, y con la universidad aun consumiendo mucho de mi tiempo decidí dejar este proyecto aparcado un tiempo.

Quiero con este artículo hacer una prueba de contacto a la escritura y formato propios de un blog, y comentar el proceso creativo y de diseño que han llevado al stack de tecnologías actuales de dobon.dev.

Y al principio estaba lobste.rs

Mi interés por tener mi propio espacio digital viene de tiempo atrás. De forma accidental, buscando resolver las distintas dudas que me surgían en mi viaje autodidacta en el mundo de la informática, encontraba textos que me parecían de un gran interés y aprendizaje, pues en muchos casos me abrían las puertas a conceptos completamente nuevos.

Las explicaciones de Michael Stapelberg sobre su gestor de paquetes experimental d1stri, las detalladas explicaciones de Xe Iaso sobre su paranoica configuración de NixOS o el rant de Aria Desires sobre la situación actual de los ABIs basados en C eran pequeñas ventanas hacia todo aquello de mi gremio que no conocía.

Fue con ello natural que de mí surgiera el deseo de escribir y compartir mis opiniones y descubrimientos, que se mantuvo latente pero constante a lo largo de los años. Al llegar a la universidad y hablar con mis semejantes, me di cuenta de que quizá había infravalorado tanto mi capacidad de enseñar y mostrar a otros mis descubrimientos, como del placer que me es hacerlo.

Pasado el primer cuatrimestre, algo más asentado en la vida universitaria, tomé la decisión de dedicar mis escasos momentos libres a la construcción de mi propia página web. Durante ese periodo, en mi rutinaria lectura de lobste.rs, me encontré una nueva entrada, clara y directa: Why You Should Write Your Own Static Site Generator (entrada en lobste.rs).

Con ello, motivado por este artículo, abrí RustRover con la intención de crear un SSG que cumpliese una breve y humilde lista de características:

Renderizado incremental.
Renderizado basado en plantillas HTML.
Soporte multiidioma.
Generación de fuentes Atom.
Optimización de imágenes AVIF y generación de fallbacks WEBP y JPEG.
Recarga en caliente (Hot reloading).
Sistema de taxonomías.
Soporte de comentarios con Webmention.
Minificación de HTML, CSS y JS.
Sindicalización POSSE.

Espero que se haya hecho notar la ironía... Visto en retrospectiva mi error está claro, la complejidad del sistema que yo necesitaba era demasiado alta. El desarrollo fue rápidamente cuesta arriba por un segundo cuatrimestre que ya estaba funcionando a todo rendimiento y una serie de restricciones autoimpuestas, quería que fuese un SSG generalista en toda regla, y no un programa de planta de interior.

Todo esto llevo a que el proyecto acabara de forma prematura, insatisfecho con lo que había logrado hacer. Creo que hubo unos puntos clave que dificultaron mucho la tarea:

Menosprecie la dificultad de crear una caché funcional y la poca necesidad de renderizado incremental en la mayoría de SSGs, dada la velocidad de renderizado que pueden llegar a alcanzar.
La conversión entre formatos de imagen resulto ser más compleja que añadir una librería adicional y una llamada extra a una función, ImageMagick tiene una API de una complejidad elevada.

En pocas palabras:

Hay solo dos cosas difíciles en la informática: la invalidación de caché y nombrar cosas.

— Phil Karlton (Traducido, fuente)

Hugo me marea

Paso un tiempo de desconexión sobre este tema; un proyecto de autoalojado (self-hosting), sobre el que quiero escribir en un futuro, tomó gran parte de mi tiempo.

Recién entrando en el mes de agosto quise de una vez por todas tener una página propia, me decanté por Hugo, que es sin duda, junto a Jekyll, Eleventy y Astro, uno de los SSG más usados del mundo...

No fue una tarde productiva, la documentación de Hugo resulto ser un desastre. Más cercana a una referencia que a un documento que sirva para aprender a usar la herramienta, introduce constantemente conceptos nuevos y peca de enlazar demasiadas páginas entre sí, lo que vuelve todo algo agobiante.

Su guía Quick start trata a la herramienta como una caja negra, obligando la instalación de un tema, pues no es explicado en ella como funciona el sistema de plantillas y estilizado.

El glosario de Hugo

Esta sección originalmente no iba a estar escondida tras un desplegable, pero me extendí demasiado en ella. Además, me quedó demasiado como un rant.

Para ejemplo de esta problemática se encuentra su glosario de términos, que presenta multitud de problemas como:

La adición de términos comunes en la informática que solo llevan a que el glosario sea demasiado extenso, por ejemplo:
- Booleano: Un booleano es un tipo de dato con dos posibles valores, o verdadero > (true) o falso (false).
- Caché: Una caché es un componente de software que almacena datos para que > futuras peticiones de los mismos sean más rápidas.
- CLI: CLI significa Command Line Interface, un mecanismo basado en texto que > permite la interacción con programas informáticos o sistemas operativos.
— El glosario del SSG Hugo (Traducido, fuente)
La existencia de términos proxy, por ejemplo:
- Dimensión de un contenido: Vea dimensión.
- Bundle: Vea bundle de una página.
- bool: Vea booleano.
— El glosario del SSG Hugo (Traducido, fuente)
La invención de terminología innecesariamente compleja:

Dimensión: Una dimensión es un eje de variación de un contenido que permite que múltiples variaciones lógicas de una página existan simultáneamente. Las tres dimensiones son idioma, rol y versión.

Por ejemplo, una página lógica puede que exista en 6 idiomas, 4 versiones y 2 roles.

— El glosario del SSG Hugo (Traducido, fuente)

Que no se me malinterprete, este glosario no se trata de un problema crítico, pero sí ejemplifica a la perfección el mal estado de la documentación de Hugo.

¿Y si uso Bash?

Durante un muy breve periodo de tiempo se me ocurrió la idea no utilizar un SSG, sino una serie de scripts en Bash que dieran uso de herramientas como Pandoc o yq.

La idea duró una tarde. Vi en poco tiempo como iba a acabar con los mismos problemas que con mi intento original de SSG, además, recordé mi odio hacia el shell scripting.

Usando Zola

Finalmente, di una segunda oportunidad a una herramienta que en un pasado rindió sin peros y que todavía no sé por qué la deje a un lado, Zola.

No tengo ninguna queja, su Getting Started - Overview me guio rápidamente en la creación de un sencillo blog personal, mostrando en el proceso el funcionamiento de su sistema de plantillas y su breve terminología basada en páginas, secciones e índices.

Es un SSG que busca ser rápido, no entrometerse en tu diseño y tener las funcionalidades justas y necesarias.

Hablemos del Open Source

En una nota más personal, me alegró ver que el proyecto sufrió una transición de una licencia MIT (permisiva) a la EUPL (libre y vírica). Me gustaría incluir el siguiente fragmento de una conversación que ocurrió en GitHub:

Desafortunadamente, esto es un gran cambio para los usuarios corporativos de los EEUU. La EUPL está categóricamente prohibida en la industria tecnológica, pues es agrupada junto a la AGPL y la SSPL. Esta licencia hace a efectos practicos a Zola imposible de incluso ejecutar su binario en cualquier entorno comercial estadounidense. — psarossy

¿Una pena para los usuarios corporativos de los EEUU entonces? No hay razón ninguna para agrupar la EUPL con la AGPL. [La versión] 0.21 está todavía disponible para esos usuarios. — Keats (creador de Zola)

— Extracto de la conversación del Issue #3093 del repositorio de GitHub de Zola (Traducido, fuente).

Creo que ilustra a la perfección la asimétrica situación en la que nos encontramos en el mundo Open Source. El mundo corporativo y profesional ha creado unas expectativas sobre voluntarios y gente que ejerce de la informatica como hobby, obligandoles a proveer productos y un servicio de excelencia y business-ready.

Creo que es relevante enunciar una vez más una serie de verdades muchas veces olvidadas:

Toda persona es libre de crear cuando y como quiera, ignorando si lo creado presenta o no una utilidad práctica.
No tienes la obligación de examinar Pull Requests o cualquier otra propuesta de adición de código, sea escrita por humano o IA.
ESTE SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO.

Recomiendo mucho el texto help wanted por Lake Hope, que explora en mayor profundidad este tema.

Post mortem

Por un lado, me alegra mucho tener por fín un sitio en el que compartir mis ideas y opiniones. Pero, no puedo evitar tener el pensamiento de que no he logrado tener la virtud propia de un ingeniero informático; el desgaste (o burnout), el cansancio y el desconocimiento han jugado un factor clave en esto, pero no haber sido capaz de desarrollar un programa SSG más competente me deja una sensación agridulce en el cuerpo.

Sobre mí

2026-03-20T00:00:00+00:00

¡Hola! Soy Jorge, un estudiante de ingeniería informática y estadística de España.

Quiero en esta página contar un poco sobre mí, como una forma de que conozcais al autor que esta detras de todos los textos de este sitio web.

En esta página intento evitar mencionar preferencia o disgusto frente a productos, servicios o piezas de arte en concreto. Mi página de recomendaciones ya cumple ese propósito.

Informática

Llevo descubriendo de forma autodidacta, y ahora también de forma académica, la informática desde que tengo memoria. Esta ha sido, es, y seguramente será la pasión a que más horas la he dedicado.

He probado y estudiado, en mayor o menor medida, una gran multitud de los campos que la conforman: desarrollo de software, diseño de interfaces, la web, administración de sistemas, sistemas reproducibles (NixOS), devops y CI/CDs y mucho más.

Y aun con todas las horas pasadas en frente de una pantalla, solo me surgen las ganas de conocer más, de leer más, de cacharrear un poco más.

En dos palabras: vi-deojuegos

Desde niño soy un gran apasionado de los videojuegos, les he dedicado miles de horas y probado decenas de géneros diferentes.

Nunca me voy a negar de jugar a un Metroidvania, un buen juego de puzzles, un souls-like, una aventura de supervivencia o un plataformas resultón.

Y por mucho que lo intente, y lo mucho que me lo recomienden, no he logrado nunca he logrado divertirme jugando un Rogue-like (o un Rogue-lite).

Lectura

Aunque desde hace unos años ya estoy habituado a leer todos los días algún texto de aspecto técnico, normalmente escritos por miembros de la IndieWeb, no tengo todavía un fuerte hábito de lectura.

Espero en unos años poder actualizar esta sección de la página con un tono más positivo.

Fotografía

Desde hace no mucho tiempo, y debido a unas vacaciones en las que se dio lugar a espacios muy fotogénicos, me he empezado a interesar en la fotografía.

Por ahora no soy más que un principiante (ab)usando de un teléfono móvil de altas prestaciones; algunas de las fotografías que hago me resultan lo suficiente atractivas como para publicarlas en este sitio.

Ahora

2026-03-20T00:00:00+00:00

A día de 8 de agosto de 2026 me encuentro:

Disfrutando de mis vacaciones de verano.
Migrando de mi SSG (Static Site Generator) casero a Zola.

Esto es una página /now, una idea impulsada por Derek Sivers y Greg Albritton.