CS Fundamentals
How computers actually work — from CPU fetch-decode-execute through data structures, algorithms, networking, databases, operating systems, cryptography, and system design. No hand-waving, no skipped foundations.
How Computers Actually Work: CPU, Memory, Storage — No Abstraction
Every programming tutorial treats "the computer runs your code" as a black box. This post opens it — the fetch-decode-execute cycle, why RAM is fast but forgets everything, why storage is slow but permanent, and the memory hierarchy that explains almost every performance characteristic you'll ever encounter as a developer.
Binary, Hexadecimal, and Why Computers Think in 0s and 1s
Post 1 explained what the CPU and memory do — this post explains the actual language everything is encoded in underneath. A complete guide to binary and hex number systems, why they exist, how text becomes numbers, and the bitwise operations that show up in real code more often than you'd expect.
Data Structures: Arrays, Linked Lists, Stacks, and Queues
Post 1 covered how memory works — this post covers the fundamentally different ways you can organize data within it, and why that choice matters more than almost any other decision in a program's design. Arrays, linked lists, stacks, and queues, with the actual hardware-level reason arrays are usually faster in practice.
Data Structures: Hash Tables — The Most Useful Structure You'll Ever Use
Nearly every fast lookup in modern software — a Python dict, a database index, a cache — relies on the same underlying idea. A complete guide to how hash tables actually achieve near-instant access, what happens when two keys collide, and why Python's dict has been a hash table under the hood the entire time.
Data Structures: Trees, Binary Search Trees, and Tree Traversal
Hash tables from Post 4 are excellent at "look up by exact key" and terrible at "give me everything in sorted order" or "find everything between X and Y." Trees solve exactly this gap. A complete guide to binary search trees, the four ways to traverse one, and why your browser's DOM is one of the most common trees you'll ever work with.
Data Structures: Graphs — Modeling the World as Nodes and Edges
A tree allows exactly one parent per node — a genuinely common relationship, but not the only one. Graphs drop that restriction entirely, letting any node connect to any other, and become the data structure underneath maps, social networks, and dependency resolution. A complete guide, including the direct payoff of Post
Algorithms: Big O Notation — Measuring Code Performance Precisely
"O(1) average case" and "O(log n)" have appeared constantly since Post #4 without a formal definition — this is the post that makes them precise. A complete guide to Big O notation, using the exact data structures from this series (hash tables, BSTs, arrays) as concrete, already-familiar examples rather than abstract theory.
Algorithms: Sorting — Bubble to Quicksort and Why It Matters
Post 5's BST-based sort was a genuine, working algorithm — this post covers the sorting algorithms actually used in practice, from the simplest to understand to the ones running under the hood of every language's built-in sort(), including the hardware-level reason quicksort often beats merge sort despite matching Big O.
Algorithms: Searching — Linear, Binary, and Beyond
Post 8 covered how to sort data — this post covers exactly why that effort pays off. Binary search finds anything in a sorted list of a billion items in about 30 comparisons, using the identical halving strategy Post 5's binary search tree relied on. A complete guide to when sorting first is actually worth it.
Recursion: Thinking in Self-Reference, Base Cases, and Call Stacks
Recursion has appeared constantly since Post 5 — BST search, DFS, merge sort, quicksort — always used, never formally explained. This is that explanation, grounded directly in Post 1's CPU mechanics and Post 3's call stack, including why naive recursive Fibonacci is a genuinely instructive way to see O(2^n) growth happen in real code.
Dynamic Programming: Solving Hard Problems by Remembering Answers
Post 10 ended with naive Fibonacci recomputing the same values millions of times, an O(2^n) explosion for no good reason. Dynamic programming fixes exactly this — remember an answer once, never recompute it. A complete guide to memoization and tabulation, turning that same exponential Fibonacci into a linear-time function.
Greedy Algorithms: When Local Optimal Is Globally Optimal
Post 11's dynamic programming remembers every possibility to guarantee the best answer. Greedy algorithms make a different bet entirely — pick the best-looking option at each step and never reconsider — dramatically faster when it works, and silently wrong when it doesn't. A complete guide to both sides of that bet.
How the Internet Works: TCP/IP, DNS, and HTTP — The Real Story
Every fetch() call and every API request across this blog's other series has treated "send this to a URL" as a black box. This post opens it completely — how a domain name becomes an IP address, how TCP guarantees your data arrives intact and in order, and what actually happens between pressing Enter and a page appearing on screen.
Databases: Relational vs NoSQL, Indexing, and Query Optimization
Post 4's hash tables and Post 5's trees were not just abstract theory — they are literally the data structures powering every database index in production use today. A complete guide to relational and NoSQL databases, and the concrete, direct connection between this series' foundational data structures and how a database actually makes a query fast.
Operating Systems: Processes, Threads, and Memory Management
Post 1 covered a single CPU's fetch-decode-execute cycle — but your computer runs hundreds of programs at once on far fewer cores than that. This post covers the operating system layer that makes that illusion work, and connects directly to the threading-versus-multiprocessing decision covered elsewhere on this blog.
Cryptography: Hashing, Encryption, and How HTTPS Actually Works
Post 4 covered hashing for fast lookup. This post covers a completely different kind of hashing — the cryptographic kind, built for security rather than speed — plus the encryption that turns Post 13's plain-text HTTP into HTTPS. A complete guide to how your data actually stays private in transit.
System Design: Scaling From One Server to One Million Users
Every post in this module covered one piece in isolation — networking, databases, operating systems. This post is where they combine into an actual system, following the genuine, realistic journey from a single server handling a handful of users to an architecture serving millions, with the exact same memory-hierarchy principle from Post 1 reappearing at every single layer.
Design Patterns: The Patterns Every Developer Actually Uses
Across seventeen posts, several recurring solution shapes have appeared without ever being named — a database's single connection pool, an event system notifying multiple listeners, a sort function swappable at runtime. This post names them directly, using this series' own data structures and algorithms as the concrete, already-familiar examples.
Compilers and Interpreters: How Code Becomes Execution
Post 1 established that a CPU only understands raw binary machine instructions. Every post since has used readable, human-written code. This is the post that bridges that entire gap — lexing, parsing, compilation, interpretation, and the bytecode-plus-VM hybrid approach that Python, and much of the modern software you use daily, actually relies on.
Computer Science in 2026: AI, Quantum, and the Next Decade
This series opened with a CPU's fetch-decode-execute cycle and closes on the same idea, applied to the systems training and running the AI models covered elsewhere on this blog. The final post looks at how these twenty posts' fundamentals actually underlie the AI landscape, gives quantum computing an honest, hedged look, and closes out the complete series.
Join our newsletter!
Get the latest developer guides, tutorials, and tips delivered straight to your inbox.