<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Rust on Inicio</title>
    <link>https://blog.rafaelfernandez.dev/es/tags/rust/</link>
    <description>Recent content in Rust on Inicio</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>es</language>
    <copyright>© 2026 Rafael Fernandez</copyright>
    <lastBuildDate>Tue, 24 Mar 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://blog.rafaelfernandez.dev/es/tags/rust/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Cómo funcionan los query engines 2. Por qué los query engines modernos piensan en columnas</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/how-query-engines-work-2-columnar-storage-arrow-rust/</link>
      <pubDate>Tue, 24 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/how-query-engines-work-2-columnar-storage-arrow-rust/</guid>
      <description>¿Por qué los query engines modernos se pasan columnas en vez de filas? Porque al hardware le encanta esa forma. Este post explica por qué el layout columnar es tan rápido, cómo Apache Arrow lo representa en memoria y cómo construir y manipular arrays de Arrow en Rust sin tratar todo esto como si fuera magia negra.</description>
      
    </item>
    
    <item>
      <title>Cómo funcionan los query engines 1. El pequeño compilador detrás de cada query SQL</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/how-query-engines-work-1-from-sql-to-results/</link>
      <pubDate>Mon, 23 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/how-query-engines-work-1-from-sql-to-results/</guid>
      <description>Escribes una query SQL, presionas enter y unos milisegundos después aparecen resultados. En el medio, un pequeño compilador ya parseó el texto, construyó un plan, lo optimizó y lo ejecutó. Este post recorre ese pipeline con una query real y código real en Rust usando DataFusion.</description>
      
    </item>
    
    <item>
      <title>La Arquitectura Elm: un bucle que cabe en tu cabeza</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/the-elm-architecture-a-loop-that-fits-in-your-head/</link>
      <pubDate>Sun, 22 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/the-elm-architecture-a-loop-that-fits-in-your-head/</guid>
      <description>Model, Update, View. Tres piezas, un bucle, cero sorpresas. Explicamos The Elm Architecture desde cero con ejemplos lado a lado en Rust y Scala, rastreamos de donde viene el patron, por que sigue apareciendo en TUIs y codebases funcionales, y cuando deja de ser la herramienta correcta.</description>
      
    </item>
    
    <item>
      <title>La correspondencia Curry-Howard: cuando los tipos se convierten en demostraciones</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/curry-howard-types-as-proofs/</link>
      <pubDate>Fri, 20 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/curry-howard-types-as-proofs/</guid>
      <description>Todo programa bien tipado es una demostración. Todo tipo es una proposición. No es una metáfora: es un teorema matemático descubierto en los años 30 que explica por qué hacer los estados inválidos irrepresentables realmente funciona.</description>
      
    </item>
    
    <item>
      <title>Hacer los estados inválidos irrepresentables 3: bugs reales por estados representables sin sentido</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-3-real-bugs/</link>
      <pubDate>Wed, 18 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-3-real-bugs/</guid>
      <description>Referencias nulas, spinners de carga que muestran errores y datos simultáneamente, pagos capturados y anulados a la vez. No son hipotéticos; son consecuencia directa de tipos que mienten sobre el dominio.</description>
      
    </item>
    
    <item>
      <title>Hacer los estados inválidos irrepresentables 2: el álgebra detrás de tus tipos</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-2-algebra-behind-types/</link>
      <pubDate>Mon, 16 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-2-algebra-behind-types/</guid>
      <description>Los tipos se llaman algebraicos porque obedecen aritmética. Los tipos producto multiplican, los tipos suma suman. Entender esta aritmética explica por qué un enum con 5 variantes es infinitamente más preciso que 4 flags booleanos.</description>
      
    </item>
    
    <item>
      <title>Hacer los estados inválidos irrepresentables 1: por qué los flags booleanos son bugs disfrazados</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-1-boolean-flags/</link>
      <pubDate>Sat, 14 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/making-invalid-states-unrepresentable-1-boolean-flags/</guid>
      <description>Un semáforo que está en rojo y verde a la vez. Un usuario que está logueado y deslogueado simultáneamente. Los flags booleanos hacen estos estados absurdos perfectamente representables, y ese es el problema.</description>
      
    </item>
    
    <item>
      <title>Ownership en Rust 3. La culpa del clone y la República de los tipos</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-3-clone-guilt-republic-of-types/</link>
      <pubDate>Thu, 12 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-3-clone-guilt-republic-of-types/</guid>
      <description>La comunidad de Rust convirtió .clone() en un pecado moral. Ese dogma es tan peligroso como la incapacidad del Consejo Jedi para adaptarse. Ponemos la culpa bajo el microscopio: los números reales de rendimiento, el lint de clippy que la refuerza y la teoría de tipos que explica por qué Rust hace visible la duplicación.</description>
      
    </item>
    
    <item>
      <title>Ownership en Rust 2. Seis formas de compartir estado y como elegir la correcta</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-2-six-ways-to-share-state/</link>
      <pubDate>Mon, 09 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-2-six-ways-to-share-state/</guid>
      <description>Move, borrow, clone, Rc, Arc, Cow. Rust te da seis formas de sable laser para el ownership. Cada una contrarresta una amenaza concreta. Usar la forma equivocada contra el oponente equivocado no es solo inelegante, es fatal. Mapeamos cada estrategia a las situaciones donde brilla y donde falla catastroficamente.</description>
      
    </item>
    
    <item>
      <title>Ownership en Rust 1. Deja de temer a .clone()</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-1-stop-fearing-clone/</link>
      <pubDate>Fri, 06 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/ownership-rust-1-stop-fearing-clone/</guid>
      <description>La comunidad Rust trata .clone() como un code smell. A veces lo es. Pero la mayoría de las veces, el instinto de evitarlo cuesta más en complejidad de lo que el clone cuesta en nanosegundos. Diseccionamos qué hace clone realmente para cada tipo común, el espectro real de costes a lo largo de seis órdenes de magnitud, y por qué Clone y Copy no son la misma conversación.</description>
      
    </item>
    
    <item>
      <title>Tagless Final es semantica denotacional disfrazada</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/tagless-final-is-denotational-semantics/</link>
      <pubDate>Tue, 03 Mar 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/tagless-final-is-denotational-semantics/</guid>
      <description>Cada trait en tu arquitectura hexagonal es un algebra tagless-final. Cada impl es un interprete. Has estado escribiendo semantica denotacional sin saberlo. Trazamos la conexion desde el paper de Kiselyov a traves de Cats-Effect de Scala hasta los port traits de Rust, y mostramos por que el patron que los academicos llaman &amp;lsquo;finally tagless&amp;rsquo; es el mismo patron que los practicantes llaman &amp;lsquo;inyeccion de dependencias.&amp;rsquo;</description>
      
    </item>
    
    <item>
      <title>Todo TUI en Rust 5. Polling de eventos, el corte vertical de edición y cierre</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-5-event-polling-edit-vertical-slice/</link>
      <pubDate>Sat, 28 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-5-event-polling-edit-vertical-slice/</guid>
      <description>La rata sirve el último plato. Corregimos el lag de entrada con polling de eventos no bloqueante, añadimos la funcionalidad de edición como un corte vertical completo desde la capa de aplicación hasta la TUI, observamos la máquina de estados crecer de 3 a 4 variantes con seguridad guiada por el compilador, y cerramos con las conclusiones clave de toda la migración.</description>
      
    </item>
    
    <item>
      <title>Todo TUI en Rust 4. Pulido UX y el popup de entrada</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-4-ux-polish-input-popup/</link>
      <pubDate>Wed, 25 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-4-ux-polish-input-popup/</guid>
      <description>La rata aprende a emplatar. Cinco mejoras de UX transforman un prototipo monocromático en una herramienta escaneable y responsiva: codificación por colores, feedback positivo, guía de estado vacío, mensajes transitorios y un cursor visual. Después sustituimos la entrada de texto en la barra de comandos por un popup modal centrado.</description>
      
    </item>
    
    <item>
      <title>Todo TUI en Rust 3. Eventos, seguridad de terminal y el momento de la verdad</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-3-events-terminal-safety-migration/</link>
      <pubDate>Sat, 21 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-3-events-terminal-safety-migration/</guid>
      <description>La rata conecta los oídos. Implementamos manejadores de eventos por modo con crossterm, rediseñamos el mapeo de teclas para usar un toggle en vez de teclas separadas, resolvemos el problema de restauración de terminal con un patrón de captura-limpieza-retorno, y ejecutamos cargo test para descubrir que cero líneas cambiaron fuera del adaptador.</description>
      
    </item>
    
    <item>
      <title>Todo TUI en Rust 2. Renderizando la capa View con ratatui</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-2-rendering-view-layer-ratatui/</link>
      <pubDate>Wed, 18 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-2-rendering-view-layer-ratatui/</guid>
      <description>La rata empieza a pintar. Implementamos la capa de renderizado: dibujo en modo inmediato, un layout de tres zonas con Layout::vertical, una tabla de tareas con StatefulWidget y resaltado de fila, una barra de comandos sensible al contexto que cambia según InputMode, y el sutil gotcha de Block que costó unos minutos de depuración.</description>
      
    </item>
    
    <item>
      <title>Todo TUI en Rust 1. Andamiaje del adaptador TUI y diseño de la máquina de estados</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-1-scaffolding-tui-adapter-state-machine/</link>
      <pubDate>Sat, 14 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-tui-rust-1-scaffolding-tui-adapter-state-machine/</guid>
      <description>Arrancamos una nueva serie migrando el adaptador CLI a una TUI con ratatui. Configuramos las nuevas dependencias, diseñamos la estructura de módulos bajo adapters/tui/, modelamos los modos de interacción como un enum para hacer los estados inválidos irrepresentables, y resolvemos el puzzle de ownership al clonar un repositorio en una sesión persistente.</description>
      
    </item>
    
    <item>
      <title>Sintaxis y Semantica 3. El Problema de la Expresion</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-3-the-expression-problem/</link>
      <pubDate>Sat, 07 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-3-the-expression-problem/</guid>
      <description>Agregar un nuevo tipo es facil en OOP, dificil en FP. Agregar una nueva operacion es facil en FP, dificil en OOP. Philip Wadler nombro esto el Expression Problem en 1998. Mostramos como se manifiesta en Rust y Scala, y anticipamos la resolucion.</description>
      
    </item>
    
    <item>
      <title>Sintaxis y Semantica 2: Tres formas de definir que significa tu codigo</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-2-three-ways-to-define-meaning/</link>
      <pubDate>Tue, 03 Feb 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-2-three-ways-to-define-meaning/</guid>
      <description>Tu expresion match es semantica operacional. Tu funcion pura es semantica denotacional. El borrow checker de Rust es semantica axiomatica. Tres marcos formales, tres formas de asignar significado al codigo, y has estado usando los tres sin saberlo.</description>
      
    </item>
    
    <item>
      <title>Sintaxis y Semantica 1: Tu codigo tiene un problema de gramatica</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-1-your-code-has-a-grammar-problem/</link>
      <pubDate>Fri, 30 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/syntax-and-semantics-1-your-code-has-a-grammar-problem/</guid>
      <description>Cada enum que escribes es una gramatica formal. Cada sealed trait es un conjunto de reglas de produccion. Has estado haciendo metodos formales todo este tiempo; simplemente no sabias el nombre. Trazamos la conexion desde la jerarquia de Chomsky hasta tus tipos de dominio en Rust y Scala.</description>
      
    </item>
    
    <item>
      <title>Los traits también son gramáticas: una idea de diseño que no me soltaba</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/traits-are-grammars-too-from-contract-design-to-formal-syntax/</link>
      <pubDate>Wed, 28 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/traits-are-grammars-too-from-contract-design-to-formal-syntax/</guid>
      <description>Al volver sobre el trait TaskRepository de la serie Todo CLI, me di cuenta de que no solo estaba dibujando una frontera arquitectónica. También estaba definiendo qué podía decirse en esa frontera, y eso se parece mucho más a una gramática de lo que pensé al principio.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 5. Siguiente paso, pasar de CLI a TUI con ratatui</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-5-cli-to-tui-with-ratatui/</link>
      <pubDate>Mon, 26 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-5-cli-to-tui-with-ratatui/</guid>
      <description>Cerramos la serie explorando qué implica migrar de CLI a TUI con ratatui: cómo cambia el modelo de interacción, qué fricciones introduce Rust con ownership y &amp;amp;mut en un event loop persistente, y por qué la arquitectura hexagonal absorbe el cambio sin cirugía.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 4. Creando el CLI con clap: parsing tipado, subcomandos y salida dual</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-4-building-cli-with-clap/</link>
      <pubDate>Thu, 22 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-4-building-cli-with-clap/</guid>
      <description>Diseñamos la capa CLI con clap derive, parsing tipado de argumentos con ValueEnum y FromStr para UUIDs, subcomandos como enums, flag global &amp;ndash;output para salida dual table/json, y errores propagados por capas hasta stderr.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 3.1. Estrategia de pruebas y deuda técnica explícita</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-3-1-testing-strategy-technical-debt/</link>
      <pubDate>Sun, 18 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-3-1-testing-strategy-technical-debt/</guid>
      <description>Analizamos la estrategia de testing del repositorio: pruebas por comportamiento para cada adapter, aislamiento con tempdir, por qué no hay tests compartidos, y la deuda técnica que decidimos documentar en vez de esconder.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 3. Persistencia JSON, contrato vs implementación</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-3-json-persistence-contract-vs-implementation/</link>
      <pubDate>Thu, 15 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-3-json-persistence-contract-vs-implementation/</guid>
      <description>Tercera parte de la serie: definimos el contrato de persistencia con un trait genérico, implementamos dos adaptadores (in-memory y JSON a disco) y profundizamos en la diferencia entre interfaz e implementación como eje de la arquitectura hexagonal.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 2. Dominio inmutable y errores tipados por capa</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-2-immutable-domain-typed-errors/</link>
      <pubDate>Mon, 12 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-2-immutable-domain-typed-errors/</guid>
      <description>En esta parte modelamos el corazón del proyecto: la entidad Task, sus transiciones inmutables y una taxonomía de errores por capas. Menos magia, más reglas explícitas y menos bugs sorpresa.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 1. Arquitectura hexagonal en un proyecto pequeño</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-1-hexagonal-architecture/</link>
      <pubDate>Thu, 08 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-1-hexagonal-architecture/</guid>
      <description>Arrancamos la serie construyendo un To-Do CLI en Rust desde el Project #1 de CodeCrafters, pero sin convertirlo en un script gigante. Vemos decisiones de arquitectura, límites de capas y por qué un proyecto pequeño también puede enseñarte diseño serio.</description>
      
    </item>
    
    <item>
      <title>Todo CLI en Rust 0. Roadmap de la serie y mapa del repositorio</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-0-roadmap-repository-map/</link>
      <pubDate>Mon, 05 Jan 2026 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/todo-cli-rust-0-roadmap-repository-map/</guid>
      <description>Guía de lectura de la serie Todo CLI en Rust, con el mapa técnico del repositorio, orden recomendado de capítulos y enlaces directos a archivos y commits para seguir cada decisión paso a paso.</description>
      
    </item>
    
    <item>
      <title>Zarpando con Sail. Entorno limpio con Docker, Jupyter y RustRover</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/zarpando-con-sail-entorno-limpio-docker-jupyter-rustrover/</link>
      <pubDate>Sun, 20 Jul 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/zarpando-con-sail-entorno-limpio-docker-jupyter-rustrover/</guid>
      <description>Guía práctica para montar un entorno limpio y reproducible con Docker, Jupyter y RustRover para trabajar con Sail como usuario o colaborador. Desde levantar servicios con docker-compose hasta debuggear en local sin instalar dependencias en tu máquina.</description>
      
    </item>
    
    <item>
      <title>Sail. Navegando entre gigantes y rayos</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/sail-navegando-entre-gigantes-y-chispas/</link>
      <pubDate>Wed, 16 Jul 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/sail-navegando-entre-gigantes-y-chispas/</guid>
      <description>En este artículo comparto mi visión crítica sobre el estado actual de la ingeniería del dato, dominada por plataformas pesadas como Spark y Databricks, y presento Sail, un motor open-source construido sobre Apache Arrow y DataFusion, escrito en Rust, que propone un nuevo camino: ligero, eficiente y potente.</description>
      
    </item>
    
    <item>
      <title>Primeros Pasos en Rust 🦀</title>
      <link>https://blog.rafaelfernandez.dev/es/posts/primeros-pasos-en-rust/</link>
      <pubDate>Thu, 13 Feb 2025 00:00:00 +0000</pubDate>
      
      <guid>https://blog.rafaelfernandez.dev/es/posts/primeros-pasos-en-rust/</guid>
      <description>Mis primeras impresiones de Rust desde un enfoque de programación funcional (Scala y Haskell). Una mezcla de emoción, frustración y un cambio de paradigma en la forma de pensar.</description>
      
    </item>
    
  </channel>
</rss>
