Computer Science lessons & courses
69 lessons · 16 learning paths · free, quiz-checked, no signup required
The foundations beneath the stack: how computers represent data, schedule work, and move bits. Timeless material that outlives any particular framework.
Learning paths
Search Relevance: From BM25 to Hybrid
Vector search did not replace keyword search; production search runs both, because they fail in opposite places. This path builds relevance engineering from the ground up: the inverted index and the analysis decisions baked into it, BM25 and its saturation arithmetic, hybrid retrieval with reciprocal rank fusion, and the evaluation machinery, judgment sets, NDCG, position bias, that tells you whether any of it actually got better.
Formal Verification: Proving a Program Correct
Testing samples inputs; a proof covers all of them. Three traditions do this and each hits a different wall. Deductive proof turns a program into a relation between assertions, and stalls at the loop invariant no machine can supply. Type-level encoding makes wrong programs unwritable, and pays with a language that rejects some correct ones. Model checking searches every state exhaustively, and is bounded by how many there are. The path ends with two systems that were actually verified, and what they cost.
Floating Point: Why Your Numbers Are Wrong
Every floating point operation is correctly rounded to about sixteen digits, and results are still wrong in the first digit. This path explains how both are true: the guarantee is per-operation and relative, which means subtracting nearly equal numbers promotes error from insignificant to dominant without introducing any. It covers the representation, the cancellation patterns worth recognising, how to compare and test, and finally how to tell whether an inaccurate answer is your bug or the problem's nature.
Probabilistic Data Structures: Answers Without the Data
Answering set questions exactly costs memory proportional to the data, and that is a lower bound rather than an inefficiency. Sketches give up exactness in a specific, chosen direction and get constant memory in return. This path builds the three that run modern infrastructure: Bloom filters for membership, HyperLogLog for distinct counts in twelve kilobytes, and count-min for frequency. It ends on the property that actually explains their ubiquity, which is not the space saving.
Computer Graphics: Rasterisation and Ray Tracing
Every renderer answers one question first: at this pixel, which surface is visible? There are two ways to answer it, and almost everything else about a graphics system follows from which one it picked. This path builds the transform chain, then rasterisation as a distributed sort with a depth buffer, then ray tracing as a search through a spatial hierarchy. The last lesson explains why the two coexist, and lets you predict which effects will be cheap, which will be faked, and what the artefacts will look like.
The Limits of Computation: What No Program Can Do
Some things are not slow to compute, they are impossible, and the boundary is sharp enough to prove in a few lines. This path climbs the ladder of machines one memory model at a time: finite states and the counting argument that defeats them, then a stack, then an unbounded tape. At the top the limit stops being about memory and becomes the halting problem, generalised by Rice to every semantic property at once. The last lesson spends that result on why every type checker and verifier must choose which way to be wrong.
Dynamic Programming and Greedy: Knowing Which One Applies
Both techniques replace exponential search with something polynomial, and both fail on problems without the right structure. This path builds the recognition skill rather than a catalogue of recurrences: optimal substructure and where it breaks, choosing a state and deriving the running time from it, the exchange argument and the matroid theorem that says exactly when greedy is guaranteed, and a decision procedure to run on a problem you have never seen before.
Differentiable Rendering: Running Graphics Backwards
If a renderer is differentiable, recovering a 3D scene from a photograph becomes gradient descent. This path builds that idea properly: the rendering equation and why Monte Carlo path tracing is the only way to evaluate it, the visibility discontinuities that make naive autodiff return silently zero gradients for geometry, the adjoint and path-replay methods that made the backward pass affordable, and why the remaining difficulties are about the problem being ill-posed rather than about the gradients.
Core Data Structures: Hash Tables, Trees, Heaps, and Tries
Four structures cover most of what production code actually needs, and each exists because the others cannot answer one particular question. This path builds them from the mechanism up: why a hash table's constant lookup costs you all ordering, why sorted input destroys an unbalanced tree and what a rotation repairs, why a heap keeps only enough order to surface the smallest item, and why routers and autocomplete need a trie. You will finish able to pick the right one from the question being asked.
How CPUs Actually Work: Pipelines, Caches, and Performance
Two processors at the same clock speed can differ several-fold in real work done, and the reason is never the clock. This path builds the model that explains it: how a pipeline overlaps instructions and what a mispredicted branch costs, how a core issues several instructions per cycle and reorders them, why a DRAM access is roughly sixty times an L1 hit, and how the roofline model tells you whether optimising arithmetic is worth any effort at all. You will finish able to predict which loop is faster and say why.
Information Theory and Compression
Shannon proved in 1948 that information has a hard, measurable limit, and nearly every file, stream and disk you touch is built on that result. This path works through it. You will learn what entropy really measures and why cross-entropy is the loss function that trains language models, how Huffman and arithmetic coding approach the compression floor, where lossy formats like JPEG and AAC actually discard information and why that is a deliberate tradeoff, and how error-correcting codes let data survive a noisy channel.
How Computer Networks Actually Work
A request leaves your browser and arrives somewhere across the world in tens of milliseconds. This path follows it the whole way down. You will learn how headers nest as a packet is built, why MTU mismatches cause the classic bug where small requests work and large ones hang, how routers choose a path by longest prefix match and how a BGP mistake can take a network off the internet, how TCP turns an unreliable network into an ordered stream and what congestion control is really negotiating, and why HTTP/3 abandoned TCP for QUIC.
How Operating Systems Actually Work
Every program runs on top of a kernel making decisions for it: which thread gets the CPU, which pages stay in memory, when a write really reaches disk. This path opens that layer up. You will learn what a process actually is and what a context switch costs, how virtual addresses become physical ones through page tables and the TLB, what happens when code crosses into kernel mode and why that crossing is expensive, and how the page cache and fsync decide whether your data survives a crash. It closes on containers as ordinary kernel features rather than magic.
Digital Twins: Virtual Replicas of the Physical World
A digital twin is a virtual replica of a specific physical asset, kept in sync by live data so you can predict, optimize, and experiment safely in software. This cursus builds the concept precisely: what a twin is and how it differs from a plain simulation, what it is made of (physics and data-driven models, the sensor and data layer, and the types from component to process scale), and where it pays off, predictive maintenance, manufacturing, energy, and more, alongside an honest look at the data, drift, cost, and security challenges.
How hackers get in (and how to stop them)
A practical, example-driven tour of security from basics to advanced. Start by thinking like an attacker and following a real breach through its five stages, then dig into the human layer of phishing and passwords, then the technical layer where web apps get hacked with real code for SQL injection and XSS, and finally the defender's playbook of least privilege, zero trust, detection, and response. Every attack is paired with its concrete defense.
System Design Fundamentals
Ten lessons covering the building blocks every backend engineer needs to reason about scale. Move from traffic-shaping and caching through the hard tradeoffs of distributed data, then up to architectural styles that decide how teams ship.
All Computer Science lessons
Filesystems and the I/O Path
A file has no name; the name is a directory entry pointing at an inode. This lesson follows the kernel's I/O path: the VFS abstraction over every filesystem, the page cache and its writeback thresholds, buffered versus direct I/O, what fsync actually promises and what it does after a failure, ext4 journaling modes, and how a write finally reaches flash.
Syscalls and the Kernel Boundary
User code cannot touch a disk, a network card, or another process's memory without crossing into the kernel, and the crossing is not free. This lesson covers ring transitions and the syscall path, interrupts versus traps versus exceptions, measured boundary costs, why vDSO and io_uring exist, and how namespaces plus cgroups turn ordinary kernel features into containers.
Virtual Memory: Page Tables, TLBs and Faults
Virtual memory is not a trick for pretending you have more RAM. It is the hardware and kernel machinery that gives every process a private, relocatable address space. This lesson covers multi-level page tables, why a TLB miss costs real cycles, demand paging, copy-on-write, mmap, swapping, huge pages, and how the OOM killer picks a victim.
Processes and Scheduling: What the Kernel Actually Runs
A process is an address space plus a control block, and the thing Linux actually schedules is neither. This lesson walks the kernel side: what a context switch physically costs, how per-CPU run queues and preemption flags work, how nice values become weights, and why CFS was replaced by EEVDF in Linux 6.6.
Applications, Value, and Challenges
Where digital twins earn their keep and where they struggle. This lesson covers predictive maintenance (the flagship use), applications across manufacturing, aerospace, energy, cities, and healthcare, the underlying value of experimenting safely in virtual space, and an honest account of the challenges: data, model drift, cost, security, and standards.
Anatomy and Types of Digital Twins
What a digital twin is actually made of and the forms it takes. This lesson covers the virtual model (physics-based, data-driven, and hybrid), the data layer of sensors and pipelines that feeds it, the twin taxonomy from component to process scale, the fidelity-versus-cost tradeoff, and the sense-simulate-act loop that turns a model into a working twin.
What Is a Digital Twin?
A digital twin is a virtual replica of a specific physical thing, kept in sync by live data. This lesson defines it precisely, covers its three components, its origins with Michael Grieves and NASA, the crucial distinction from an ordinary simulation, and the digital model to digital shadow to digital twin taxonomy that pins down what 'twin' really means.
Building systems that resist attack
No single wall stops a determined attacker, so real security is built in layers on one assumption: a breach will eventually happen. Learn the practical defender's playbook, least privilege, network segmentation and zero trust, patching, encryption done right, and the detection and incident response that limit the damage when prevention fails, each mapped to the attack stages it defeats.
How web applications actually get hacked
Most technical breaches trace to one root cause: an application trusting input it should not. Walk through the real vulnerabilities with concrete code, SQL injection, cross-site scripting, broken access control, and vulnerable dependencies, seeing exactly how each is exploited and, just as concretely, how each is fixed. Practical, example-driven, and defense-focused throughout.
The weakest link is a person
Most breaches do not start with clever code; they start with a person. Learn how phishing actually works by dissecting a real example, how passwords get stolen through breaches, credential stuffing, and spraying, why multi-factor authentication helps and how attackers bypass it, and the practical habits, unique passwords, password managers, phishing-resistant MFA, that defend the human layer.
How a hacker actually breaks in
Real attacks are not a single dramatic moment; they are a patient, multi-stage process. Learn to think like an attacker and follow the chain from reconnaissance to initial access, privilege escalation, lateral movement, and the final objective. Understanding this sequence is the foundation of both breaking in and defending, because every stage is also a chance to stop the attack.
Idempotency
Why "the same request twice should produce the same result" is one of the most useful properties you can give an API, the standard patterns for implementing it (keys, dedupe tables, natural idempotency), and what goes wrong when you don't.
Event-Driven Architecture
Commands tell, events announce. How event-driven systems decouple producers from consumers, when CQRS and event sourcing earn their complexity, and the eventual-consistency tax you pay either way.
Microservices vs Monoliths
The honest case for each. When a monolith is correct, what microservices actually buy you (and what they cost), Conway's law, and how to spot a fake microservices architecture that's actually a distributed monolith.
CDNs Explained
Why your assets should never come from your origin. How a CDN's edge cache, geographic routing, and invalidation actually work, plus the cases where a CDN doesn't help (or quietly hurts).
Rate Limiting
How to keep one client from breaking the system for everyone else. The four canonical algorithms (fixed window, sliding window, token bucket, leaky bucket), distributed limiting with Redis, and the polite way to tell a client "slow down".
Message Queues
Async work between services without one tripping the other. Point-to-point vs pub/sub, the three delivery guarantees and what they cost, dead letter queues, and how to pick between Kafka, RabbitMQ, SQS, and friends.
Caching Strategies
The named caching patterns (cache-aside, read-through, write-through, write-behind), when each makes sense, and the failure modes that bite even experienced teams (thundering herd, stale invalidation, the second-hardest problem).
The CAP Theorem
Why every distributed system has to give up something when the network splits. CAP, the trade-offs in real databases, and the PACELC extension that's usually more useful in practice.
Database Sharding
When one database isn't enough. How sharding splits data across nodes, the trade-offs of different sharding keys, and the operational headaches (hot spots, rebalancing, cross-shard queries) you sign up for.
Load Balancing
How load balancers spread traffic across servers, what L4 and L7 actually mean, the routing algorithms in real use, and the failure modes you need to design around.