Short definitions of every term the course uses. The lesson in brackets is where it is explained.
| Term | Meaning |
|---|---|
| Alignment | The address multiple at which a value must start; the cause of struct padding. (II.04) |
| Arena | A region of the heap reserved from the OS (III.03); also a pattern of allocating many objects from one block and freeing them together. (III.05) |
| Atomic | An operation on one word that completes indivisibly. (IV.04) |
| Attention | The transformer operation in which a token gathers information from earlier tokens. (VI.05) |
| Backpressure | A slow consumer slowing its producer, usually through a bounded queue. (IV.06) |
| Bounds check | The run-time test that an index is within a slice; removable when provably safe. (V.02) |
| BPE | Byte-pair encoding: a tokenizer built by repeatedly merging the most frequent adjacent pair. (VI.04) |
| Cache line | The 64-byte unit in which the CPU loads and owns memory. (V.03) |
| cgo | Go’s mechanism for calling C. (V.04) |
| Channel | A typed, synchronized queue between goroutines. (IV.02) |
| Closure | A function value that captures variables from its surroundings. (I.03) |
| Context | A value carrying cancellation, a deadline and request-scoped data down a call chain. (IV.03) |
| Data race | Unsynchronized concurrent access to a variable, at least one a write. (IV.05) |
| Devirtualization | Turning an interface method call into a direct call. (V.02) |
| Dynamic batching | Grouping requests that arrive close together into one model call. (VI.08) |
| Embedding | A vector representing an item so that similar items are close together. (VI.07) |
| Escape analysis | The compiler pass deciding whether a value can live on the stack. (III.02) |
| False sharing | Independent variables on one cache line slowing each other’s writers. (V.03) |
| G, M, P | Goroutine, OS thread, and scheduling context. (IV.01) |
| Generics | Functions and types with type parameters constrained by interfaces. (II.06) |
GOGC | The heap growth percentage that triggers the next garbage collection. (III.04) |
GOMAXPROCS | The number of Ps: how many goroutines run Go code at once. (IV.01) |
GOMEMLIMIT | A soft ceiling on the runtime’s total memory. (III.04) |
| Goroutine | A function running concurrently on its own small, growable stack. (IV.01) |
| Green Tea | The span-oriented garbage collector implementation, default since Go 1.26. (III.04) |
| Happens-before | The ordering relation that defines when one goroutine’s write is visible to another. (IV.05) |
| Heap | Memory that outlives a function call, managed by the allocator and the GC. (III.01) |
| HNSW | A graph-based approximate nearest-neighbour index. (VI.07) |
| Inlining | Replacing a call with the callee’s body. (V.02) |
| Interface value | Two words: a type (or method table) and a data pointer. (II.05) |
| Iterator | A function that can be ranged over, yielding values one at a time. (II.06) |
| IVF | An approximate index that searches only the partitions nearest the query. (VI.07) |
| KV cache | Stored attention keys and values for previous tokens. (VI.05) |
| Logits | The model’s raw scores, one per vocabulary entry. (VI.05) |
| mcache / mcentral / mheap | The allocator’s per-P, per-size-class and global tiers. (III.03) |
| MCP | Model Context Protocol: a standard for exposing tools and data to models. (VI.09) |
| Method set | The methods available on a type; decides interface satisfaction. (I.04) |
| Module | A versioned tree of packages with a go.mod file. (I.05) |
| Netpoller | The runtime component that parks goroutines on network I/O and wakes them. (V.05) |
| PGO | Profile-guided optimization using a production CPU profile. (V.02) |
| Preemption | The runtime interrupting a long-running goroutine. (IV.01) |
| Recall | The fraction of true nearest neighbours an approximate search returns. (VI.07) |
| Rune | A Unicode code point; int32. (II.02) |
| Size class | One of the fixed object sizes the allocator serves. (III.03) |
| Slice header | Pointer, length and capacity describing a window on an array. (II.01) |
| Span | A run of 8 KB pages dedicated to one size class. (III.03) |
| SSE | Server-Sent Events: the streaming format used by LLM APIs. (V.05, VI.06) |
| Stack | Per-goroutine memory for function frames; grows by copying. (III.01) |
| Swiss table | The hash-table design behind Go’s maps since 1.24. (II.03) |
sync.Pool | A cache of reusable temporary objects, emptied by the GC. (III.05) |
| Tensor | A flat array of numbers plus a shape. (VI.02) |
| Tool call | A model’s request that the program run a named function with JSON arguments. (VI.09) |
| Tri-colour marking | The white/grey/black algorithm the collector uses to find live objects. (III.04) |
| Work stealing | An idle P taking runnable goroutines from another P’s queue. (IV.01) |
| Write barrier | Code run on pointer writes during GC marking to keep it correct. (III.04) |
| Zero value | The default every variable starts with: 0, "", false, nil. (I.02) |