The Complete Curriculum
We don't speed-run. Every concept comes with context — why it was invented, what problem it solves, and how it connects to what comes next.
Phase 0: Mathematical Foundations
4-7 weeks
Individual
No AI tools for coding
0.1Number Systems & Arithmetic
Minute Concepts: Powers of 2, memory scaling (KB/MB/GB), Operator precedence, Modular arithmetic, Remainders, Negative numbers (Two's complement), Floating-point bounds.
Pedagogical Exercise Type & Mechanics
Reverse Engineering: "Number Detective." Given a pattern of arbitrary memory allocations, students derive the scaling rule. Break It: "Floating Point Forensics." Students force floating-point rounding errors and document the hardware limitations causing them.
0.2Foundational Algebra
Minute Concepts: Variables as state, Domain and Range, Sequences and Series (Iteration), Input-to-Output mapping.
Pedagogical Exercise Type & Mechanics
Constraint-Based Design: "Function Machine." Students map inputs to outputs via tabular data and challenge peers to derive the underlying state transition rule.
0.3Logic & Boolean Algebra
Minute Concepts: Truth tables, AND/OR/NOT/XOR operations, De Morgan's Laws, Proof by Induction, Loop invariants.
Pedagogical Exercise Type & Mechanics
Logic Puzzles: "Lie Detector." Given a set of statements where exactly one is false, students apply Boolean operators to isolate the anomaly. Design Challenge: Design a voting system utilizing Boolean logic gates to handle vetoes and majorities.
0.4Set Theory & Combinatorics
Minute Concepts: Intersections, Unions, Differences, Counting principles, Combinations vs. Permutations.
Pedagogical Exercise Type & Mechanics
Code Archaeology: "Venn Diagram SQL Preview." Utilizing visual set theory to predict the outcome of future SQL JOIN, UNION, and EXCEPT operations.
0.5Graph Theory Intuition
Minute Concepts: Nodes, Edges, Directed vs. Undirected graphs, Degree centrality, Bridge nodes, Shortest paths.
Pedagogical Exercise Type & Mechanics
Physical Modeling: "Map Your World." Students chart physical intersections as graphs to manually execute a precursor to Dijkstra's algorithm, tracking edge weights by hand.
Phase 1: Computational Thinking (Unplugged)
2-3 weeks
Individual
No AI tools for coding
1.1Algorithmic Precision
Minute Concepts: Literal execution, Ambiguity resolution, Instruction sequencing, Implicit assumptions.
Pedagogical Exercise Type & Mechanics
Peer Teaching/Roleplay: "PB&J Algorithm." One student writes instructions; another executes them with adversarial literalism, forcing the writer to recognize implicit assumptions in their logic.
1.2Divide & Conquer
Minute Concepts: Search spaces, Logarithmic reduction, Base cases, Recursive intuition.
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Binary Search Game." Students attempt to guess a bounded integer in minimum steps, naturally discovering O(log n) constraints before formal Big-O notation is introduced.
1.3Decomposition
Minute Concepts: Breaking monolithic tasks into sub-routines, Stopping conditions for decomposition, Atomic operations.
Pedagogical Exercise Type & Mechanics
Constraint-Based Design: "Decompose a System." Students take a monolithic real-world task (e.g., planning a wedding) and recursively break it down until tasks are atomic, analogous to microservices.
1.4Abstraction
Minute Concepts: Filtering irrelevant data, State representation, Interface vs. Implementation.
Pedagogical Exercise Type & Mechanics
Design Challenge: "Subway Map Design." Students translate a geographically accurate map into a topological transit map, identifying which data points are necessary for navigation and which are noise.
1.5Computability Intuition
Minute Concepts: The Halting Problem, Theoretical limits of computation, Infinite loops, Decidability.
Pedagogical Exercise Type & Mechanics
Technical Discussion: "The Halting Problem Story." Discussing problems that fundamentally have no algorithmic solution, establishing that software engineering operates within hard theoretical boundaries.
Phase 2: CS History, Computer Architecture & How Computers Work
4-7 weeks
Individual
No AI tools for coding
2.1Digital Logic & Gates
Minute Concepts: NAND universality, Combinational logic, Multiplexors, Decoders, Half/Full Adders, Arithmetic Logic Units (ALU).
Pedagogical Exercise Type & Mechanics
Build From Scratch: "NAND World." Utilizing a hardware simulator, students construct basic logic gates, multiplexors, and an ALU utilizing only primary NAND gates.
2.2Sequential Logic & Memory
Minute Concepts: Clock cycles, Flip-flops, Registers, Random Access Memory (RAM), Program Counters, State over time.
Pedagogical Exercise Type & Mechanics
Constraint-Based Design: "Memory Construction." Students implement 16-bit registers and RAM units, grasping that memory is simply a time-delayed combinational circuit governed by a clock.
2.3Instruction Set Architecture (ISA)
Minute Concepts: Machine language, Op-codes, Operands, RISC-V instruction formats, Assembly language translation.
Pedagogical Exercise Type & Mechanics
Code Archaeology / Translation: Students write basic programs (e.g., drawing shapes) in a minimalist assembly language, translating logical operations into binary instruction formats.: "
2.4CPU Architecture
Minute Concepts: Fetch-Decode-Execute cycle, Control units, Datapaths, Single-cycle vs. Pipelined execution, Data hazards.
Pedagogical Exercise Type & Mechanics
Physical Roleplay / Simulation: "Human Pipeline." Students physically act out CPU pipeline stages, manually introducing stalls and flushes to understand data hazards before viewing them in a simulator.
2.5Memory Hierarchy & Caches
Minute Concepts: Spatial and temporal locality, Cache mapping (Direct, Set-Associative, Fully Associative), Cache misses, Virtual memory, Translation Lookaside Buffers (TLB).
Pedagogical Exercise Type & Mechanics
Performance Tuning: "Cache-Friendly vs. Cache-Hostile." Students analyze algorithms to predict cache hit rates. Insight: Connects the physical layout of arrays to algorithmic performance.
Phase 3: Programming & Logic Foundations (Pseudocode)
4-7 weeks
Individual
No AI tools for coding
3.1Environment & CLI
Minute Concepts: Shell navigation, File system hierarchy, Standard input/output, Basic bash scripting, Absolute vs. Relative paths.
Pedagogical Exercise Type & Mechanics
Code Archaeology: "Terminal Scavenger Hunt." Students navigate deeply nested directory trees utilizing only standard Unix commands (cd, ls, grep) to find hidden flags and organize files.
3.2State & Variables
Minute Concepts: Variable declaration, Reassignment, State mutation, Scope intuition, Primitive data types.
Pedagogical Exercise Type & Mechanics
Tracing: "State Snapshots." Given a block of pseudocode, students must manually track and document the value of every variable at each discrete line of execution.
3.3Control Flow
Minute Concepts: Conditionals (If/Else), Boolean evaluations, Iteration (For/While loops), Infinite loops, Loop termination conditions.
Pedagogical Exercise Type & Mechanics
Parsons Problems: Students are provided with scrambled pseudocode blocks, including deceptive distractor lines. They must arrange the blocks to correctly implement basic flow control.: "
3.4Functions & Modularity
Minute Concepts: Parameters, Arguments, Return values, Call stacks, Side effects vs. Pure functions, Code reuse.
Pedagogical Exercise Type & Mechanics
Debugging Challenges: "Find the Bug." Students are given pseudocode with subtle logic errors (e.g., off-by-one errors) and must identify the flaw, explaining the exact state corruption it causes.
3.5System Design (Pseudocode)
Minute Concepts: Requirement gathering, Edge case identification, State machine design, Structuring complex logic.
Pedagogical Exercise Type & Mechanics
Design Challenge: "Design an ATM." Students architect an ATM system in pseudocode, handling daily limits, insufficient funds, and network failures, followed by peer adversarial testing.
Phase 4: Programming Paradigms & Language History
3-4 weeks
Individual
No AI tools for coding
4.1Paradigm Evolution
Minute Concepts: Unstructured programming (GOTO), Procedural, Object-Oriented Programming (OOP), Functional programming.
Pedagogical Exercise Type & Mechanics
Refactoring: "GOTO Spaghetti." Students receive a functional but unstructured program relying heavily on GOTO statements. They rewrite it using structured procedural logic to observe maintainability.
4.2Lexical Analysis (Scanning)
Minute Concepts: Tokens, Lexemes, Regular expressions, Whitespace handling, Keyword identification.
Pedagogical Exercise Type & Mechanics
Reverse Engineering: "Tokenize By Hand." Students manually parse a complex mathematical or logical statement into discrete token categories (identifiers, keywords, literals, operators).
4.3Syntax Analysis (Parsing)
Minute Concepts: Context-free grammars, Top-down vs. Bottom-up parsing, Abstract Syntax Trees (AST), Operator precedence.
Pedagogical Exercise Type & Mechanics
Visual Modeling: "Draw the AST." Students diagram the abstract syntax tree for nested mathematical operations, visually understanding operator precedence and tree traversal algorithms.
4.4Semantic Analysis
Minute Concepts: Scope resolution, Type checking, Symbol tables, Static vs. Dynamic typing.
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Error Taxonomy." Students generate specific code snippets designed to fail at precise stages of the compilation pipeline (e.g., a lexical error vs. a semantic type-mismatch error).
4.5Code Generation & Optimization
Minute Concepts: Intermediate Representations (IR), Three-Address Code (TAC), Register allocation, Garbage collection mechanisms.
Pedagogical Exercise Type & Mechanics
Code Archaeology: Students map the lifecycle of a variable from high-level declaration down to its theoretical representation in Three-Address Code and register allocation.: "
Phase 5: Python
8-14 weeks
Rotating Pairs
Introduce AI critically (Mid-Phase)
5.1Version Control (Git)
Minute Concepts: Directed Acyclic Graphs (DAG), Commits, Parent pointers, Branching, Merging, .gitignore.
Pedagogical Exercise Type & Mechanics
Mental Modeling: Git is taught mathematically as a DAG. Students draw the graph state before and after every git commit and git merge operation, mapping the repository history.: "
5.2Core Python Types & Coercion
Minute Concepts: Integers, Floats, Strings, Booleans, f-strings, Type casting, Dynamic typing mechanics.
Pedagogical Exercise Type & Mechanics
Break It: "Type Coercion Traps." Students identify edge cases where implicit type coercion yields unexpected results, writing defensive assertions to catch them.
5.3Collections & Iterables
Minute Concepts: Lists, Tuples, Dictionaries, Sets, Slicing, List comprehensions, Memory overhead.
Pedagogical Exercise Type & Mechanics
Constraint-Based Design: Students manipulate large datasets (e.g., parsing log files) using only iterators and comprehensions, analyzing the memory footprint compared to standard loops.: "
5.4Functions & Functional Tools
Minute Concepts: *args, **kwargs, Lambdas, Decorators, Closures, Variable scope (LEGB rule).
Pedagogical Exercise Type & Mechanics
Code Archaeology: "Function Graphing." Given a legacy script, students map the call graph and isolate pure functions from those producing side-effects to identify dead code.
5.5Object-Oriented Python
Minute Concepts: Classes, Instance vs. Class attributes, Inheritance, Polymorphism, Dunder methods (__init__, __str__).
Pedagogical Exercise Type & Mechanics
System Design: "Model a Real System." Students model a library management system using an inheritance hierarchy, defending their abstraction choices in peer reviews.
5.6Error Handling & I/O
Minute Concepts: Context managers (with statements), try/except/finally, Custom exceptions, File parsing (CSV/JSON).
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Crash Test." One student writes a script handling network data; their peer writes a malicious input generator designed to bypass the try/except blocks.
5.7AI Critical Evaluation
Minute Concepts: LLM Hallucinations, Prompt engineering, Code verification, Boundary condition analysis.
Pedagogical Exercise Type & Mechanics
Peer Review: "The 40% Report." Students prompt an AI to generate a complex Python module. They then review the code, finding the semantic errors and edge cases the AI missed.
Phase 6: The C Programming Language
6-8 weeks
Pair Debugging
No AI for C (Feel the segfaults)
6.1C Fundamentals vs. Python
Minute Concepts: Static typing, Stack allocation, Format strings, Pass-by-value semantics, Integer overflow.
Pedagogical Exercise Type & Mechanics
Translation: "Rosetta Stone." Students translate their Python projects into C, documenting exactly what Python's interpreter was previously doing on their behalf (e.g., garbage collection).
6.2Memory Mechanics & Pointers
Minute Concepts: Memory addresses, Dereferencing, Pointer arithmetic, Pass-by-reference simulation.
Pedagogical Exercise Type & Mechanics
Visual Modeling: "Pointer Diagrams." Before compiling, students must draw box-and-arrow diagrams mapping the physical memory layout of their pointers to predict output.
6.3Dynamic Memory Allocation
Minute Concepts: The Heap, malloc(), calloc(), realloc(), free(), Memory leaks, Dangling pointers.
Pedagogical Exercise Type & Mechanics
Debugging Challenges: "Memory Leak Detective." Students use valgrind to audit intentionally flawed code, tracing memory leaks back to omitted free() calls across complex branching logic.
6.4Complex Data Structures in C
Minute Concepts: Structs, Arrays of pointers, Double pointers (pointers to pointers), Function pointers, Event callbacks.
Pedagogical Exercise Type & Mechanics
Build From Scratch: "Dynamic Array." Students build a dynamically resizing array (similar to Python's list) using double pointers and realloc(), managing memory boundaries manually.
6.5Build Systems & Debugging
Minute Concepts: Compilation pipeline (Preprocessor, Compiler, Assembler, Linker), Makefiles, Header files, GDB.
Pedagogical Exercise Type & Mechanics
Reverse Engineering: "Compile Step-by-Step." Students pause the compilation at each stage (e.g., gcc -E, gcc -S) to inspect the intermediate assembly and object files, connecting back to Phase 4.
6.6Memory Security Vulnerabilities
Minute Concepts: Buffer overflows, Segmentation faults, Out-of-bounds reads, Stack smashing.
Pedagogical Exercise Type & Mechanics
Break It: "Buffer Overflow Demo." Students intentionally write past the bounds of a local array to overwrite the return address on the call stack, effectively hijacking execution flow.
Phase 7: Data Structures & Algorithms (DSA) + Design & Analysis
14-22 weeks
Pair Problem-Solving
AI as a study partner (No answers)
7.1Complexity Analysis
Minute Concepts: Big-O, Big-Omega, Big-Theta notation, Time vs. Space complexity trade-offs, Amortized analysis.
Pedagogical Exercise Type & Mechanics
Code Archaeology: "Algorithm Races." Students write equivalent algorithms (e.g., linear vs. binary search). They plot execution time against input size to empirically prove theoretical Big-O bounds.
7.2Linear Data Structures
Minute Concepts: Arrays, Singly/Doubly Linked Lists, Stacks, Queues, Hash Tables (Collision resolution, Load factors).
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Break the Hash." Students build a Hash Table in C. Peers write malicious test cases designed to force catastrophic hash collisions, degrading the structure to O(n).
7.3Non-Linear Data Structures
Minute Concepts: Trees, Binary Search Trees (BST), AVL/Red-Black Trees, Heaps (Priority Queues), Tries, Graphs (Adjacency list/matrix).
Pedagogical Exercise Type & Mechanics
Visual Modeling: "Visualize the Algorithm." Students implement graph traversal (BFS/DFS) with terminal visualization, watching how the frontier expands differently based on the underlying queue/stack.
7.4Sorting & Searching Algorithms
Minute Concepts: Bubble, Selection, Insertion, Merge, Quick, and Radix Sort. Binary search logic.
Pedagogical Exercise Type & Mechanics
Constraint-Based Design: Students must sort a massive dataset but are artificially constrained to 10MB of RAM, forcing the implementation of external merge sort techniques.: "
7.5Algorithmic Paradigms
Minute Concepts: Brute Force, Divide and Conquer, Greedy Algorithms, Dynamic Programming (Memoization, Tabulation), Backtracking.
Pedagogical Exercise Type & Mechanics
Refactoring: "Optimize to DP." Students write a naive recursive Fibonacci or Knapsack solution, observe the exponential time failure, and refactor using dynamic programming tabulation.
7.6Advanced Graph Algorithms
Minute Concepts: Dijkstra's Shortest Path, Bellman-Ford, Kruskal/Prim (Minimum Spanning Trees), Topological Sorting.
Pedagogical Exercise Type & Mechanics
System Design: "Pathfinding Visualizer." Students build a route-planning application, defending why A* search is superior to Dijkstra for specific spatial navigation tasks.
Phase 8: Databases
6-9 weeks
Small Groups
AI for boilerplate only
8.1Relational Model & SQL
Minute Concepts: Relational algebra, CRUD operations, Joins (Inner, Outer, Cross), Aggregations, Subqueries, Normalization.
Pedagogical Exercise Type & Mechanics
Data Cleaning: "Dirty Data Audit." Students are given a massive, inconsistent dataset. They must write complex analytical queries to deduplicate, normalize, and extract a single source of truth.
8.2Database Storage Architecture
Minute Concepts: Disk-oriented architecture, Buffer Pool Management, Slotted pages, Row vs. Column stores (OLTP vs. OLAP).
Pedagogical Exercise Type & Mechanics
Build From Scratch: "Buffer Pool Manager." Students implement a buffer pool in C, managing memory frames, page tables, and LRU (Least Recently Used) cache eviction policies.
8.3Indexing & Filter Structures
Minute Concepts: B-Trees, B+ Trees, Hash Indexes, Vector Indexes, Index Concurrency.
Pedagogical Exercise Type & Mechanics
Performance Tuning: "Slow Query Challenge." Students are given queries causing full table scans. Using EXPLAIN, they must identify the bottleneck, implement a B+ Tree index, and document the latency reduction.
8.4Query Execution & Optimization
Minute Concepts: Processing models (Iterator, Vectorized), Sorting algorithms, Hash Joins, Query planners, Cost-based optimization.
Pedagogical Exercise Type & Mechanics
Code Archaeology: Students trace how a declarative SQL query is translated by the query planner into a physical execution tree using relational algebra primitives.: "
8.5Transaction Processing (ACID)
Minute Concepts: Atomicity, Consistency, Isolation, Durability, Concurrency anomalies (Dirty reads, Phantom reads).
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Concurrency Crash." Students simulate high-throughput transactions. They must isolate anomalous behavior and explain which isolation level prevents it.
8.6Concurrency Control
Minute Concepts: Two-Phase Locking (2PL), Timestamp Ordering, Multi-Version Concurrency Control (MVCC), Deadlock detection.
Pedagogical Exercise Type & Mechanics
Roleplay / Simulation: "Deadlock Dinner." Students model database transactions acquiring shared/exclusive locks, intentionally triggering deadlocks, and implementing wait-die or wound-wait schemes.
8.7Database Recovery
Minute Concepts: Write-Ahead Logging (WAL), Checkpointing, ARIES recovery algorithm.
Pedagogical Exercise Type & Mechanics
Break It: Students forcefully terminate a database process mid-transaction and manually parse the Write-Ahead Log to determine which transactions must be redone or undone.: "
Phase 9: Networking, Operating Systems & Backend Development
10-16 weeks
Fixed Teams
AI as junior developer
9.1Computer Networking Core
Minute Concepts: OSI Model, TCP/IP Suite, UDP vs. TCP, DNS resolution, NAT, Sockets, Packet switching.
Pedagogical Exercise Type & Mechanics
Protocol Analysis: "Trace a Packet." Using Wireshark and tcpdump, students capture a full TLS handshake and HTTP request, identifying packet headers, sequence numbers, and payload data.
9.2Reliable Transport (TCP)
Minute Concepts: Stream reassembly, Sliding windows, Flow control, Congestion control algorithms, Elastic buffers.
Pedagogical Exercise Type & Mechanics
Build From Scratch: "TCP Receiver/Sender." Students implement a robust stream assembler that handles out-of-order packets, overlapping bytes, and zero-window size advertisements.
9.3The Process Model (OS)
Minute Concepts: Process Control Blocks (PCB), fork(), exec(), wait(), Context switching, Zombie processes.
Pedagogical Exercise Type & Mechanics
System Design: "The Custom Shell." Students build a functioning Unix shell in C, managing process creation, foreground/background execution, and standard I/O redirection (pipes).
9.4Memory Management (OS)
Minute Concepts: Virtual memory mapping, Paging, Segmentation, TLBs, Page faults, Heap allocations.
Pedagogical Exercise Type & Mechanics
Reverse Engineering: "Memory Map Investigation." Students explore /proc/[pid]/maps in Linux, dynamically observing how the OS loads shared libraries and allocates heap space during execution.
9.5Concurrency & Synchronization
Minute Concepts: Threads vs. Processes, Mutexes, Semaphores, Race conditions, Condition variables, Preemptibility.
Pedagogical Exercise Type & Mechanics
Debugging Challenges: "Race Condition Lab." Students are given heavily multi-threaded code with missing locks. They must identify the non-deterministic output and fix it without introducing deadlocks.
9.6Backend Architecture & APIs
Minute Concepts: RESTful principles, Statelessness, Authentication (JWT, OAuth), Connection pooling, Rate Limiting.
Pedagogical Exercise Type & Mechanics
System Design: "Idempotent Payment Gateway." Students build an API where network failures cause client retries. They must design distributed locks and idempotency keys to ensure users are not charged twice.
Phase 10: Software Engineering Practices
7-11 weeks
Fixed Teams
AI in professional workflow
10.1Advanced Git Workflows
Minute Concepts: Branching strategies (GitFlow, Trunk-based), Rebasing, git bisect, Merge conflict resolution.
Pedagogical Exercise Type & Mechanics
Code Archaeology: "Find the Regression." Students use git bisect on a massive historical repository to isolate the exact commit that introduced a subtle bug, analyzing the commit diff.
10.2Testing Strategy
Minute Concepts: Unit testing, Integration testing, End-to-End (E2E), Test-Driven Development (TDD), Mocking/Stubbing.
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "Legacy Code Rescue." Students receive an undocumented, untested codebase. They must write characterization tests to lock in the current behavior before safely refactoring.
10.3Design Patterns & SOLID
Minute Concepts: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion.
Pedagogical Exercise Type & Mechanics
Refactoring: "Refactor This Mess." Students are given a monolithic "god class." They must dismantle it utilizing SOLID principles, justifying their abstractions in a formal Architecture Decision Record (ADR).
10.4Code Review & Quality
Minute Concepts: Linting, Static analysis, Cyclomatic complexity, Constructive peer feedback, Documentation standards.
Pedagogical Exercise Type & Mechanics
Peer Review: "PR Roulette." Students submit pull requests and randomly review peers. The grade is based entirely on the depth, empathy, and technical rigor of the review comments, not just the code.
10.5Agile Development Process
Minute Concepts: Sprints, Backlog grooming, Estimation, Standups, Retrospectives, Technical debt management.
Pedagogical Exercise Type & Mechanics
Simulation: "Sprint Execution." Teams operate in a strict two-week sprint rhythm, handling dynamically changing requirements and prioritizing technical debt alongside feature delivery.
Phase 11: Distributed Systems, System Design & AI Literacy
10-16 weeks
Team Capstone
AI Orchestration
11.1Time & Ordering
Minute Concepts: Physical clocks, Clock drift, Logical clocks (Lamport, Vector), Network Time Protocol (NTP).
Pedagogical Exercise Type & Mechanics
Simulation: "Clock Drift Lab." Students simulate distributed processes stamping events. They observe causality violations with physical clocks and resolve them by implementing Lamport timestamps.
11.2Replication & Consistency
Minute Concepts: Primary-Backup, Chain Replication (CRAQ), Quorum consensus, Eventual vs. Strong consistency, Linearizability.
Pedagogical Exercise Type & Mechanics
Build From Scratch: "Distributed KV Store." Students build a sharded Key/Value store. They inject network partitions (split-brain) and observe how the system sacrifices availability for consistency.
11.3Consensus Algorithms
Minute Concepts: Two-Phase Commit (2PC), Paxos, Raft leader election, Log replication.
Pedagogical Exercise Type & Mechanics
Roleplay / System Design: "Consensus Role Play." Students act as Raft nodes. The leader fails, triggering a simulated election. They then translate this state machine into a fault-tolerant C++ implementation.
11.4Distributed Storage & Computing
Minute Concepts: Google File System (GFS), MapReduce, Spark, Consistent Hashing, Sharding algorithms.
Pedagogical Exercise Type & Mechanics
Code Archaeology: Students read the seminal Spanner and MapReduce papers, mapping the theoretical architecture to modern cloud infrastructure (AWS/GCP) to understand data locality.: "
11.5System Design Patterns
Minute Concepts: API Gateways, Load Balancers, Rate Limiting (Token Bucket), Message Queues (Kafka/RabbitMQ), Caching (Redis/Memcached).
Pedagogical Exercise Type & Mechanics
Design Challenge: "Architect a Chat App." Students design a high-throughput system utilizing WebSockets and message brokers, explicitly documenting their strategies for ordering guarantees and partition tolerance.
11.6AI Literacy & Orchestration
Minute Concepts: LLM architectures, Generative limitations, Evaluating AI system design logic, Prompt injection.
Pedagogical Exercise Type & Mechanics
Adversarial Testing: "AI Hallucination Catalog." Students prompt AI for distributed system architectures. They must identify subtle flaws, such as an AI recommending synchronous replication for a globally distributed, high-availability database.