Lessons

How do you scale a database beyond one machine while keeping it reliable? This lesson covers every major replication topology, the quorum math behind leaderless systems, and partitioning strategies from range keys to consistent hashing — including how to avoid hot partitions and handle rebalancing.

Distributed systems break in ways single machines don't: nodes crash silently, messages vanish, and clocks lie. Learn the standard failure taxonomy, why a global clock is physically impossible, and how Lamport and vector clocks let you reason about causality without one.

Consensus is the hardest fundamental problem in distributed systems — and the one everything else depends on. Understand why FLP makes it theoretically impossible in async systems, how quorums work, and exactly how Raft solves leader election, log replication, and commitment safely.

CAP is the most misquoted theorem in distributed systems. Get the precise statement, learn why PACELC is more useful in practice, and master the consistency spectrum from linearizability down to eventual consistency — with concrete trade-offs for each level.

Go from a raw neural network to one that actually generalizes. Covers loss functions (MSE, cross-entropy), gradient descent variants (SGD, momentum, Adam), learning-rate effects, overfitting vs underfitting, and the regularization toolkit (L2/dropout/early stopping/batch norm).

Build intuition for how artificial neurons stack into layers, why nonlinear activations are non-negotiable, and how the chain rule turns a forward pass into exact gradients — illustrated with a tiny numpy forward+backward walk-through.

Understand why fully-connected layers fail at image scale, then build up the CNN toolkit: convolutions, kernels, stride, padding, feature maps, pooling, and parameter sharing. Finish with the ResNet residual connection idea that unlocked networks of 100+ layers.

From the limits of RNNs to the self-attention mechanism that replaced them. Learn how queries, keys, and values implement scaled dot-product attention, why multi-head attention captures richer structure, how positional encodings inject order, and how all of this assembles into a transformer block.

Transactions are a promise. Learn the ACID guarantees, the exact anomalies each SQL isolation level prevents or allows, why two-phase locking blocks and MVCC does not, and how Postgres uses row versions plus a transaction ID visibility check to give you snapshot isolation without holding a single read lock.

Disk geometry dictates database design. Learn why sequential I/O beats random I/O by 100x, how fixed-size pages and slotted page headers work, why row-stores and column-stores suit different workloads, how the buffer pool keeps hot pages in RAM, and how the write-ahead log makes durability cheap.

B-trees rule read-heavy OLTP; LSM-trees rule write-heavy workloads. Learn how the memtable and immutable SSTable pipeline converts random writes into sequential I/O, why compaction is unavoidable, how bloom filters slash unnecessary reads, and when to pick LSM over B-tree.

B+ trees are the workhorse of relational databases. Learn why their high fanout and shallow depth match disk perfectly, how point lookups and range scans work, the difference between clustered and secondary indexes, how covering indexes eliminate table lookups, and the hidden write cost of keeping indexes up to date.

The model is rarely the bottleneck. This lesson examines why data readiness — quality, governance, lineage, and access — is the primary constraint on enterprise AI value, with a practical scorecard, and a clear-eyed comparison of RAG versus fine-tuning economics.

Learn how to generate smooth robot trajectories — trapezoidal velocity profiles, cubic and quintic polynomials — and how to combine feedforward and feedback to track them with minimal error on real arms and mobile robots.

Move beyond single-input PID to the state-space framework: the state vector, matrix dynamics, controllability, pole placement via state feedback, and LQR — the tool that scales to full robot arms and drones.

Master the proportional-integral-derivative controller: what each term fixes, the PID equation, integral windup, a discrete Python implementation, and a Ziegler-Nichols tuning guide for real loops.

Understand why feedback beats open-loop, how the classic closed-loop architecture works, and what the key performance metrics — rise time, overshoot, settling time, steady-state error — actually mean for a real system.

AES and block ciphers are primitive building blocks, not complete encryption schemes. Learn how ECB leaks structure, why CBC and CTR modes work differently, and why GCM is the modern default — including the catastrophic consequences of nonce reuse.

Trapdoor functions power every TLS handshake, code signature, and SSH session. Master RSA key generation and its math, why textbook RSA is trivially broken, what elliptic curves add, and how ECDSA and Ed25519 compare — with key-size equivalences you can quote in code reviews.

Every HTTPS connection negotiates a fresh secret over an untrusted network. Learn Diffie-Hellman and ECDH from first principles, why forward secrecy matters when private keys leak, how TLS 1.3 cut the handshake to one round-trip, and how certificate chains stop man-in-the-middle attacks.

Hash functions are not all equal and MACs are not just hashes with a secret. Learn the three resistance properties, why length-extension attacks break naive HMAC constructions, how KDFs differ from hashes, and why bcrypt/scrypt/Argon2 exist for passwords.

Threads look deceptively simple — create a few, share some memory, done. In practice, shared mutable state is a minefield: race conditions, non-deterministic output, and bugs that vanish under a debugger. This lesson dissects concurrency vs parallelism, why `count++` is three operations the CPU can interleave, Amdahl's law, and what a critical section actually means.

The CPU and compiler silently reorder your code. Cache coherence does not mean coherent behavior. This lesson explains the happens-before relation, memory fences, C++ and Java atomic operations, compare-and-swap, and why `volatile` is not a synchronization primitive.

Mutexes, condition variables, semaphores, and reader-writer locks — the primitives that make concurrent code correct. Understand the four Coffman deadlock conditions, how lock ordering prevents them, and why contention turns a performance win into a bottleneck.