COMPUTER SCIENCE, CONNECTED

Understand the mechanisms.
Connect the ideas.

Go beyond code that works.
Follow a program through memory, the CPU and the OS to understand what happens inside a computer.

Use lessons, practice questions and demos without signing up.

INSIDE THE COMPUTER01 / 04
// Start small. See how it works.let total = 0;
for (const value of values) {
  total += value;
}
01ProgramValues, types, execution
02MemoryReferences, layout, lifetime
03CPUInstructions, caches
04Operating systemProcesses, virtual memory

Look at one computation through several layers.

Open materials
541topics
Practice questions
1,704questions
Learning courses
5courses
Knowledge map
22subjects

Study 13 foundation textbooks and 528 other materials in Japanese or English. Check foundations → · Predict and experiment →

CHOOSE YOUR STARTING POINT

Where will you begin?

Try a short session with a lesson, practice questions and a look at the mechanism.

Build your CS foundations

Follow a program from execution to memory, complexity, and the CPU. Use computer science foundations to answer questions that come up while building software.

Understand the systems behind the web

Study processes, virtual memory, and concurrency in sequence. Build the foundation needed to understand network communication and databases.

Prepare for AI systems

Start with complexity, memory hierarchies, CPUs, and concurrency before studying AI execution systems. See where model theory fits into the wider learning path.

Learn by running and building

Inspect internal state and connect the code to the mechanism.

Explore experiments and demos →

Build a DOM from HTML

Change a short HTML input and follow the steps that turn a string into a tree.

Try the demo →

OPEN TEXTBOOKS

Build your understanding, one topic at a time.

Work through concrete examples and explore the mechanisms behind the code.

Find any learning material →

KNOWLEDGE MAP

See where each idea fits.

Explore available lessons and upcoming topics. Select a topic to see its objectives and prerequisites.

TIER 0

Mathematics and logic

Discrete Mathematics, Logic, and Proof

Describe discrete structures using sets, relations, logic, proof, and induction.

Read lesson
Sets, relations, and counting: handle overlap and correspondence →
Induction and loop invariants: explain why repetition is correct →

Linear Algebra

Work with multidimensional structures through vectors, matrices, linear maps, eigenvalues, and decompositions.

Probability and Statistics

Model uncertainty with random variables and distributions, then estimate and evaluate quantities from samples.

Calculus and Optimization

Connect rates of change, gradients, the chain rule, convexity, and optimization to machine learning and systems analysis.

Derivatives and gradients: read local change →Numerical stability and condition numbers →
Gradient descent: test step size and convergence on a quadratic →Convexity and optimization guarantees →
TIER 1

Computer science foundations

Programming Foundations

Understand how programs execute, manage memory, express abstractions, and support debugging.

Read lesson
Read lesson
Read lesson
Debugging and testing: turn a hypothesis into a small check →

Algorithms and Data Structures

Study computation and data representation through correctness, complexity, and measured performance.

Read lesson
Choose a data structure from the operations you need →
Understand BFS and DFS through traversal order and shortest paths →
Choose among greedy methods, divide-and-conquer, and dynamic programming →

Computer Architecture

Understand how instructions, processors, pipelines, caches, I/O, and multiple cores execute programs.

Theory of Computation

Explore the limits of computation through formal languages, automata, computability, reductions, and complexity classes.

Formal Languages, Regular Expressions, and Finite Automata →
Computability, Reductions, P, and NP →

Operating Systems

Understand resource abstraction and protection through virtualization, concurrency, and persistence.

Computer Networks

Trace communication through layers, addressing, routing, reliability, name resolution, and web protocols.

Databases

Understand persistent data management through data models, indexes, queries, transactions, and recovery.

TIER 2

Systems and security

Concurrency

Reason about races, synchronization, ordering, and progress when executions overlap.

Distributed Systems

Reason about consistency and availability across nodes that can fail independently and communicate with delays.

Programming Languages and Compilers

Connect syntax, semantics, and types to program analysis, transformation, and runtime systems.

Syntax, semantics, and types: separate three kinds of correctness →Understand type checking and inference through constraints →Parse expressions into a JavaScript syntax tree →
Compilers, Interpreters, Runtimes, and Garbage Collection →From source characters to an expression tree →Manage value lifetimes with ownership and borrowing →Garbage collection through reachability →JIT optimization and deoptimization →Types, ownership, and errors across an FFI →Tokenize HTML by following parser state →Build a DOM from tokens and an open-element stack →Choose CSS values through matching and the cascade →Compute layout boxes and paint a small page →Parse expressions into a JavaScript syntax tree →Execute JavaScript with environments and a call stack →Propagate DOM mutations through a document tree →Trace event paths and propagation →Process tasks and microtasks →Decide what to relayout and repaint after a change →Design HTML tokens and source positions in Rust →Preserve DOM parent and child invariants in Rust →Compute styles and layout in Rust →Verify the same Rust code natively and in WASM →Reading JavaScript in Rust: tokens into syntax trees →Running JavaScript in Rust: values, bindings, and calls →Event dispatch in Rust: capture, bubble, and stopping propagation →From DOM mutation to repaint: follow one Rust tree →Scheduling and cancelling timers in Rust →Selecting one task at a time in Rust →Draining microtasks to a checkpoint in Rust →Updating DOM and painting after deferred work →

Virtualization and Cloud Computing

Understand resource abstraction and operations using virtual machines, hypervisors, containers, and orchestration.

Virtual Machines, Hypervisors, and Virtual I/O →Arm exception levels: guest and hypervisor responsibilities →Guest entry and exit: save state and resume →Two-stage translation: follow VA, IPA, and PA →Virtualization permissions and faults: why a mapped address can still fail →MMIO to character output: follow a virtual UART access →One virtqueue round trip: publish, complete, and reclaim →Manage interrupt state: separate pending from active →Deliver a virtual interrupt: check recipient and masks →Calculate virtual time and deadlines: count, offset, and CVAL →Switch timer contexts: preserve deadlines and clear the level source →Build virtio block requests: validate direction, length, and sector →Confirm completion and reclaim resources: follow used IDs and ownership →Booting Rust: linker placement and the first stack →Initializing EL2: exception vectors and saved frames →Entering an EL1 guest: ERET and the execution contract →Emulating MMIO: validating a stage-2 fault and resuming the guest →Configuring GICv3 in Rust: the virtual interrupt entry →IRQ round trips in Rust: acknowledge, EOI, and deactivate →Virtual timers in Rust: from deadline to interrupt →Resuming after a timer: rearming, masking, and measured invariants →Implementing virtio-mmio in Rust: registers into request admission →Validating a virtqueue in Rust: descriptors and ring handoff →Implementing block I/O in Rust: returning a 512-byte sector →Returning I/O completion: used rings, IRQ, and guest reclaim →
Containers, Namespaces, cgroups, and Orchestration →

Computer Security

Analyze threat models, authentication, authorization, memory safety, web attacks, isolation, and side channels.

Cryptography

Understand the primitives and assumptions behind confidentiality, integrity, authentication, and key exchange.

Hashes, MACs, Symmetric Encryption, and Randomness →
Public-Key Cryptography, Signatures, PKI, and TLS →

Trusted Execution and Confidential Computing

Protect execution and data from an untrusted host and verify execution state remotely.

TEEs, Enclaves, and Confidential Virtual Machines →
Measurements, Remote Attestation, and Key Provisioning →
TIER 3

AI and its execution platforms

Machine Learning

Understand learning from data through loss minimization, generalization, evaluation, and representation.

Supervised Learning, Models, and Loss Functions →
Generalization, Overfitting, and Evaluation Metrics →
Feature Representations, Dimensionality Reduction, and Clustering →

Deep Learning

Study neural networks, backpropagation, optimization, and major model architectures.

Neural Networks, Computation Graphs, and Backpropagation →
Deep Learning Optimization and Model Architectures →Quantization error and inference performance →

Transformers and Large Language Models

Understand language models through tokenization, self-attention, pretraining, generation, and KV caching.

Tokenization, Self-Attention, and Transformers →
Pretraining, Fine-Tuning, Generation, and the KV Cache →Calculating KV-cache capacity →Separating prefill and decode in LLM inference →

AI Systems

Connect accelerator execution, inference serving, vector search, RAG, evaluation, observability, and security.