Forem: Tu codigo cotidiano

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

Why is everyone rewriting tools in Rust?

Tu codigo cotidiano — Tue, 24 Mar 2026 13:54:43 +0000

Why is everyone rewriting tools in Rust?

Rust stopped being just an internet meme and became a real engineering decision.

In this new episode of Tu código cotidiano, we explain why so many teams are moving critical tools to Rust: memory safety, performance, no garbage collector, and a compiler that catches problems before production.

We also break down the bigger shift behind it all: why modern software teams are no longer willing to choose between speed and safety.

If you work in backend, systems, tooling, DevOps, or just want to understand why Rust keeps showing up everywhere, this episode is for you.

🎧 Listen here:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/por-que-todo-el-mundo-esta-reescribiendo-herramientas-en-rust/

UDP in Real Time: Why Late Data Can Be Worse Than Lost Data

Tu codigo cotidiano — Mon, 23 Mar 2026 13:04:31 +0000

I just published a hands-on tutorial where I build a small Rust workspace with a UDP sender and receiver to explore a real-time networking idea that often surprises people:

in interactive systems, late packets can be more harmful than lost packets.

The project detects packet loss, out-of-order delivery, jitter, and late arrivals, with a structure designed to make the behavior observable instead of abstract.

If you're into Rust, networking, telemetry, or real-time systems, this might be useful:
https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/udp-en-tiempo-real-por-que-recibir-datos-tarde-es-peor-que-perderlos/

Feedback is welcome.

SharedArrayBuffer: Deep Concurrency and Shared Memory Between Workers

Tu codigo cotidiano — Sat, 21 Mar 2026 03:03:05 +0000

I just published a new guide about SharedArrayBuffer and how it changes the way we think about concurrency in the browser.

This is not just about “sending data faster” to a Worker.

It is about understanding the difference between:

copying data,
transferring ownership,
and exposing the same underlying memory to multiple threads.

In the guide I cover:

what SharedArrayBuffer really is,
why shared memory without Atomics is dangerous,
how cross-origin isolation becomes a hard requirement,
where this model actually pays off,
and why it should never be your default choice.

My main argument is this: https://tucodigocotidiano.yarumaltech.com/leer_guias/sharedarraybuffer-concurrencia-profunda-y-memoria-compartida-entre-workers/

Once two threads can touch the same memory in real time, you are no longer doing ordinary frontend work. You are designing concurrency.

What Is a Vector in AI and Why Does It Matter So Much?

Tu codigo cotidiano — Fri, 20 Mar 2026 00:47:54 +0000

We often hear that AI can “understand” text, images, or user intent.
But under the hood, a lot of that apparent understanding depends on something much more mathematical: vectors.

In this new episode of TuCodigoCotidiano, we break down a simple but powerful idea:

A vector in AI is not just a list of numbers.
It is a way to represent features, meaning, context, or similarity in a form that machines can compare.

That matters because vectors are everywhere in modern AI:

semantic search

recommendation systems

embeddings

context retrieval

similarity matching across text, images, audio, and more

The goal of this episode was to explain the concept in a way that feels intuitive without losing technical value.

If you’ve seen terms like embeddings, vector databases, or semantic retrieval and wanted a cleaner mental model, this episode is for you.

🎧 Listen here:
https://tucodigocotidiano.yarumaltech.com/escuchar-podcast/que-es-un-vector-en-ia-y-por-que-importa-tanto/

I’d love to know:
Which topic should come next — embeddings, vector databases, or RAG?