Computer Science
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.
Bitwise Operators & Bit ManipulationAND, OR, XOR, shifts, and the bit tricks built on them — checking, setting, clearing, and toggling individual bits.How Numbers and Text Become BitsFloating-point representation, big- vs little-endian byte order, and how ASCII became Unicode and UTF-8.Cache 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.How 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.The 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.Pipelining 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.Instruction 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.Processes 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.CPU 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.Synchronization: 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.DeadlocksThe 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.Memory 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.Interprocess CommunicationHow separate processes that don't share memory exchange data — pipes, message queues, shared memory, and sockets — and when to reach for each.File 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.Finite Automata and Regular LanguagesWhat a finite automaton is, what makes a language "regular," and why every regex engine you use is secretly running one.Turing 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.Lexing and ParsingHow raw source text becomes tokens, and how those tokens become a tree — the two-stage pipeline every compiler and interpreter starts with.Compilation 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.Intermediate 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.Concurrency vs. ParallelismWhy structuring a program as independent tasks (concurrency) is a different idea from running tasks at the same instant (parallelism).Race Conditions and Thread SafetyHow unsynchronized access to shared state produces timing-dependent bugs, worked through a classic lost-update counter example.Version 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.Testing 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.GoF 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.UML DiagramsClass, use-case, activity, state-machine, and sequence diagrams — what each one shows and when to reach for it.The 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.DNS 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.TLS and HTTPSHow HTTPS gets its privacy and integrity guarantees from TLS — the handshake, certificates, and what encryption in transit does and doesn't protect.Sockets, 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.
Representation & caching
- Bitwise Operators & Bit ManipulationAND, OR, XOR, shifts, and the bit tricks built on them — checking, setting, clearing, and toggling individual bits.
- How Numbers and Text Become BitsFloating-point representation, big- vs little-endian byte order, and how ASCII became Unicode and UTF-8.
- Cache 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.
Computer architecture
- How 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.
- The 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.
- Pipelining 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.
- Instruction 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.
Operating systems
- Processes 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.
- CPU 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.
- Synchronization: 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.
- DeadlocksThe 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.
- Memory 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.
- Interprocess CommunicationHow separate processes that don't share memory exchange data — pipes, message queues, shared memory, and sockets — and when to reach for each.
- File 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.
Theory of computation & compilers
- Finite Automata and Regular LanguagesWhat a finite automaton is, what makes a language "regular," and why every regex engine you use is secretly running one.
- Turing 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.
- Lexing and ParsingHow raw source text becomes tokens, and how those tokens become a tree — the two-stage pipeline every compiler and interpreter starts with.
- Compilation 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.
- Intermediate 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.
Concurrency & practices
- Concurrency vs. ParallelismWhy structuring a program as independent tasks (concurrency) is a different idea from running tasks at the same instant (parallelism).
- Race Conditions and Thread SafetyHow unsynchronized access to shared state produces timing-dependent bugs, worked through a classic lost-update counter example.
- Version 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.
- Testing 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.
Design patterns & architecture
Networking fundamentals
- The 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.
- DNS 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.
- TLS and HTTPSHow HTTPS gets its privacy and integrity guarantees from TLS — the handshake, certificates, and what encryption in transit does and doesn't protect.
- Sockets, 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.