Episodes

  • How Email Was Invented: The First Network Message, the At Sign and SMTP
    Oct 3 2026

    The history of email from the original documents: mailboxes on a single time-sharing computer, Ray Tomlinson's first network message and his choice of the at sign, the first header standard with From, Date and Subject, the SMTP conversation between mail servers, and how envelope, contents and POP3 get mail to you.

    0:19 Before the network: one computer, many mailboxes

    Mail between users of a single time-sharing computer already existed; a mailbox was just a file others could add to but not read.

    Sources: Ray Tomlinson (original)

    1:33 The first network message and the at sign

    Tomlinson merged a file transfer program into SNDMSG and chose the at sign to separate the user from the host; the first messages went between two machines side by side.

    Sources: Ray Tomlinson (original) · Internet Hall of Fame (original)

    3:16 From, Date, Subject: the first header standard

    RFC 561, in 1973, proposed a common format for the From, Date and Subject lines because every system wrote them differently.

    Sources: RFC 561 (original) · Internet Hall of Fame (original)

    4:40 SMTP: the conversation between mail servers

    In 1982 RFC 821 defined SMTP, a strict, one step at a time dialogue of commands and numbered replies that can relay mail across networks.

    Sources: RFC 821 (original) · Internet Hall of Fame (original)

    6:30 Envelope, letter and mailbox: how mail reaches you

    RFC 822 split a message into envelope and contents; POP3 let computers that are not always online fetch mail from a server.

    Sources: RFC 822 (original) · RFC 1939 (original)

    Follow the show in your podcast app to get each new episode as soon as it is out.

    Produced by Juan Pablo.

    Show More Show Less
    8 mins
  • What Happens When You Open a Website: DNS, HTTPS and How Browsers Load a Page
    Oct 3 2026

    One page load, step by step: how DNS finds the server, what the TCP and TLS handshakes do, how a certificate authority like Let's Encrypt vouches for a site, what an HTTP request and response look like and why HTTP/3 moved to QUIC, and how the browser turns code into pixels.

    0:23 Finding the address: DNS

    The Domain Name System turns a name into an IP address through a resolver, a root server, a top-level domain server and an authoritative server, with caching at every level.

    Sources: Cloudflare Learning Center (original) · MDN Web Docs (original)

    1:45 Two handshakes: TCP and TLS

    A TCP three-way handshake opens the connection; the TLS handshake agrees on keys, proves the server identity and encrypts everything after it.

    Sources: MDN Web Docs (original) · IETF RFC 8446 (original)

    3:27 Who vouches for the server: certificates

    A certificate authority ties a public key to a domain name after the server proves it controls the domain; Let's Encrypt does it with the automated ACME protocol.

    Sources: Let's Encrypt (original)

    4:51 The request and the response: HTTP

    HTTP is a plain, extensible, stateless request and response protocol; versions one point one, two and three changed how messages travel, not what they mean.

    Sources: MDN Web Docs (original) · IETF RFC 9114 (original)

    6:29 From code to pixels: rendering

    The browser parses HTML and CSS into trees, builds a render tree, runs layout and paints pixels; late images without dimensions force a reflow.

    Sources: MDN Web Docs (original)

    Follow the show in your podcast app to get each new episode as soon as it is out.

    Produced by Juan Pablo.

    Show More Show Less
    8 mins
  • How Diffusion Models Make Images: From Pure Noise to a Picture
    Oct 3 2026

    How AI image generators turn random static into a picture: the idea of destroying an image with noise and learning to undo it, how the model is trained to predict noise, what happens step by step when you generate, why latent diffusion made it cheap enough to run, and how a text prompt steers the result.

    0:36 Destroy, then learn to undo

    Diffusion models come from an idea borrowed from physics: slowly destroy the structure in data with noise, then learn the reverse process that restores it.

    Sources: arXiv (original) · Hugging Face blog (original)

    2:05 Training a noise detector

    In the denoising diffusion approach of Ho and colleagues, the network learns to predict the noise that was added to an image, scored with a simple error measure.

    Sources: arXiv (original) · Hugging Face blog (original)

    3:41 Generating, step by step

    Generation starts from random noise the size of the output; at each step the model predicts the noise and a scheduler removes part of it.

    Sources: Hugging Face Diffusers docs (original)

    4:56 Latent diffusion: working on a sketch

    Latent diffusion runs the denoising in the compressed space of an autoencoder instead of on full pixels, which cuts the cost dramatically.

    Sources: arXiv (original) · Hugging Face Diffusers docs (original)

    6:19 How the prompt steers the picture

    A text encoder turns the prompt into numbers the denoiser attends to, and classifier-free guidance controls how strongly the image follows the prompt.

    Sources: arXiv (original) · arXiv (original) · Hugging Face Diffusers docs (original)

    Follow the show in your podcast app to get each new episode as soon as it is out.

    Produced by Juan Pablo.

    Show More Show Less
    8 mins