Skip to content

Volume ITechnology

0.3 — Notation and Conventions ​

Ever seen a symbol in the middle of a page and thought, "wait, what does that mean?" This page is where you look it up.

You do not need to read it now. Every symbol and unit below is also explained the first time it appears in a chapter. This page just gathers them in one place, so you can find them again later.

1. Mathematical notation ​

Asymptotic notation describes how fast something grows as its input gets bigger. Chapter 4.1 builds it from scratch.

SymbolRead asMeans
O(f(n))"big O of f"Grows at most as fast as f (an upper bound)
\Omega(f(n))"big omega"Grows at least as fast as f (a lower bound)
\Theta(f(n))"big theta"Grows exactly like f (both bounds)
o(f(n))"little o"Grows strictly slower than f

In everyday engineering talk, people say "O(n \log n)" even when they mean the tight bound, which is really \Theta. This book follows that habit. It says so whenever the difference matters.

The growth ladder, from best to worst: O(1), O(\log n), O(n), O(n \log n), O(n^2), O(n^3), O(2^n), O(n!).

Logarithms. \log_b x is the power you raise b to in order to get x. For example, \log_2 8 = 3, because 2 \times 2 \times 2 = 8.

In algorithm analysis we leave out the base. Changing the base only multiplies the answer by a fixed number, and big-O notation ignores fixed multipliers. So \log n just means "roughly how many times you can halve n." In information theory (Chapter 1.8) the base is 2, and there it does matter.

Common symbols:

SymbolMeaning
\sum_{i=1}^{n} x_iAdd up x_1 through x_n
\prodMultiply a list of numbers
\lfloor x \rfloor / \lceil x \rceilRound down / round up
x \bmod mThe remainder after dividing x by m
\lvert S \rvertThe size of a set, or an absolute value
\in"Is a member of"
\cup, \capUnion (everything in either), intersection (only what is in both)
\approxApproximately equal
\ll, \ggMuch less than, much greater than
\equivEquivalent, or the same remainder modulo something
\oplusExclusive or (true when exactly one side is true)

Probability and statistics (Chapters 12.2 and 12.3). P(A) is the probability of A. P(A \mid B) is the probability of A given that B happened. E[X] is the expected value, which is the average you would get over many trials. \mu is the mean and \sigma is the standard deviation, which measures how spread out the values are.

Percentiles are written p50, p95 and p99. p99 means that 99% of observations are at or below this value. It is the number engineers watch in performance work (Chapter 15.5), because it shows how bad the slow cases are.

2. Units ​

Data sizes. Two systems exist side by side, and mixing them up causes real confusion (Chapter 1.3).

DecimalValueBinaryValue
kB10^3KiB2^{10} = 1,024
MB10^6MiB2^{20}
GB10^9GiB2^{30}
TB10^{12}TiB2^{40}

Disk makers count in decimal. Many operating systems report in binary. That is why a "1 TB" disk shows up as about 931 GiB. Neither is wrong. They are different units. This book writes GB for decimal and GiB when it means binary.

A bit is written b and a byte is written B. A byte is 8 bits. Network speeds use bits per second (Mbps) and file sizes use bytes. So a 100 Mbps link moves about 12.5 MB per second, before overhead.

Time. A millisecond (ms) is a thousandth of a second. A microsecond (µs) is a millionth. A nanosecond (ns) is a billionth.

Latency numbers worth knowing. These are rough sizes, not exact figures (Chapters 1.6 and 10.12).

OperationAbout how long
CPU cache reference1 ns
Main memory reference100 ns
SSD random read100 µs
Round trip inside a data centre0.5 ms
Disk seek (spinning disk)10 ms
Round trip between continents150 ms

The ratios matter more than the exact numbers. Main memory is roughly a thousand times faster than an SSD read. A trip across continents takes roughly a million times longer than one memory access. Many of the design choices in this volume follow from that one table.

3. Code conventions ​

TypeScript is the main language in Volume I. A chapter switches to Python, SQL, Bash or another language when its subject needs one.

Every code snippet sits inside a real situation, such as an order, a checkout or an upload. You will not see foo and bar.

Numbered markers unpack the code. Here is how they look:

ts
const iv = randomBytes(12);                    // (1)
const cipher = createCipheriv('aes-256-gcm', key, iv);

The text right below a snippet walks through each numbered line in order. For (1) it says what the line does, and why it is there.

When behaviour matters, the page says what the code prints, throws or returns.

Highlighted lines show the part that matters most. Red and amber lines mark wrong and risky code. Some snippets come as a tabbed pair, such as before and after, or two languages side by side.

Code blocks are always dark, in both the light and dark site themes.

4. Page markup ​

Marked keywords look like this. They flag the exact term that an interviewer or a specification would use. A page has only a handful of them. They help you find the key words quickly. They are not for emphasis.

Bold marks the sentence to remember from a paragraph.

The recall box closes pages that matter for interviews. It has a short summary and a few self-test questions. Come back to it after a gap and try to rebuild the chapter from it (see Chapter 0.2).

"What the interviewer will push on" appears on chapters that interviewers really ask about. For each follow-up question, it says what the interviewer is checking, how a real answer differs from a memorised one, and one useful thing to say even if nobody asks.

Cross-references such as "Chapter 7.3.2" become links when the chapter exists.

Every chapter ends with a "Next" line. It names the problem the following chapter solves, the one this chapter left open.

5. Diagrams ​

In Volume I, every figure is drawn in the page itself, so it works offline and matches the site theme. Later volumes also use photographs and diagrams from Wikimedia Commons.

Each figure is introduced in the text before it appears, and explained after. It also has a caption. No figure stands alone.

The colours mean the same thing on every page. Knowing them helps you read a diagram quickly:

ColourUsually means
BlueThe main subject, the request path, the client
GreenA correct or successful path, the server, storage
AmberA secondary system, a queue, a warning
RedA failure, an attacker, the thing that goes wrong
PurpleA control plane, a coordinator, a derived result
CyanSupporting detail, a cache, a neutral component

Steps are numbered ①②③ when order matters. Arrows are curved so that they look like motion. A complex mechanism is drawn as two to four small panels, such as before, during and after, instead of one crowded figure.

6. Spelling and terminology ​

The prose uses British spelling, such as behaviour, serialise and normalisation. Code keeps its real spelling, such as serializeUser and Color, because those are the actual names.

In code, money is stored as a whole number of the smallest unit, such as total_minor for pence or cents. In prose it is written normally, like £24.99. Chapter 9.7.29 explains why decimals are never used for money.

Times and dates use UTC and the ISO 8601 format, like 2026-08-02T14:22:10Z. A chapter about local time is the only exception.

Product and company names appear only in chapters about them. Elsewhere the book names what a thing does, so that a page does not go out of date when a product is renamed.

Every acronym is spelled out the first time it appears in a chapter, even if an earlier chapter did it already, because people read chapters out of order.

7. What this book does not contain ​

  • No testing content. There are no unit-testing chapters and no test-code snippets. Design points about structure stay, because they teach design.
  • No preamble. A page starts with the material itself: a real situation, a problem or a plain definition. It does not start by describing the page.
  • No unexplained examples. Every example uses only things the book has already taught, or things from ordinary life. If a tool or term is named, it is explained in a sentence right there, or it is not used.
  • No invented terms. If the industry has no name for something, the book describes it in ordinary words.
  • No unchecked claims. Figures, dates and specification references are verified, or marked as illustrative.

Recall

  • O is an upper bound, \Omega is a lower bound, and \Theta is both. People often say O when they mean \Theta. The growth ladder is 1 < \log n < n < n\log n < n^2 < 2^n < n!. The log base is dropped because it only changes the answer by a fixed multiplier.
  • kB is 10^3 and KiB is 2^{10}. That is why a 1 TB disk shows as about 931 GiB. b is a bit and B is a byte, so 100 Mbps is about 12.5 MB per second.
  • The latency table is about ratios. Memory is about 100 ns, an SSD about 100 µs, a data-centre round trip about 0.5 ms, and a trip across continents about 150 ms. Many design choices follow from it.
  • Code is TypeScript inside a real situation, with numbered markers explained below the snippet, and the output stated.
  • Marked keywords are the exact terms to know. Recall boxes and "What the interviewer will push on" sections appear where interview weight is real.
  • Figures are introduced before and explained after. Colours keep their meaning: blue for the subject, green for success, amber for secondary, red for failure, purple for control, cyan for support.
  • Prose uses British spelling and code keeps its real spelling. Money is stored as whole minor units, and times are UTC in ISO 8601.

Self-test: What does \Theta say that O does not? · Why is the logarithm's base left out in complexity? · How many GiB is a 1 TB disk, and why? · How many orders of magnitude separate memory from an SSD? · What does a numbered marker in a snippet promise? · What does a red element in a figure usually mean?

Combine chapters into one PDF

Pick the chapters you want. They print in the order you pick them.

Volume I — Technology
Part 0 — Retention & Notation
Part 1 — Foundations of Computation
Part 2 — Operating Systems
2.1 The Kernel
2.2 Processes
2.3 Threads & Scheduling
2.4 Concurrency Under the Hood
2.5 Memory Management
2.6 File Systems
2.7 Input/Output
2.8 Linux for Engineers
2.9 Windows & macOS in Practice
Part 3 — Languages, Compilers & Runtimes
3.6 JavaScript & V8
3.7 TypeScript
3.8 Node.js Internals
3.13 Python & CPython
3.14 FastAPI & Production Python
Part 4 — Data Structures & Algorithms
4.0 Classic Problems — Before NeetCode
4.4 Arrays & Hashing — Problems
4.5 Two Pointers
4.6 Sliding Window
4.8 Stack — Problems
4.9 Linked List — Problems
4.11 Binary Search — Problems
4.13 Trees
4.14 Tree — Problems
4.15 Trie — Problems
4.17 Heap — Problems
4.18 Backtracking — Problems
4.19 Graphs
4.20 Graph — Problems
4.21 Advanced Graph — Problems
4.23 1-D DP — Problems
4.24 2-D DP — Problems
4.26 Greedy — Problems
4.27 Interval — Problems
4.28 Math & Geometry — Problems
4.30 Bit Manipulation — Problems
Part 5 — Networking & the Web
5.3 IP
5.4 Transport
5.6 HTTP
Part 6 — Frontend Engineering
6.1 Browser Internals
6.2 HTML & CSS Mastery
6.3 JavaScript in the Browser
6.4 React, from First Component to Full Shop
6.5 Frameworks & Rendering
6.8 UI Engineering & Patterns
Part 7 — Databases & Storage
7.2 SQL Mastery
7.3 Storage Engine Internals
7.4 Transactions
7.5 NoSQL Taxonomy
7.8 Analytics & Big Data
Part 8 — Security, Identity & Cryptography
8.2 Cryptography
8.3 Protocols of Trust
8.4 Identity: AuthN & AuthZ
8.5 Application Security
8.6 Infrastructure Security
Part 9 — Software Design (LLD)
9.2 OOP Foundations
9.3 Design Principles
9.4 Design Patterns
9.5 Concurrency
9.6 API Design
9.7 LLD Interview Machines
9.9 Node/Express Production Playbook
Part 10 — Distributed Systems & HLD
10.7 Consistency & Consensus
10.8 Messaging & Microservices
10.14 Caching
Building blocks from the design seat
Part 11 — System Design Case Studies
Part 12 — AI & ML Engineering
12.1 What AI Engineering Is
12.2 The Math You Need
12.3 Classical Machine Learning
12.4 Data for ML
12.5 Deep Learning
12.6 Embeddings & Vector Search
12.7 Transformers & LLMs
12.8 Building with LLMs
12.9 Retrieval-Augmented Generation
12.10 Agents
12.11 Adapting Models
12.12 Production AI
12.13 Multimodal AI
12.14 AI Security & Governance
12.15 Case Studies & Capstone
Part 13 — Cloud, DevOps & Infrastructure
13.11 Git, from First Commit to Team Workflow
Part 14 — Containers: Docker & Kubernetes
14.1 Foundations
14.2 Docker
14.3 Kubernetes
14.4 Kubernetes on Azure
Part 15 — The Craft & Career
Nothing picked yet