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.

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.

Where the electricity behind AI actually goes: training versus everyday use, what the chips draw, why a data center spends energy on more than computing, how one company measured the energy of a single prompt, and the engineering levers that cut the footprint by large factors.

0:36 Two kinds of work: training and answering

AI uses energy in two phases: training a model once, and inference every time someone uses it; the compute used for the largest training runs grew exponentially.

Sources: OpenAI (original) · Google Cloud blog (original)

1:52 Where the watts go: the machines

Accelerator chips draw hundreds of watts each, but host processors, memory and machines kept idle for spikes also use energy.

Sources: Nvidia (original) · Google Cloud blog (original)

3:21 The building: cooling and PUE

Power usage effectiveness compares a data center's total energy with what reaches the computers; cooling is one of the biggest overheads, and machine learning cut Google's cooling energy by up to forty percent.

Sources: Google DeepMind (original) · Google Data Centers (original) · Google Cloud blog (original)

4:41 The energy of one question

Google estimated the median Gemini Apps text prompt at about a quarter of a watt-hour when counting the whole system, more than double the chip-only figure.

Sources: Google Cloud blog (original)

5:59 The levers that cut it

Sparse models, efficient data centers and accelerators, carbon-aware location, and serving tricks like distillation and speculative decoding can cut energy by large factors.

Sources: arXiv (original) · Google Cloud blog (original)

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

Produced by Juan Pablo.

The vocabulary of software security made plain: what a vulnerability, an exploit and a patch are, why some attacks are called zero-days, what a real security advisory looks like, how researchers and vendors coordinate disclosure, what a severity score does and does not tell you, and what to do when a fix is not ready yet.

0:26 Vulnerability, exploit, patch

A vulnerability is an unintended flaw; an exploit is code that takes advantage of it; a zero-day exploit hits a flaw that has no fix yet.

Sources: Cloudflare Learning Center (original) · Google Project Zero (original)

2:03 Reading a real advisory

A real vendor advisory for an email security appliance: a path traversal flaw letting an attacker with no login write files, reported exploited in the wild, with a workaround and signs of compromise.

Sources: Fortinet PSIRT (original) · MITRE CWE-22 (original)

3:32 When do researchers go public?

Under coordinated disclosure, researchers report flaws privately so the vendor can ship a fix first; Project Zero's deadline is ninety days, or seven if the flaw is under attack.

Sources: Microsoft Security Response Center (original) · Google Project Zero (original)

4:55 What a severity score tells you

CVSS scores a vulnerability from zero to ten; nine to ten is critical, but the base score measures severity, not the risk to you.

Sources: FIRST (original)

6:17 What to do when the fix isn't ready

Patch quickly, use the vendor's workaround when there is no patch yet, look for signs of compromise, and reduce exposure.

Sources: Google Project Zero (original) · Fortinet PSIRT (original) · Cloudflare Learning Center (original)

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

Produced by Juan Pablo.

Why it is so easy to fake the sender of an email, what phishing messages have in common, how the three email authentication standards SPF, DKIM and DMARC let receiving servers catch forged mail, what they cannot stop, and the habits that protect you anyway.

0:31 What phishing looks like

Phishing tries to steal personal information or break into accounts with deceptive messages and sites that imitate ones you trust, usually with urgency.

Sources: Google Help (original)

1:43 Why email is so easy to fake

The basic mail protocol, SMTP, has no built-in way to authenticate the sender, so the From line can be forged.

Sources: Cloudflare Learning Center (original) · RFC 7208 (original)

2:51 SPF and DKIM: a guest list and a seal

SPF lets a domain publish which servers may send its mail; DKIM adds a cryptographic signature checked against a public key in DNS.

Sources: RFC 7208 (original) · Google Workspace Admin Help (original) · RFC 6376 (original) · Cloudflare Learning Center (original)

4:23 DMARC: what to do when the check fails

DMARC ties SPF and DKIM to the visible From address and lets the domain owner ask receivers to do nothing, quarantine or reject failing mail, with reports back.

Sources: RFC 7489 (original)

5:56 What authentication can't stop

Authentication does not stop lookalike domains or mail from real accounts that were taken over, so personal habits still matter.

Sources: Cloudflare Learning Center (original) · Google Help (original)

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

Produced by Juan Pablo.

Why operating systems ask permission before an app reads your files, why full disk access is special, what changes when the software asking is an AI agent that acts on its own, how prompt injection turns an agent's permissions against you, and the old security principle that limits the damage.

0:39 How a computer asks for consent

Modern operating systems require user consent before apps reach protected folders or restricted data, and let users switch that access on or off per app.

Sources: Apple Platform Security (original) · Apple Support (original) · Android Developers (original)

2:06 The master key: Full Disk Access

Full Disk Access largely sidesteps the Mac's privacy controls so backup apps can work; Apple has said the risk grows as AI agents become more autonomous.

Sources: Apple Developer News (original) · Apple Platform Security (original)

3:28 What makes an agent different

Agents plan and act on their own over many steps, using tools; that autonomy brings compounding errors and calls for sandboxes and guardrails.

Sources: Anthropic Engineering (original) · OWASP Gen AI Security Project (original)

4:44 Prompt injection: when the data gives orders

Indirect prompt injection hides instructions in content an agent reads, such as a web page, a file or an email, and can turn the agent's permissions against its user.

Sources: OWASP Gen AI Security Project (original) · OWASP Gen AI Security Project (original)

6:03 The fix is an old one: least privilege

Give every program the smallest set of privileges it needs, check every access, and keep a human in the loop for high-impact actions.

Sources: Saltzer and Schroeder (original) · Saltzer and Schroeder (original) · OWASP Gen AI Security Project (original)

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

Produced by Juan Pablo.

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.

How a keyboard can learn from what millions of people type without collecting their typing: the federated learning loop, the averaging trick that saves bandwidth, secure aggregation, differential privacy, and how sealed processors let outsiders check the server side.

0:27 Bring the model to the data

Instead of uploading data, each phone trains the shared model locally and sends back only a small, encrypted update that is averaged with many others.

Sources: Google Research (original)

1:50 The averaging trick

Federated Averaging lets phones do more work locally so far fewer rounds of communication are needed.

Sources: arXiv (original) · Google Research (original)

3:15 Hiding each phone in the crowd

Secure Aggregation uses cryptography so the server can only read the sum of many updates, never one phone's update.

Sources: IACR ePrint (original) · Google Research (original)

4:18 Adding noise on purpose

Differential privacy adds calibrated random noise during training so the final model cannot memorize any one person's data.

Sources: Google Research (original)

5:33 From trust us to check us

Running the server side inside trusted execution environments, with access policies in a public log, lets outsiders verify what code touches the data.

Sources: Google Research (original)

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

Produced by Juan Pablo.

Language models do not read words, they read tokens. What a token is, how byte pair encoding chops text into pieces, why the same sentence costs more tokens in some languages, what the context window really holds, and why a bigger window does not mean the model pays equal attention to everything in it.

0:28 What a token is

Models process text as tokens, pieces that can be a character, part of a word, a whole word or punctuation; in English one token is roughly three quarters of a word.

Sources: OpenAI Help Center (original) · GitHub (original)

1:50 How text is cut into pieces

Byte pair encoding starts from single characters and keeps merging the most frequent neighboring pair, so common words stay whole and rare words split into known pieces.

Sources: Hugging Face Transformers docs (original) · arXiv (original) · GitHub (original)

3:38 Why some text costs more tokens

Token counts depend on the model, its encoding and the language, so the same idea can take a different number of tokens.

Sources: OpenAI Help Center (original) · Hugging Face Transformers docs (original)

4:54 What the context window holds

The context window is the model's working memory: everything it can refer to while answering, including its own answer.

Sources: Claude Docs (original) · OpenAI Help Center (original)

6:08 Bigger is not always better

Accuracy and recall can degrade as the context grows, and models often use information at the start or end of a long input better than information in the middle.

Sources: Claude Docs (original) · arXiv (original) · OpenAI Help Center (original)

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

Produced by Juan Pablo.

What actually happens inside a large language model: how it learns by predicting the next word, what the Transformer and its attention mechanism do, why size changed what these models can do, how a raw text predictor is turned into an assistant that follows instructions, and why it sometimes makes things up with total confidence.

0:30 A machine that guesses the next word

Pretraining: the model reads huge amounts of text and learns to predict the next word, with no human labels.

Sources: Hugging Face LLM Course (original) · OpenAI (original)

1:54 The Transformer and attention

The Transformer, introduced by Google researchers in the paper Attention Is All You Need, lets every word look at every other word in one step.

Sources: Google Research (original) · arXiv (original)

3:27 Why size changed everything

Most modern LLMs keep only the decoder half of the Transformer; scaling them up made few-shot learning possible.

Sources: Hugging Face LLM Course (original) · arXiv (original)

4:56 From text predictor to assistant

Fine-tuning with human demonstrations and rankings, known as reinforcement learning from human feedback, turns a raw text predictor into an assistant.

Sources: OpenAI (original) · arXiv (original)

6:16 Why it makes things up

Hallucinations come from next-word prediction on rare facts and from tests that reward guessing over saying I don't know.

Sources: OpenAI (original)

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

Produced by Juan Pablo.