Computer Science

Beginner · Roadmap · 29 lessons · 7 groups

The layers above data structures and algorithms (see datastructures-and-algorithms) and short of system design (see system-design): how a CPU actually executes a program, how an operating system shares one machine among many programs, what a computer can and can't compute and how a compiler turns text into something that runs, how concurrent code stays correct, how bits become numbers and text, how patterns organize software, and how machines talk to each other over a network. Twenty-nine lessons that assume the core data structures and algorithms as a starting point.

0%

Not started

Nothing saved yet. Progress is kept in this browser until you sign in.

Start the path

Representation & caching · 3

Computer architecture · 4

Operating systems · 7

Theory of computation & compilers · 5

Concurrency & practices · 4

Design patterns & architecture · 2

Networking fundamentals · 4

01Bitwise Operators & Bit ManipulationAND, OR, XOR, shifts, and the bit tricks built on them — checking, setting, clearing, and toggling individual bits.Beginner · 10 min02How Numbers and Text Become BitsFloating-point representation, big- vs little-endian byte order, and how ASCII became Unicode and UTF-8.Beginner · 10 min03Cache Eviction: LRU, LFU & MFUWhich cached item to throw out when the cache is full — least recently used, least frequently used, or most frequently used — plus Huffman coding.Intermediate · 15 min01How a CPU Executes InstructionsThe fetch-decode-execute cycle, registers versus RAM, the program counter, and a worked trace of a CPU running a few instructions.Beginner · 11 min02The Memory Hierarchy and Why Caching WorksWhy computers stack registers, L1/L2/L3 cache, RAM, and disk into a hierarchy, and why locality is the reason caching actually works.Beginner · 6 min03Pipelining and Instruction-Level ParallelismHow CPUs overlap the fetch, decode, execute, and writeback stages of different instructions, and why data, control, and structural hazards make this hard.Beginner · 22 min04Instruction Sets and Assembly BasicsWhat an instruction set architecture is, RISC vs CISC at a conceptual level, and a short assembly snippet walked through line by line.Beginner · 10 min01Processes and ThreadsWhat separates a process from a thread, why threads are cheaper to create and switch between, and the states a process moves through as it runs.Beginner · 11 min02CPU Scheduling AlgorithmsHow an OS picks which ready process runs next — FCFS, SJF, round robin, and priority scheduling — and the throughput-vs-fairness tradeoffs between them.Beginner · 16 min03Synchronization: Locks and SemaphoresWhy concurrent access to shared data needs coordination, how mutexes and semaphores provide it, and how both solve the classic producer-consumer problem.Beginner · 18 min04DeadlocksThe four conditions that must all hold for a deadlock to occur, how a resource-allocation graph detects one, and how prevention and avoidance strategies work.Beginner · 12 min05Memory Management and Virtual MemoryWhy every process gets its own private address space, how paging maps it to real RAM, and what happens when memory runs out.Beginner · 12 min06Interprocess CommunicationHow separate processes that don't share memory exchange data — pipes, message queues, shared memory, and sockets — and when to reach for each.Beginner · 13 min07File Systems and I/OHow a file system organizes data on disk as inodes and directory trees, and why the OS buffers reads and writes instead of hitting disk every time.Beginner · 12 min01Finite Automata and Regular LanguagesWhat a finite automaton is, what makes a language "regular," and why every regex engine you use is secretly running one.Beginner · 13 min02Turing Machines and DecidabilityA more powerful machine than a finite automaton — and a proof, using that machine, that some problems can never be solved by any program.Beginner · 6 min03Lexing and ParsingHow raw source text becomes tokens, and how those tokens become a tree — the two-stage pipeline every compiler and interpreter starts with.Beginner · 14 min04Compilation vs. InterpretationThe spectrum from executing an AST directly to compiling all the way to machine code ahead of time — and where JIT compilation sits in between.Beginner · 11 min05Intermediate Representations and BytecodeWhy compilers and runtimes translate to bytecode instead of going straight from AST to machine code, using Python's .pyc and JVM bytecode as examples.Beginner · 23 min01Concurrency vs. ParallelismWhy structuring a program as independent tasks (concurrency) is a different idea from running tasks at the same instant (parallelism).Intermediate · 4 min02Race Conditions and Thread SafetyHow unsynchronized access to shared state produces timing-dependent bugs, worked through a classic lost-update counter example.Intermediate · 11 min03Version Control Internals: How Git Actually Stores DataGit's real mental model — commits as content-addressed snapshots forming a DAG, and branches as nothing more than movable pointers.Intermediate · 58 min04Testing Fundamentals: The Test PyramidUnit, integration, and end-to-end tests, what makes a unit test good, and why mocking exists to isolate the thing under test.Intermediate · 2 min01GoF Design PatternsThe Gang of Four's creational, structural, and behavioral patterns, with a deep look at Strategy plus the Null Object and Type Object patterns.Intermediate · 35 min02UML DiagramsClass, use-case, activity, state-machine, and sequence diagrams — what each one shows and when to reach for it.Beginner · 13 min01The OSI Model and TCP/IP ModelHow networking is split into layers, what each layer is responsible for, and why TCP/IP — not OSI — is what the internet actually runs on.Beginner · 12 min02DNS and HTTP: What Happens When You Hit EnterHow a domain name becomes an IP address, and the request/response protocol that carries the page back once it has one.Beginner · 15 min03TLS and HTTPSHow HTTPS gets its privacy and integrity guarantees from TLS — the handshake, certificates, and what encryption in transit does and doesn't protect.Intermediate · 12 min04Sockets, WebSockets, and PollingWhat a network socket is, and the three ways browsers get near-real-time updates from a server — short polling, long polling, and WebSockets.Intermediate · 27 min

Representation & caching

3 lessons

  1. 01 / 03Bitwise Operators & Bit ManipulationAND, OR, XOR, shifts, and the bit tricks built on them — checking, setting, clearing, and toggling individual bits.10 min
  2. 02 / 03How Numbers and Text Become BitsFloating-point representation, big- vs little-endian byte order, and how ASCII became Unicode and UTF-8.10 min
  3. 03 / 03Cache Eviction: LRU, LFU & MFUWhich cached item to throw out when the cache is full — least recently used, least frequently used, or most frequently used — plus Huffman coding.15 min

Computer architecture

4 lessons

  1. 01 / 04How a CPU Executes InstructionsThe fetch-decode-execute cycle, registers versus RAM, the program counter, and a worked trace of a CPU running a few instructions.11 min
  2. 02 / 04The Memory Hierarchy and Why Caching WorksWhy computers stack registers, L1/L2/L3 cache, RAM, and disk into a hierarchy, and why locality is the reason caching actually works.6 min
  3. 03 / 04Pipelining and Instruction-Level ParallelismHow CPUs overlap the fetch, decode, execute, and writeback stages of different instructions, and why data, control, and structural hazards make this hard.22 min
  4. 04 / 04Instruction Sets and Assembly BasicsWhat an instruction set architecture is, RISC vs CISC at a conceptual level, and a short assembly snippet walked through line by line.10 min

Operating systems

7 lessons

  1. 01 / 07Processes and ThreadsWhat separates a process from a thread, why threads are cheaper to create and switch between, and the states a process moves through as it runs.11 min
  2. 02 / 07CPU Scheduling AlgorithmsHow an OS picks which ready process runs next — FCFS, SJF, round robin, and priority scheduling — and the throughput-vs-fairness tradeoffs between them.16 min
  3. 03 / 07Synchronization: Locks and SemaphoresWhy concurrent access to shared data needs coordination, how mutexes and semaphores provide it, and how both solve the classic producer-consumer problem.18 min
  4. 04 / 07DeadlocksThe four conditions that must all hold for a deadlock to occur, how a resource-allocation graph detects one, and how prevention and avoidance strategies work.12 min
  5. 05 / 07Memory Management and Virtual MemoryWhy every process gets its own private address space, how paging maps it to real RAM, and what happens when memory runs out.12 min
  6. 06 / 07Interprocess CommunicationHow separate processes that don't share memory exchange data — pipes, message queues, shared memory, and sockets — and when to reach for each.13 min
  7. 07 / 07File Systems and I/OHow a file system organizes data on disk as inodes and directory trees, and why the OS buffers reads and writes instead of hitting disk every time.12 min

Theory of computation & compilers

5 lessons

  1. 01 / 05Finite Automata and Regular LanguagesWhat a finite automaton is, what makes a language "regular," and why every regex engine you use is secretly running one.13 min
  2. 02 / 05Turing Machines and DecidabilityA more powerful machine than a finite automaton — and a proof, using that machine, that some problems can never be solved by any program.6 min
  3. 03 / 05Lexing and ParsingHow raw source text becomes tokens, and how those tokens become a tree — the two-stage pipeline every compiler and interpreter starts with.14 min
  4. 04 / 05Compilation vs. InterpretationThe spectrum from executing an AST directly to compiling all the way to machine code ahead of time — and where JIT compilation sits in between.11 min
  5. 05 / 05Intermediate Representations and BytecodeWhy compilers and runtimes translate to bytecode instead of going straight from AST to machine code, using Python's .pyc and JVM bytecode as examples.23 min

Concurrency & practices

4 lessons

  1. 01 / 04Concurrency vs. ParallelismWhy structuring a program as independent tasks (concurrency) is a different idea from running tasks at the same instant (parallelism).4 min
  2. 02 / 04Race Conditions and Thread SafetyHow unsynchronized access to shared state produces timing-dependent bugs, worked through a classic lost-update counter example.11 min
  3. 03 / 04Version Control Internals: How Git Actually Stores DataGit's real mental model — commits as content-addressed snapshots forming a DAG, and branches as nothing more than movable pointers.58 min
  4. 04 / 04Testing Fundamentals: The Test PyramidUnit, integration, and end-to-end tests, what makes a unit test good, and why mocking exists to isolate the thing under test.2 min

Design patterns & architecture

2 lessons

  1. 01 / 02GoF Design PatternsThe Gang of Four's creational, structural, and behavioral patterns, with a deep look at Strategy plus the Null Object and Type Object patterns.35 min
  2. 02 / 02UML DiagramsClass, use-case, activity, state-machine, and sequence diagrams — what each one shows and when to reach for it.13 min

Networking fundamentals

4 lessons

  1. 01 / 04The OSI Model and TCP/IP ModelHow networking is split into layers, what each layer is responsible for, and why TCP/IP — not OSI — is what the internet actually runs on.12 min
  2. 02 / 04DNS and HTTP: What Happens When You Hit EnterHow a domain name becomes an IP address, and the request/response protocol that carries the page back once it has one.15 min
  3. 03 / 04TLS and HTTPSHow HTTPS gets its privacy and integrity guarantees from TLS — the handshake, certificates, and what encryption in transit does and doesn't protect.12 min
  4. 04 / 04Sockets, WebSockets, and PollingWhat a network socket is, and the three ways browsers get near-real-time updates from a server — short polling, long polling, and WebSockets.27 min
Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark