ComputationPath

Binary and Bits

Why computers represent everything as bits, how integers are encoded in two's complement, and how hexadecimal compresses bytes for human use.

Character Encodings: ASCII, UTF-8, Unicode

How text became bytes: from 7-bit ASCII to Unicode code points to UTF-8 variable-width encoding, with worked byte-level examples.

Compression Fundamentals

Why text compresses but random bits do not. Entropy gives the floor, Huffman codes approach it, and LZ77 supplies the dictionary core of gzip.

Error Detection and Correction

Parity bits catch single flips, Hamming codes correct them, and CRCs catch burst errors in networks and storage. The Singleton and Hamming bounds say what is achievable.

Floating-Point Representation (IEEE 754)

How real numbers fit in 32 or 64 bits: sign, exponent, mantissa, the implicit leading 1, NaN, infinity, denormals, and the precision tradeoffs that bite ML.

Boolean Algebra

The algebra of true and false: operators, identities, normal forms, Karnaugh maps, and the minimization step used before building gates.

Building An ALU From Gates

How a chip-scale arithmetic-logic unit is assembled from 1-bit slices, carry chains, two's-complement subtraction, flags, and operation-select muxes.

Combinational Circuits

Circuits whose outputs are pure functions of current inputs, from gates to adders, comparators, multipliers, delay, fan-out, and glitches.

Decoders, Encoders, Multiplexers

Signal selectors for digital datapaths: decoders choose one line, multiplexers choose one value, and encoders compress active lines into indices.

NAND Universality

Every Boolean function reduces to NAND gates alone. One gate type, one mask pattern, and in CMOS it costs fewer transistors than AND or OR.

Sequential Circuits and Flip-Flops

Memory in digital logic comes from feedback. This page builds SR latches, D latches, edge-triggered flip-flops, timing constraints, counters, shift registers, and finite-state machines.

Branch Prediction

Why mispredicted branches cost dozens of cycles, and how modern CPUs reach >95% prediction accuracy with two-level adaptive and TAGE predictors.

Cache Hierarchy

Why memory is a pyramid. L1/L2/L3, cache lines, associativity, replacement, write policy, and AMAT as the effective access-time model.

Instruction Set Architectures (ISA)

The contract between software and hardware. RISC vs CISC, x86-64 vs ARM64 vs RISC-V, and how ISA choices shape every layer above.

Machine Language And Assembly

What CPUs actually execute: opcodes, fields, addressing modes, and how a one-line C statement becomes a half-dozen machine instructions readable as assembly.

Out-of-Order Execution

How modern CPUs find independent work to fill stalls through register renaming, scheduling, speculation, and in-order retirement.

Pipelining Basics

Why overlap fetch, decode, execute and writeback across consecutive instructions. The 5-stage pipeline, hazards, and bypassing.

Registers And The Instruction Cycle

The CPU as a fetch-decode-execute-writeback loop over a small register file, with PC, IR, ALU, and one ADD instruction through the datapath.

SIMD and Vector Instructions

One instruction, many data lanes. SSE, AVX, AVX-512, NEON, and SVE explain why dense ML kernels are written against intrinsics.

Memory Allocation (Malloc, Free, Jemalloc)

How malloc and free build variable-size heap allocation on sbrk and mmap, from boundary tags to jemalloc and tcmalloc size classes.

Memory-Mapped I/O and Mmap

Two uses of one abstraction: device registers as load/store addresses, and files paged into virtual memory by mmap().

Pointers And Addresses

A pointer is a virtual address with a C type. Pointer arithmetic, null traps, aliasing rules, and callbacks all follow from that pairing.

Stack vs Heap

Two regions, two lifetimes. Stack frames push and pop with calls; heap allocations live until freed. The model behind every undefined-behavior bug.

TLB and Locality

Walking a 4-level page table costs ~100 cycles. The TLB caches recent translations, and locality decides whether memory code stays inside that cache.

Virtual Memory

Each process sees a flat private 64-bit address space. The kernel and MMU map virtual pages to physical frames, faulting pages from disk when needed.

Concurrency and Locks

Shared mutable state needs synchronization. Race conditions, mutual exclusion, spinlocks, mutexes, atomic instructions, and cache-coherence costs.

Condition Variables And Semaphores

Waiting for a condition without busy-loops. Condition variables release the mutex while sleeping; semaphores generalize to counted resources.

CPU Scheduling

Many runnable threads, few cores. FIFO, SJF, round-robin, MLFQ, and Linux CFS define the path from simple policies to fair-share kernels.

Filesystems

How bytes on disk become named files: inodes, directories, allocation, page cache, journaling, and the durability contract behind fsync().

Interrupts And Context Switches

How control moves from user code into the kernel and back, including trap frames, interrupt deferral, preemption, and context switch costs.

Processes And Threads

A process is an isolated address space with one or more threads. Threads share memory and file descriptors but carry separate stacks, registers, and scheduler state.

System Calls

The user/kernel boundary. How syscalls switch privilege, pass arguments in registers, and route file, process, memory, and synchronization operations through the kernel.

Virtualization And Containers

Two ways to multiplex an OS-shaped abstraction. Hypervisors virtualize hardware; containers isolate processes with Linux namespaces, cgroups, and layered filesystems.

DNS and Name Resolution

How a hostname becomes an IP. Recursive resolvers, authoritative servers, the root zone, A/AAAA/CNAME/MX records, and the caches at every hop.

HTTP and TLS

How the web works on top of TCP: request bytes, status classes, caching, persistent connections, HTTP/2, HTTP/3, TLS 1.3, and certificate chains.

OSI Model and Protocol Layering

Seven layers as a teaching reference; four-or-five as deployed. Layering separates change, but MTU, NAT, TLS, and QUIC show where boundaries leak.

Sockets Programming Essentials

The BSD sockets API in five system calls: create, name, listen, accept, connect. Covers blocking I/O, short reads, and readiness APIs from select to io_uring.

TCP Three-Way Handshake And Connection State

How TCP establishes a connection in three packets, why SYN cookies exist, and the state machine that governs every byte until FIN_WAIT_2.

TCP/IP Overview

What the internet protocol stack does: IP routes best-effort packets, TCP gives ordered reliable bytes, UDP sends datagrams, and ports demultiplex services.

C++ Basic Types and Memory

What int, double, char, and a struct actually look like in memory: fundamental sizes, alignment, padding, layout categories, and why std::is_trivially_copyable matters.

Move Semantics And Rvalue References

C++11 rvalue references separate ownership transfer from copying. Move constructors let vectors, strings, and user types pass large storage by pointer swaps.

Pointers, References, and Ownership

C++ has three ways to refer to an object: raw pointer, reference, and smart pointer. Ownership is the missing concept in C; unique_ptr and shared_ptr put it back.

Templates and Compile-Time Programming

C++ templates instantiate type-specific code at compile time. This page covers deduction, specialization, SFINAE, concepts, variadic packs, and constexpr evaluation.

Undefined Behavior Essentials

Why use-after-free, signed overflow, and uninitialized reads let C++ compilers assume impossible cases away, plus the sanitizer builds that catch them.

CUDA Mental Model

Threads, warps, blocks, and grids form the CUDA execution model; memory placement and scheduling determine most kernel performance.

Distributed Training Basics

When one GPU is too small or too slow, distributed training splits batches, tensors, layers, parameters, gradients, and optimizer state across accelerators.

From CPU To GPU

Why neural-net workloads outgrew CPUs: latency cores, SIMT execution, host-device transfer costs, and the memory bandwidth gap that moved training and inference to GPUs.

Inference Servers

How production LLM servers turn a decoder model into low-latency streams using continuous batching, paged attention, scheduling, speculation, and quantization.

KV Cache and Attention at Inference Time

Why token-by-token generation stores past keys and values, how KV cache memory is computed, and why MQA, GQA, paging, quantization, and offload matter.

Memory Bandwidth and the Roofline Model

Arithmetic intensity predicts whether a kernel is capped by FLOPs or bytes. The roofline bound explains SAXPY, GEMM, attention, and why fusion matters.

Quantization And Model Compression

How LLM weights, activations, and caches shrink through INT8, INT4, FP8, sparsity, and distillation, with the accuracy and throughput costs made explicit.

Tensor Cores and Mixed Precision

Why a high-end datacenter GPU does so much more matrix-multiply per second than its FP32 cores predict. Tensor cores compute matrix tiles at FP16, BF16, and FP8 with FP32 accumulation; mixed-precision training keeps activations low-precision and master weights in FP32.

Computability Theory

What can be computed? Turing machines, decidability, the Church-Turing thesis, recursive and recursively enumerable sets, reductions, Rice's theorem, and connections to learning theory.

Godel's Incompleteness Theorems

Godel's first incompleteness theorem: any consistent formal system containing basic arithmetic has true but unprovable statements. The second: such a system cannot prove its own consistency. These are hard limits on what formal reasoning can achieve.

P vs NP

A central open problem in computer science: is every problem whose solution can be verified in polynomial time also solvable in polynomial time? Covers P, NP, NP-completeness, reductions, Cook-Levin theorem, and relevance for ML.

SAT, SMT, and Automated Reasoning

SAT solvers decide Boolean satisfiability (NP-complete). SMT solvers extend SAT with theories like arithmetic and arrays. These tools verify constraints, discharge proof obligations, and complement LLMs in AI agent pipelines.

Formal Languages and Automata

Regular languages, context-free grammars, pushdown automata, the Chomsky hierarchy, pumping lemmas, and connections to parsing, neural sequence models, and computational complexity.

Dependent Type Theory

Types that depend on values. Pi types generalize function types; Sigma types generalize pairs. The Curry-Howard correspondence extends to full logic: propositions are types, proofs are programs. This is the foundation of proof assistants like Lean and Coq.

Formal Verification and Proof Assistants

Some behaviors should be proven, not merely hoped for. Model checking, theorem proving, Lean/Coq, verified compilers, and why verification matters for infrastructure, protocols, and safety-critical AI.

Lambda Calculus

Lambda calculus is the simplest model of computation: just variables, abstraction, and application. It is equivalent to Turing machines in power, and it is the foundation of functional programming, type theory, and the Curry-Howard correspondence.