Forem: Tu codigo cotidiano

View Transitions API: matemáticas de interpolación para transiciones entre páginas SPA

Tu codigo cotidiano — Fri, 17 Apr 2026 00:30:33 +0000

La mayoría de explicaciones sobre View Transitions API se quedan en la superficie: “sirve para animar páginas”. En este artículo propongo un enfoque más preciso y mucho más útil para desarrolladores frontend: entenderla como una interpolación entre estados visuales del DOM.

La guía recorre la idea desde cinco capas: modelo mental, base matemática intuitiva, pipeline interno del navegador, valor real en SPA y variables perceptuales como posición, escala, opacidad y easing. El objetivo no es solo mostrar una API bonita, sino ofrecer un criterio técnico para pensar continuidad visual en interfaces web.

Artículo completo:
https://tucodigocotidiano.yarumaltech.com/leer_guias/view-transitions-api-matematicas-de-interpolacion-para-transiciones-entre-paginas-spa/

Kubernetes: ¿realmente lo necesitas o solo estás agregando complejidad?

Tu codigo cotidiano — Tue, 14 Apr 2026 13:39:02 +0000

Publiqué un nuevo episodio en Tu código cotidiano sobre una de esas decisiones técnicas que muchas veces se toman por prestigio y no por necesidad real:

usar Kubernetes.

Kubernetes puede ser increíble cuando el problema lo justifica.
Pero también puede convertirse en una capa enorme de complejidad operativa si tu sistema todavía no está en ese punto.

En este episodio explico:

qué hace Kubernetes de verdad
por qué tanta gente lo adopta antes de tiempo
cuándo sí vale la pena
y cómo pensar la decisión desde costo operativo versus valor real

Si trabajas en software, backend, infraestructura o despliegues, creo que este episodio te va a gustar porque intenta responder la pregunta sin humo y sin fanatismo.

🎧 Escúchalo aquí: https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/kubernetes-solucion-escalable-o-exceso-de-ingenieria/

Construye una analítica web zero-tracking con JavaScript puro, Rust y SQLite

Tu codigo cotidiano — Mon, 13 Apr 2026 13:26:08 +0000

Publiqué una nueva guía en TuCodigoCotidiano sobre un tema que me parece cada vez más importante: cómo medir una web sin convertir la analítica en rastreo.

Construí un sistema “zero-tracking” con JS puro y Rust que registra pageviews reales, persiste eventos en SQLite, soporta SPA y expone un dashboard mínimo.

Sin cookies.
Sin identificadores persistentes.
Sin plataformas externas.
Sin complejidad innecesaria.

Me gusta este enfoque porque demuestra algo clave: muchas veces no necesitas saber quién es el usuario; necesitas entender qué ocurrió, en qué ruta ocurrió y cómo validarlo técnicamente.

Te dejo la guía aquí:
https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/analitica-web-zero-tracking-construye-tu-propio-sistema-en-js-puro-y-rust-sin-cookies-ni-identificadores/

Hacking ético: pensar como el atacante para defender mejor tu código

Tu codigo cotidiano — Fri, 10 Apr 2026 15:15:50 +0000

Publiqué un nuevo episodio en Tu código cotidiano sobre una idea clave para cualquiera que construya software:

si no entiendes cómo podría romperse un sistema, te costará mucho protegerlo de verdad.

Eso no significa promover daño.
Significa adoptar una mentalidad de revisión más dura, más honesta y más útil.

En este episodio explico:

por qué pensar como atacante mejora la defensa
cómo cambia la forma de ver una aplicación cuando piensas en superficie de ataque
por qué las entradas, permisos, errores y decisiones de arquitectura importan tanto
y cómo el hacking ético ayuda a escribir software más robusto

Es un episodio pensado para desarrolladores, gente de backend, personas interesadas en seguridad y cualquiera que quiera mejorar su criterio técnico.

🎧 Escúchalo aquí:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/hacking-etico-como-pensar-como-el-atacante-para-defender-tu-codigo/

JavaScript Generators, Iterators, and function*: Pausing Execution Without Magic

Tu codigo cotidiano — Thu, 09 Apr 2026 14:51:36 +0000

Most explanations of function* stay at the syntax level. That’s the problem.

In this article, I break down the real difference between iterables, iterators, and generators in JavaScript, then connect yield and next() to a much stronger mental model: finite state machines.

You’ll see why generators are not automatic async behavior, not concurrency, and not “magic functions,” but a precise way to pause execution, preserve context, and resume a sequence on demand.

If you want to understand generators beyond memorizing syntax, this guide is for you.

https://tucodigocotidiano.yarumaltech.com/leer_guias/generadores-function-e-iteradores-pausando-la-ejecucion-y-maquinas-de-estado-finito/#comments

Concurrencia vs Paralelismo: no son lo mismo y esta diferencia importa de verdad

Tu codigo cotidiano — Wed, 08 Apr 2026 15:42:36 +0000

Publiqué un nuevo episodio en Tu código cotidiano sobre una de esas diferencias que parecen teóricas… hasta que empiezan a cambiar cómo diseñas software de verdad:

concurrencia vs paralelismo.

Mucha gente las usa como si fueran sinónimos, pero no lo son.

En este episodio explico:

por qué la concurrencia tiene más que ver con la organización de tareas
por qué el paralelismo tiene que ver con ejecución simultánea real
cómo se relacionan
y por qué entender esta distinción mejora tu intuición sobre sistemas, rendimiento y arquitectura

Si trabajas con programación, sistemas distribuidos, rendimiento o simplemente quieres pensar mejor cómo se ejecuta el software, creo que este episodio te va a gustar.

🎧 Escúchalo aquí:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/concurrencia-vs-paralelismo-no-son-lo-mismo-y-te-explicamos-por-que/

WebRTC y HTML: la arquitectura real detrás de una videollamada P2P

Tu codigo cotidiano — Tue, 07 Apr 2026 18:47:29 +0000

Muchísima gente aprende WebRTC con un modelo mental incompleto: creen que una videollamada es básicamente “poner dos videos y conectarlos”.

Ese enfoque parece suficiente al principio, hasta que aparece la realidad:

la pantalla remota queda negra
los peers no conectan
ICE no completa
el flujo local existe, pero el remoto nunca llega
o HTML termina cargando una culpa que en realidad pertenece a signaling o conectividad

La idea clave es esta:

WebRTC no empieza cuando ves el video. Empieza antes, en una fase de negociación y descubrimiento de conectividad.

El error mental más común

Confundir en un solo bloque cosas que viven en capas distintas:

HTML muestra el flujo
MediaStream representa medios capturados o recibidos
RTCPeerConnection negocia y transporta
SDP describe la sesión
ICE busca rutas viables
STUN/TURN ayudan a resolver conectividad en internet real

Cuando eso no está claro, depurar una llamada se vuelve frustrante porque todo parece “problema de video”, cuando muchas veces el fallo ocurrió antes del render.

Tres ideas que cambian por completo cómo entiendes WebRTC

1. HTML no transmite el video

El elemento <video> no negocia la llamada ni descubre rutas de red.

Solo materializa en la interfaz un flujo que el navegador ya pudo capturar o recibir.

2. Una pantalla negra casi nunca significa “falló el video”

Muchas veces significa que falló algo anterior:

la oferta
la respuesta
los candidatos ICE
la selección de ruta
o la asociación final del stream al DOM

3. Peer-to-peer no significa “sin infraestructura”

Aunque el medio pueda terminar fluyendo entre peers, antes suele hacer falta:

signaling
descubrimiento de conectividad
y a veces TURN como relevo

Entonces, ¿cómo conviene pensar WebRTC?

No como “dos videos conectados”.

Sino como una arquitectura con capas separadas:

captura local
negociación
conectividad
transporte de medios
render en HTML

Ese cambio de modelo mental hace que WebRTC deje de parecer magia y empiece a verse como sistema.

Guía completa

Si quieres ver esta arquitectura explicada paso a paso, con el papel exacto de HTML, el handshake real, SDP, ICE, STUN/TURN y una separación clara entre interfaz, lógica del peer y señalización, aquí está la guía completa:

Leer la guía completa

Deception Mesh: construyendo un MVP de telemetría defensiva en Rust con honeypots HTTP/SSH

Tu codigo cotidiano — Mon, 06 Apr 2026 14:44:34 +0000

Acabo de publicar Deception Mesh, un proyecto open source en Rust orientado a capturar actividad sospechosa temprana usando sensores señuelo distribuidos.

La motivación del proyecto nace de un problema muy concreto: muchas señales tempranas de reconocimiento o exploración ofensiva se pierden entre logs dispersos o carecen de contexto suficiente para triage. Un simple HEAD /login, una solicitud a /wp-login.php o un intento SSH inválido rara vez parecen “grandes eventos”, pero sí pueden ser el primer indicio útil.

En este MVP trabajé sobre una arquitectura simple y reproducible:

sensor agent con honeypots HTTP y SSH
control plane con autenticación, RBAC y gestión multi-tenant
persistencia en PostgreSQL
severidad por reglas
webhooks y exportación CSV
quickstart y scripts E2E con Docker

Algo importante para mí fue no sobreprometer: lo presento como un MVP funcional, documentado y honesto respecto a sus límites actuales de hardening.

Si te interesa Rust, seguridad defensiva, telemetría operativa o diseño de sistemas reproducibles, aquí está la landing pública del proyecto:

https://tucodigocotidiano.yarumaltech.com/proyectos/deception-mesh/

Adiós a la “Caja Negra”: Ejecutando IA en tu propia máquina

Tu codigo cotidiano — Fri, 03 Apr 2026 16:33:40 +0000

Publiqué un nuevo episodio en Tu código cotidiano sobre un cambio que me parece clave en esta etapa de la IA:

dejar de ver los modelos como una caja negra remota y empezar a ejecutarlos localmente.

Cuando corres IA en tu propia máquina, cambian varias cosas al mismo tiempo:

privacidad
latencia
costos
autonomía
capacidad de experimentar de verdad con modelos, cuantización y hardware

Este episodio busca aterrizar esa idea sin humo y sin misticismo.
Menos “la IA como magia”.
Más “la IA como sistema que puedes entender, operar y controlar”.

Si te interesa la intersección entre modelos, infraestructura, rendimiento y soberanía tecnológica, creo que este episodio te va a gustar.

🎧 Escúchalo aquí:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/adios-a-la-caja-negra-ejecutando-ia-en-tu-propia-maquina/

Stop Chasing Scroll with JavaScript: A Deep Dive into CSS Scroll-Driven Animations

Tu codigo cotidiano — Thu, 02 Apr 2026 16:41:38 +0000

I published a deep-dive guide about CSS scroll-driven animations and how they change the architectural layer where motion is controlled.

This is not just about making parallax “look cooler”.
It is about stopping the habit of chasing scroll with JavaScript and starting to model motion as a declarative timeline the browser can understand natively.

In the guide I cover:

scroll-timeline
scroll()
view()
animation-range
progressive enhancement
production debugging
when to use scroll() vs view()
how to build parallax without JS

Read it here:
https://tucodigocotidiano.yarumaltech.com/leer_guias/animaciones-vinculadas-al-scroll-la-api-scroll-timeline-para-efectos-parallax-sin-js/

Cables submarinos: la infraestructura invisible que sostiene internet

Tu codigo cotidiano — Wed, 01 Apr 2026 14:22:18 +0000

Acabo de publicar un nuevo episodio en Tu código cotidiano sobre uno de esos temas que cambian por completo la forma en que entendemos la red:

los cables submarinos.

Muchas veces hablamos de “la nube” como si internet fuera algo etéreo, abstracto o casi mágico. Pero una parte enorme del tráfico global viaja por una infraestructura física muy concreta: fibras ópticas tendidas bajo el mar que conectan continentes, centros de datos, mercados y sistemas completos.

En este episodio explico, de forma clara y técnica:

por qué los cables submarinos son esenciales para internet
por qué no todo viaja por satélite
cómo la red depende de rutas físicas reales
qué papel juegan la capacidad, la latencia y la redundancia
y por qué esta infraestructura también tiene una dimensión geopolítica y económica

Es un episodio pensado para desarrolladores, gente de telecomunicaciones, curiosos de internet y cualquier persona que quiera entender mejor qué hay debajo de la experiencia digital cotidiana.

🎧 Escúchalo aquí:
tucodigocotidiano.yarumaltech.com/escuchar-podcast/cables-submarinos-las-arterias-fisicas-e-invisibles-de-internet/

Service Workers: Caching Strategies and Offline Architecture (Cache First, Network First)

Tu codigo cotidiano — Tue, 31 Mar 2026 14:39:17 +0000

I just published a new technical guide on Service Workers, caching strategies, and offline architecture.

This guide is written from an architectural perspective, not as a quick recipe. The main idea is simple: a Service Worker is not just a tool to cache files. It is a response policy layer between your app and the network.

Inside the guide, I cover:

what a Service Worker really is
how to think about install, activate, and fetch
precaching and cache versioning
the real differences between Cache First, Network First, and stale-while-revalidate
hybrid architecture depending on resource type
common implementation mistakes
practical criteria to decide what should be cached and what should not

The guide is aimed at developers who want to stop treating caching as a performance trick and start treating it as a product and resilience decision.

Read it here:
https://tucodigocotidiano.yarumaltech.com/leer_guias/service-workers-estrategias-de-cache-y-arquitectura-offline-cache-first-network-first/