DEV Community: Tu codigo cotidiano

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/

Building a Perceptron from Scratch in Vanilla JS — No Libraries, Just Math

Tu codigo cotidiano — Mon, 30 Mar 2026 13:59:17 +0000

I just published a Spanish tutorial on building a perceptron from scratch in Vanilla JS, with no libraries.

The goal is not just to “use AI”, but to understand the smallest possible neural unit as executable code:

inputs → weighted sum → activation → error → weight update

If you enjoy low-level explanations and code-first teaching, this one is for you.

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/el-perceptron-desde-cero-escribe-la-matematica-de-una-red-neuronal-simple-en-vanilla-js-sin-librerias/

Constraint Validation API: cómo diseñar formularios con menos JavaScript y mejor arquitectura

Tu codigo cotidiano — Fri, 27 Mar 2026 17:52:33 +0000

Muchos equipos siguen validando formularios como si HTML fuera solo una carcasa visual y toda la lógica tuviera que vivir en JavaScript.

Pero el navegador ya trae una capa mucho más potente de lo que solemos reconocer: restricciones declarativas, estados de validez, mensajes nativos y una API para consultar el estado lógico del formulario.

Acabo de publicar una guía sobre la Constraint Validation API con un enfoque menos superficial y más arquitectónico.

En la guía explico:

cómo pensar un formulario como sistema de restricciones
cuándo usar checkValidity() y reportValidity()
dónde empieza JavaScript de verdad
por qué validar todo a mano suele ser una trampa

La idea de fondo es simple: menos lógica duplicada, más semántica y mejor distribución de responsabilidades.

Aquí está la guía completa:
https://tucodigocotidiano.yarumaltech.com/leer_guias/validacion-constraint-api-logica-matematica-de-formularios-sin-tocar-javascript/

Criptografía de extremo a extremo: las matemáticas que protegen nuestros secretos

Tu codigo cotidiano — Thu, 26 Mar 2026 18:28:08 +0000

Cada vez que envías un mensaje, haces una llamada o compartes información sensible, hay una pregunta silenciosa detrás de todo: ¿quién podría leer eso en el camino?

Publiqué un nuevo episodio en Tu código cotidiano sobre un tema que sostiene gran parte de la privacidad digital moderna: la criptografía de extremo a extremo.

En este episodio explicamos, de forma clara y técnica, ideas como:

qué significa realmente “de extremo a extremo”
por qué no es lo mismo cifrar en tránsito que cifrar contenido real
cómo entran en juego las claves públicas y privadas
por qué conceptos como Diffie-Hellman o forward secrecy importan tanto
y por qué la privacidad no es lujo, sino infraestructura de libertad

Es un episodio pensado para desarrolladores, curiosos de la tecnología, gente de seguridad y cualquier persona que quiera entender qué protege de verdad sus conversaciones digitales.

🎧 Escúchalo aquí:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/criptografia-de-extremo-a-extremo-matematicas-que-protegen-nuestros-secretos/

Why Native CSS Nesting Matters: Less Repetition, More Real Structure in Your CSS

Tu codigo cotidiano — Wed, 25 Mar 2026 18:30:34 +0000

For a long time, a lot of CSS friction came from repeating context over and over again.

Component.
Child.
State.
Variant.
Pseudo-state.

That is why CSS Nesting matters.

Not because it saves a few lines.
Because it helps CSS express structure more naturally.

I published a practical guide about native CSS Nesting, including:

when to use &
when not to
real component examples
common mistakes
architecture limits

Read it here:
https://tucodigocotidiano.yarumaltech.com/leer_guias/css-nesting-nativo-menos-repeticion-mas-estructura-real-en-tu-css/

css #frontend #webdev #softwareengineering #tutorial