FREE COMPUTER SCIENCE ROADMAP · 20 SECTIONS · 170 LESSONS

Computer Science Roadmap

Follow the complete Bits Stack Trace from mathematics and silicon through software, data systems, distributed systems, AI, and agents.

• Mathematics & logic
  • The map is not the territory: Representation is the first engineering decision
  • Claims, counterexamples, and invariants: How software earns a guarantee
  • Four lenses for discrete problems: Sets, graphs, matrices, and probability
  • Foundation mastery: specify before you build: Prove the model survives a changed assumption
  • Propositions, quantifiers, and precise specifications: Translate requirements into statements that can be proved or refuted.
  • Induction and recursive structure: Prove infinite families of claims using explicit base cases and preservation steps.
  • Sets, relations, functions, and equivalence: Model collections and mappings without confusing identity, membership, and cardinality.
  • Counting choices without double counting: Use bijections, inclusion-exclusion, and the pigeonhole principle to reason about finite systems.
  • Graphs, connectivity, and constructive proofs: Connect graph definitions to traversal certificates and structural arguments.
  • Vectors, matrices, and linear transformations: Understand coordinates, composition, rank, and what a matrix actually does.
  • Derivatives, gradients, and the chain rule: Measure local change and propagate it through a computation.
  • Integrals, accumulation, and numerical approximation: Connect continuous change to finite sums and controlled error.
• Physics & signals
  • A bit is a physical agreement: Stable distinctions in a noisy world
  • Sampling a continuous world: What measurement keeps, and loses
  • Signals must arrive in time: Bandwidth, latency, energy, and synchronization
  • Signal mastery: protect meaning: Detect corruption and locate the broken boundary
  • When samples become indistinguishable: Derive an alias and design a sampling boundary.
  • Information has a probability model: Compute entropy, construct a code, and separate rate from reliability.
• Semiconductors & electronics
  • From material to controllable path: Why semiconductors make switching possible
  • The CMOS inverter: Complementary devices restore a bit
  • Timing, heat, and fabrication: Why billions of switches are a systems problem
  • Electronics mastery: find the real bottleneck: Reason across logic, timing, power, and yield
  • Charge, delay, and a switching budget: Use an RC approximation to calculate timing and dynamic power.
  • Manufacturing variation becomes a reliability problem: Separate defect yield, timing yield, and failures over time.
• Digital logic
  • From truth table to circuit: Composition turns switches into decisions
  • Addition is a chain of local facts: Build arithmetic and see the carry path
  • Memory begins with feedback: Registers, clocks, and state over time
  • Logic mastery: design a state machine: Make control explicit and test every transition
  • Minimize logic without changing its meaning: Derive, simplify, and verify a combinational circuit.
  • One bit pattern, several number systems: Track width, signedness, rounding, and overflow explicitly.
  • A clock edge has a timing neighborhood: Calculate setup and hold margins, then handle asynchronous inputs.
  • Synthesize a finite-state controller: Translate behavior into states, transitions, outputs, and register logic.
• Architecture & memory
  • The stored-program contract: Instructions and data share an organized machine
  • The memory hierarchy: Locality turns a speed gap into a workable illusion
  • Devices, interrupts, and DMA: The processor is not the whole computer
  • Architecture mastery: performance is a budget: Reason with bottlenecks, parallelism, and measurement
  • Where a cache line can live: Calculate placement, conflict misses, and coherence traffic.
  • Pipelines overlap work and expose dependencies: Derive stalls from when a result exists and when a consumer needs it.
  • Predict branches, then verify the guess: Trace a predictor and account for speculative recovery.
  • Parallel speedup has a serial denominator: Analyze vector lanes, independent work, and shared bottlenecks.
  • Measure performance as an experiment: Use elapsed time, controlled comparisons, and defensible summaries.
• Machine code & execution
  • State changes one instruction at a time: Registers, addresses, and control flow
  • Calls are negotiated protocols: Calling conventions and stack frames
  • From object file to running image: Symbols, relocation, linking, and loading
  • Execution mastery: overlap without lying: Pipelines, hazards, prediction, and precise state
  • A stack frame obeys an interface contract: Trace arguments, saved registers, local storage, and return addresses.
  • Bytes, addresses, and object layout: Decode endianness and alignment without confusing them with pointer validity.
  • Resolve a symbol, then relocate its use: Follow definitions, references, and address-dependent fields through linking.
  • Cross the privilege boundary deliberately: Trace traps, system calls, interrupt state, and resumption.
• Operating systems & runtimes
  • Processes, threads, and the scheduler: Many streams of work share finite processors
  • Virtual memory is controlled indirection: Isolation, translation, paging, and faults
  • System calls and durable names: Files, descriptors, buffering, and persistence
  • OS mastery: concurrency without corruption: Atomicity, waiting, deadlock, and isolation
  • Scheduling is an objective with a queue: Calculate response and turnaround while tracking process states.
  • Translate an address through pages and a TLB: Compute offsets, distinguish misses from faults, and account for translation cost.
  • Wait for a predicate, not a notification: Build a bounded-buffer protocol with a mutex and condition variable.
  • Find the cycle behind a deadlock: Model ownership and waiting before choosing a prevention policy.
  • Make a filesystem update survive interruption: Order data, metadata, and commit records under an explicit crash model.
  • Asynchronous I/O moves the waiting boundary: Trace submission, ownership, completion, and backpressure.
• Languages & compilers
  • Source becomes structure: Lexing, parsing, grammars, and syntax trees
  • Types make impossible states harder to express: Static constraints and runtime meaning
  • Many roads to execution: Compilers, interpreters, VMs, and JITs
  • Language mastery: who owns memory?: Lifetime, allocation, garbage collection, and boundaries
  • Parse the language you actually specified: Separate tokenization, precedence, associativity, and syntax errors.
  • A closure retains an environment: Trace lexical scope, bindings, mutation, and lifetime.
  • Type checking is a derivation over syntax: Apply explicit rules before claiming a program is safe.
  • Make dataflow visible in an intermediate representation: Build blocks, merge values, and compute liveness to a fixed point.
  • Collect unreachable objects by tracing the graph: Distinguish reachability, reference counts, movement, and resource cleanup.
  • An optimization needs a semantic proof: Check values, effects, exceptions, and the arithmetic model before rewriting.
• Algorithms & data structures
  • A data structure is a bet: Choose for operations, constraints, and evidence
  • Correctness and cost: Invariants, growth rates, and honest analysis
  • Explore without getting lost: Search, sort, and graph traversal patterns
  • Algorithm mastery: design from structure: Greedy choices, dynamic programming, and proof
  • Count work and solve recurrences: Separate a cost model from a stopwatch
  • Pay for resizing with amortized analysis: Prove a bound over every operation sequence
  • Sorting, stability, and a comparison lower bound: Connect an implementation invariant to a decision tree
  • Hashing under collisions and adversarial inputs: Make expected constant time a precise claim
  • Ordered trees and priority heaps: Different invariants buy different operations
  • Traverse graphs and order dependencies: Maintain discovery state and detect impossible schedules
  • Shortest paths and the limits of greedy finalization: Choose the algorithm from edge-weight assumptions
  • Minimum spanning trees and the cut property: Prove that a locally cheap connection is globally safe
  • Dynamic programming with reconstruction: Recover an optimal decision, not just its score
  • Greedy scheduling with an exchange proof: Know exactly which local choice is safe
• Applications & software architecture
  • Architecture is change made legible: Cohesion, coupling, and domain boundaries
  • An API is a promise over time: Contracts, identity, errors, and idempotency
  • Evidence across the lifecycle: Tests, telemetry, and debugging
  • Application mastery: design for failure and change: Security, migration, and evolutionary architecture
  • Module boundaries and domain invariants: Derive an interface from ownership of a rule, then test the boundary.
  • API contracts and compatible change: Treat schemas, errors, ordering, and retries as observable behavior.
  • Testing properties, boundaries, and state transitions: Choose tests that can distinguish a correct mechanism from a plausible bug.
  • Version control, review, and reproducible builds: Make a change reconstructable from source through an artifact.
  • Reliability objectives and error budgets: Turn a user promise into a measurable ratio and a release decision.
  • Architecture trade-offs under partial failure: Compare a modular process with distributed services using one concrete invariant.
  • Asynchronous interfaces and stale responses: Model a user interaction as states and make response ownership explicit.
• Databases & data systems
  • Records live in pages, not tables: Storage layout and indexes from first principles
  • A query is an algorithm choice: Plans, cardinality, joins, and execution
  • Transactions control interleavings: Isolation, locking, MVCC, and invariants
  • Database mastery: a commit is a promise: Logging, recovery, replication, and failure boundaries
  • Relational algebra meets SQL semantics: Predict duplicates, missing values, joins, and grouping before optimizing a query.
  • Dependencies, keys, and lossless normalization: Separate facts without losing the ability to reconstruct them.
  • B+ trees and log-structured merge trees: Follow reads and writes through two different indexing strategies.
  • Buffer pools and page replacement: Manage the boundary between database pages in memory and durable storage.
  • Join algorithms and cardinality estimates: Choose a physical plan by counting pages and predicting intermediate results.
  • Serializability, snapshots, and write skew: Distinguish a consistent-looking snapshot from a serial transaction history.
  • Recovery, write-ahead logs, and checkpoints: Explain which bytes must survive each crash boundary.
  • Replication, partitioning, and consistency contracts: Separate copying data from distributing ownership.
• Networks & distributed systems
  • One request crosses many protocols: DNS, IP, transport, TLS, and HTTP
  • Failure is partial and ambiguous: Timeouts, retries, backoff, and overload
  • Copies must agree enough: Replication, consistency, ordering, and consensus
  • Distributed mastery: shape and observe load: Load balancers, caches, queues, and graceful degradation
  • Frames, packets, streams, and forwarding: Trace one message across boundaries without confusing the responsibilities of each layer.
  • IP prefixes and longest-prefix routing: Compute address ranges and choose routes from bits.
  • TCP reliability, flow control, and congestion: Track acknowledged bytes and separate receiver limits from network limits.
  • DNS, HTTP, and TLS answer different questions: Trace a secure web request and locate the boundary of each guarantee.
  • Queueing, utilization, and Little’s law: Use consistent units and system boundaries to reason about latency and overload.
  • Logical clocks and causal histories: Order what communication can prove without pretending every event has a global timestamp.
  • Linearizability and weaker consistency contracts: Check a concurrent history against an explicit object specification.
  • Consensus, elections, and committed log safety: Separate choosing a leader from preserving an agreed history.
  • Distributed transactions and retry-safe effects: Locate the atomic boundary and make ambiguous retries explicit.
• AI & machine learning
  • Start with the decision, not the model: Targets, data, baselines, and leakage
  • Training is guided search: Models, loss, gradients, and regularization
  • Evaluation is an argument about the future: Generalization, metrics, calibration, and uncertainty
  • ML mastery: the model lives inside a system: Deployment, drift, feedback, safety, and human judgment
  • Decision trees and the meaning of an objective: Calculate a split, then explain what the training score leaves out.
  • Regularization, validation, and learning curves: Separate optimization failure from a model that fits too much or too little.
  • Clustering and principal components: Understand what an unlabeled objective can and cannot discover.
  • Sequential decisions and value functions: Model delayed reward without confusing prediction with control.
• LLMs & agents
  • A transformer predicts one token at a time: Tokens, embeddings, attention, and residual computation
  • Training creates capability, not a truth guarantee: Pretraining, adaptation, inference, and limits
  • Ground language in evidence and tools: Retrieval, tool contracts, and untrusted content
  • Agent mastery: close the loop safely: State, planning, permissions, evaluation, and stop conditions
  • Tokenization and the unit of prediction: Trace a reversible encoding before interpreting model probabilities.
  • Autoregressive inference and the key-value cache: Account for the work and memory behind generating one more token.
  • Language-model evaluation and evidence: Separate likelihood, task success, and unsupported conclusions.
• Programming & program design
  • Values, control flow, and function contracts: Turn a specification into a small program whose behavior you can trace.
  • Recursion, stack frames, and termination: Follow recursive calls as separate computations with unfinished work.
  • Mutation, aliasing, and ownership of data: Predict when a change is visible through more than one name.
  • Abstract data types and representation invariants: Separate the promises of a data structure from the objects used to implement it.
  • Higher-order functions and composable behavior: Pass behavior as data and reason about closures without losing evaluation order.
  • Objects, invariants, and substitutable behavior: Use objects to protect state and make interfaces predictable.
  • Exceptions, files, and resource lifetimes: Handle expected failures while preserving useful errors and releasing resources.
  • Debugging, tests, and falsifiable hypotheses: Use failures to locate causes and build evidence for a stated contract.
• Computation & complexity
  • Finite automata and regular languages: Represent a recognizer by the finite information it must remember.
  • Context-free grammars and pushdown memory: Explain nested syntax using productions, derivations, and a stack.
  • Turing machines, decision procedures, and recognition: Distinguish a machine that eventually confirms membership from one that always answers.
  • The halting contradiction and computable reductions: Prove limits by transforming an alleged solver into an impossible one.
  • Polynomial time, certificates, and the class NP: Separate finding a solution from efficiently checking a proposed one.
  • Polynomial reductions, NP-completeness, and honest limits: Use reductions to compare problems without overstating what hardness proves.
• Security & cryptography
  • Threat models and authority boundaries: Start with assets, adversaries, and the decisions a system must enforce.
  • Cryptographic primitives and their contracts: Choose integrity, authenticity, or confidentiality without confusing the guarantees.
  • Sessions, browser trust, and request forgery: Follow credentials through login, requests, and logout.
  • Injection, memory safety, and data boundaries: Keep untrusted bytes from becoming instructions or addresses.
  • Secure channels, identities, and key management: Understand what a successful TLS connection actually authenticates.
  • Security engineering and incident response: Turn a threat model into tests, maintenance, and a recoverable system.
• People, interfaces & ethics
  • User research and task analysis: Study the work people are trying to do before choosing controls.
  • Accessible structure, focus, and feedback: Make the same task operable through different input and perception modes.
  • Usability evidence and controlled experiments: Choose measurements that answer a question about learning or task success.
  • Privacy, fairness, and data minimization: Analyze who bears the cost of collecting data and making predictions.
  • Professional responsibility and technical decisions: Make consequences, uncertainty, and accountability part of engineering work.
• Graphics & simulation
  • Coordinate systems and affine transformations: Track points through scale, rotation, and translation in the correct order.
  • Perspective projection and clipping: Explain why distant objects shrink and why division needs a valid domain.
  • Triangles, barycentric coordinates, and visibility: Turn geometric coverage into reproducible pixel decisions.
  • Sampling, filtering, and linear-light color: Connect image artifacts to the signals and units being processed.
  • Numerical integration and simulation stability: Explain how a correct force law can still produce an unstable animation.
• Probability & statistics
  • Conditional probability and Bayes reasoning: Update beliefs using base rates, likelihoods, and an explicit sample space.
  • Random variables, expectation, and variance: Measure outcomes and reason about totals without confusing averages with guarantees.
  • Sampling, estimation, and confidence intervals: Separate population targets, sampling bias, and uncertainty caused by finite data.
  • Experiments, hypothesis tests, and effect sizes: Design comparisons that answer a causal question and report uncertainty honestly.
  • Regression, prediction, and confounding: Fit relationships while separating predictive association from causal effect.
  • Floating-point stability and problem conditioning: Separate rounding introduced by an algorithm from sensitivity inherent in the problem.