VFlash: Fast, Accurate Visual Planning via Flash Primitive Decoding
u_Unrolled
D1: CS & Systems Foundations · Bridge: From Storing Text to Understanding It
Phase 1/Domain 1/Lesson 30

Bridge: From Storing Text to Understanding It

10 min read·Foundational·Free lesson
Bridge: From Storing Text to Understanding It
Diagram, one picture of Domain 1: a request travelling network → process (OS) → Python code → data structures → database and back, with each layer labelled by the lesson that taught it.
Diagram— Diagram, one picture of Domain 1: a request travelling network → process (OS) → Python code → data structures → database and back, with each layer labelled by the lesson that taught it.

What Atlas can do now

Lesson Atlas gained
Python internals Runs as a Python service; heavy work goes to packed arrays
C++ & memory Knows where data lives and why layout decides speed
Data structures Finds sessions in O(1), schedules requests with a heap, reuses shared prompt prefixes
Operating systems Runs many workers safely; manages memory in pages
Networking Answers over HTTPS, streams tokens, retries safely, rate-limits
Databases Remembers progress and payments safely, with indexes and transactions

The problem Atlas can't solve yet

Ask Atlas: "Is GPU memory the same as VRAM?"

It can store both phrases, index them and fetch them in microseconds — but it can't tell that they mean nearly the same thing. A database index answers "is this string equal to that string?" Understanding needs "is this similar to that?"

Computers only compare numbers. So we need a way to turn meaning into numbers, and then measure closeness between them.

The idea that opens Domain 2

Describe each phrase with a list of scores — say, how much it's about hardware, about storage, about speed:

python
import numpy as np

phrases = {
    "GPU memory":   np.array([0.9, 0.8, 0.3]),
    "VRAM":         np.array([0.9, 0.9, 0.2]),
    "TCP handshake": np.array([0.2, 0.0, 0.6]),
}

def similarity(a, b):
    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b)))   # cosine similarity

q = phrases["GPU memory"]
for name, vec in phrases.items():
    print(f"{name:14s} {similarity(q, vec):.2f}")
# GPU memory 1.00, VRAM 0.99, TCP handshake 0.46

That list of scores is a vector. Similar meanings get vectors pointing in similar directions, and one multiply-and-add operation — the dot product — measures how aligned they are. Real models learn vectors with hundreds or thousands of scores automatically instead of us choosing three by hand.

three arrows on a 2-D grid — "GPU memory" and "VRAM" close together, "TCP handshake" pointing away; the small angle between the first two shaded.
Diagram— three arrows on a 2-D grid — "GPU memory" and "VRAM" close together, "TCP handshake" pointing away; the small angle between the first two shaded.

Where Domain 2 takes us

  1. Linear algebra — vectors, matrices and dot products: the language of embeddings and attention.
  2. Calculus — how a model measures "how wrong" and which way to adjust.
  3. Probability & statistics — reasoning about uncertainty and evaluating models honestly.
  4. Optimization — the algorithms (SGD, Adam) that actually do the adjusting.
  5. Information theory — entropy and cross-entropy: the loss every LLM is trained on.

You'll keep using Domain 1 throughout: vectors are the packed NumPy arrays from Python internals, and their memory layout is exactly why GPUs (D13) are so good at this maths.

Next: D2 · Linear algebra →