DEV Community: Tu codigo cotidiano

Python for Absolute Beginners: Start With One Line of Code

Tu codigo cotidiano — Thu, 02 Jul 2026 17:03:39 +0000

Many people want to learn programming, but they stop before writing their first line of code.

Not because they are not capable.

Because programming often feels too big at the beginning:

artificial intelligence, data, automation, web development, frameworks, tools, installations, terminals, errors…

So I wrote a beginner-friendly guide in Spanish with one simple goal:

help someone understand why Python is so popular and write their first real line of code.

print("Hola, mundo")

That line looks small, but it represents something powerful:

you write an instruction, the computer reads it, and something happens on the screen.

That is the first real connection with programming.

In the guide, I explain visually and step by step:

why Python is used in artificial intelligence
why it is useful for data analysis
how it helps with automation
how it connects with web development
why it is one of the best languages for beginners
what print("Hola, mundo") means
how to try your first line without feeling overwhelmed

The goal is not to understand everything on day one.

The goal is much simpler:

“I can try this.”

Programming does not start with knowing everything.

It starts with curiosity, one simple instruction, and the confidence to keep going.

I wrote this guide for people who are just starting and need a friendly first step.

Full guide in Spanish:

https://tucodigocotidiano.yarumaltech.com/leer_guias/por-que-python-es-el-lenguaje-del-momento-tu-primera-linea-de-codigo/

What was the first line of code you ever wrote?

Build a Minimal Git in Rust: Objects, Hashes, Commits and Log

Tu codigo cotidiano — Mon, 29 Jun 2026 14:01:56 +0000

I built a MiniGit in Rust to understand how Git works internally

Git is one of those tools we use every day, but many times it feels like a black box.

We know how to run:

git init
git commit
git log

But what actually happens inside?

I wrote a full Spanish tutorial where we build a small educational version of Git in Rust, step by step.

The project creates a .minigit folder and implements the core ideas behind Git:

Reading files as exact bytes
Creating blob objects
Calculating SHA-1 hashes like Git
Saving objects by hash
Recovering content from objects
Creating minimal commits
Updating refs/heads/main
Walking commit history with log

The goal is not to replace Git.

The goal is to open the black box and understand the model:

file
  ↓
exact bytes
  ↓
blob object
  ↓
SHA-1
  ↓
.minigit/objects/<hash>
  ↓
commit
  ↓
refs/heads/main
  ↓
log

This tutorial is especially useful if you are learning Rust, Git internals, systems programming, or how content-addressed storage works.

The article is in Spanish, but the code is simple and easy to follow.

Read the full tutorial here:

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/tu-propio-git-minimo-en-rust-objetos-hashes-commits-y-log/

I would love to know what you think, especially if you are also interested in building developer tools from scratch.

Build an HTTP server from scratch in Rust — no frameworks, no dependencies

Tu codigo cotidiano — Mon, 22 Jun 2026 15:37:47 +0000

A web server does not start as a framework.

Before Axum, Actix, Rocket, Express, Django or FastAPI, there is something much simpler:

a program that opens a TCP port, accepts connections, reads bytes, interprets an HTTP request and writes back a response the browser can understand.

I wrote a Spanish tutorial where we build that from scratch using only Rust’s standard library.

The tutorial covers:

TcpListener and TcpStream

reading real HTTP requests from the browser

building HTTP responses manually

simple routing

serving HTML files from public/

handling 404 NOT FOUND

handling 500 INTERNAL SERVER ERROR

basic concurrency with std:🧵:spawn

The main idea:

HTTP is not magic. HTTP is formatted text traveling over TCP.

If you are learning backend development, Rust, networking or just want to understand what web frameworks hide under the hood, this tutorial is for you.

Tutorial here:

https://tucodigocotidiano.yarumaltech.com/leer_tutoriales/servidor-http-desde-cero-sobre-tcp-en-rust-sin-frameworks-y-sin-dependencias/

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/