Books Deep-Read

Ch 1Introduction and Overview — the seven-step framework: the hard part is never the model, it's the translation and the online proofAminian & Xu · 2023 Ch 2Visual Search System — the secret isn't teaching a machine to understand pictures, it's turning each one into a vector so that "alike" becomes "nearby"Aminian & Xu · 2023 Ch 3Google Street View Blurring — a missed face is a privacy incident, an over-blurred sign is just an ugly photo, so you skew the threshold on purposeAminian & Xu · 2023 Ch 4YouTube Video Search — half the job needs no model: an inverted index and vector retrieval run as two parallel paths with complementary failure modesAminian & Xu · 2023 Ch 5Harmful Content Detection — the image is fine and the caption is fine but together they aren't: fusion must happen early, and the model scores rather than rulesAminian & Xu · 2023 Ch 6Video Recommendation System — a billion candidates against tens of milliseconds forces the retrieval–ranking–rerank funnelAminian & Xu · 2023 Ch 7Event Recommendation System — events expire in days and list with zero interactions, so cold start is the steady state and the work moves from model to featuresAminian & Xu · 2023 Ch 8Ad Click Prediction on Social Platforms — the score gets billed against, so getting the order right isn't enough: the probability itself must be honestAminian & Xu · 2023 Ch 9Similar Listings on Vacation Rental Platforms — don't define similarity; let session co-occurrence define it, with an attribute fallback for cold startAminian & Xu · 2023 Ch 10Personalized News Feed — six or seven heads collapse into one score; the model only gets the probabilities right, the weights decide what the product becomesAminian & Xu · 2023 Ch 11People You May Know — the hard part is not model accuracy, it is cutting a billion people down to ten thousand candidatesAminian & Xu · 2023 Ch 1Introduction and Overview — the seven steps, and three rules that broke: no answer key, cost per token, failure that sounds fluentAminian et al. · 2024 Ch 2Gmail Smart Compose — the latency budget moves first, pinning model size, decoding width, even whether to speak at allAminian et al. · 2024 Ch 3Google Translate — one model for a hundred-plus languages, where the sampling mix is a zero-sum dial and BLEU cannot measure qualityAminian et al. · 2024 Ch 4ChatGPT personal assistant — when good cannot be a loss function, turn human pairwise comparisons into a scorer you can optimiseAminian et al. · 2024 Ch 5Image Captioning — the vision half is solved off the shelf; nobody can say what "described it correctly" meansAminian et al. · 2024 Ch 6Retrieval-Augmented Generation — the real output is not an answer but an evidence trail you can click back and checkAminian et al. · 2024 Ch 7Realistic Face Generation — when "looks real" cannot be written as a formula, you train a second network to be the yardstickAminian et al. · 2024 Ch 8High-Resolution Image Synthesis — move the hundreds of denoising steps onto a 64×64 scratchpad and the compute finally dropsAminian et al. · 2024 Ch 9Text-to-Image Generation — cross-attention threads the sentence through every layer; painting twice and extrapolating the gap turns obedience into a live dialAminian et al. · 2024 Ch 10Personalized Headshot Generation — a face is the one condition no prompt can carry, so it must be taught from samples by an adapter that deletes cleanlyAminian et al. · 2024 Ch 11Text-to-Video Generation — temporal consistency must live inside the model; the exploding compute is only affordable in stages: sketch low-res, add frames, scale upAminian et al. · 2024 Ch 1Reliable, Scalable, Maintainable — set three yardsticks and make "is this system good?" measurable with load parameters and response-time percentilesKleppmann · 2017 Ch 2Data Models & Query Languages — what relational, document and graph are each good at, and why declarative beats imperativeKleppmann · 2017 Ch 3Storage & Retrieval — how databases store and find data: LSM-trees vs B-trees, row-oriented OLTP vs columnar analyticsKleppmann · 2017 Ch 4Encoding & Evolution — how data is serialized and how schemas evolve with forward/backward compatibility, no downtimeKleppmann · 2017 Ch 5Replication — one dataset on many machines: single-leader, multi-leader, leaderless, and the pitfalls of replication lagKleppmann · 2017 Ch 6Partitioning — splitting a dataset too big for one node: by key range or by hash, hotspots and rebalancingKleppmann · 2017 Ch 7Transactions — what ACID actually guarantees, which anomalies weak isolation lets through, and why write skew is the trap to rememberKleppmann · 2017 Ch 8The Trouble with Distributed Systems — partial failures, unreliable clocks, network and process pausesKleppmann · 2017 Ch 9Consistency & Consensus — linearizability, total-order broadcast and consensus, what to really know after CAPKleppmann · 2017 Ch 10Batch Processing — MapReduce's tally-then-total, one distributed sort turning huge immutable input into derived results, recompute on failureKleppmann · 2017 Ch 11Stream Processing — process a never-ending event stream one at a time on a replayable log (Kafka); stream-table duality turns the database inside out, with time and watermarks as the hard partKleppmann · 2017 Ch 12The Future of Data Systems — unbundle the database and reassemble it around one ordered event log; correctness comes end-to-end, not from the layers belowKleppmann · 2017 Ch 1The Problem of Delivering Software — manual deploys and release-day hell; turn releasing into a repeatable pipelineHumble & Farley · 2010 Ch 2Configuration Management — everything under version control, one artifact for every environment, no manual changes to machinesHumble & Farley · 2010 Ch 3Continuous Integration — merge to trunk every day and stop the line when it goes red; CI is a practice, not a toolHumble & Farley · 2010 Ch 4Implementing a Testing Strategy — four quadrants: automate what repeats, leave curiosity to peopleHumble & Farley · 2010 Ch 5Anatomy of the Deployment Pipeline — one automated road from commit to production: build once, stop the line when redHumble & Farley · 2010 Ch 6Build and Deployment Scripting — one script for every environment, idempotent on every run: deploy scripts are production codeHumble & Farley · 2010 Ch 7The Commit Stage — a trustworthy red or green within ten minutes; that budget governs people, not machinesHumble & Farley · 2010 Ch 8Automated Acceptance Testing — separate what to verify from how to click it, or the suite becomes unaffordableHumble & Farley · 2010 Ch 9Testing Non-Functional Requirements — turn fast-enough into a threshold that can go red; a scaled-down environment shows trends, never promisesHumble & Farley · 2010 Ch 10Deploying and Releasing Applications — blue-green and canary make going live revocable; the wall is never the code, it's the dataHumble & Farley · 2010 Ch 11Managing Infrastructure and Environments — only automation builds or changes a machine, from definitions in version control; edit one by hand and it is unreproducibleHumble & Farley · 2010 Ch 12Managing Data — code swaps back to the previous version, data does not; non-destructive migrations and a compatibility window make releases revocable againHumble & Farley · 2010 Ch 13Managing Components and Dependencies — you split to get the build back under ten minutes; the price is losing one-commit-one-verification, bought back with pinned versions and an integration pipelineHumble & Farley · 2010 Ch 14Advanced Version Control — a branch does not isolate risk, it banks it; the enemy is divergence time, not branchesHumble & Farley · 2010 Ch 15Managing Continuous Delivery — the blocker is not the pipeline but who dares approve; to satisfy auditors, add automation, not signaturesHumble & Farley · 2010 Ch 1Introduction — ask a software engineer to design an ops team, then pin it down with a 50% engineering floor and an error budgetGoogle · 2016 Ch 2The Production Environment at Google — Borg, Colossus, Jupiter and Chubby glue tens of thousands of machines into one computer the size of a datacenterGoogle · 2016 Ch 3Embracing Risk — 100% is the wrong target; treat 1 minus the SLO as a budget you spend, ship while it lasts, freeze when it's goneGoogle · 2016 Ch 4Service Level Objectives — pick the right thing to measure before arguing about nines; a good SLO names its window and measurement pointGoogle · 2016 Ch 5Eliminating Toil — the test isn't whether you hate the work but whether it grows linearly; 50% is a ceiling, not a targetGoogle · 2016 Ch 6Monitoring Distributed Systems — the four golden signals as a minimum sufficient set; never page for work a script could doGoogle · 2016 Ch 7The Evolution of Automation at Google — saving time is the weakest reason; bolt-on automation quietly rots, and the endpoint is a system that maintains itselfGoogle · 2016 Ch 8Release Engineering — shipping fast is the result; reproducibility is the foundation, and config needs its own version tooGoogle · 2016 Ch 9Simplicity — reliability is capped by what you can still understand; code is a liability, and the best change is a negative oneGoogle · 2016 Ch 10Practical Alerting from Time-Series Data — not a threshold per machine but an expression over labelled time series: rate, aggregate, ratioGoogle · 2016 Ch 12Effective Troubleshooting — a craft, not a gift: stop the bleeding first, cut from the middle, then ask where the effort goesGoogle · 2016 Ch 15Postmortem Culture: Learning from Failure — chase the conditions, not the person; the output isn't a document, it's action items tracked to closedGoogle · 2016 Ch 17Testing for Reliability — testing changes not how many bugs you have but which gate catches them; the gate sets the repair costGoogle · 2016 Ch 18Software Engineering in SRE — stop handing over “how many machines”; hand over why, and let a solver do the arithmeticGoogle · 2016 Ch 19Load Balancing at the Frontend — DNS only points coarsely and late; what pins a connection is the layer at the door, computing rather than rememberingGoogle · 2016 Ch 20Load Balancing in the Datacenter — “least work in hand” is a contaminated signal: the backend erroring in 1ms looks idlestGoogle · 2016 Ch 21Handling Overload — stop measuring capacity in QPS; take on less on purpose and output holds at the ceilingGoogle · 2016 Ch 22Addressing Cascading Failures — failure breeds; removing the trigger won't bring the system back, you have to cut the loopGoogle · 2016 Ch 23Managing Critical State — heartbeat-and-timeout doesn't avoid consensus, it implements it wrong; take this one off the shelfGoogle · 2016 Ch 24Distributed Periodic Scheduling with Cron — once it leaves one machine, cron cannot have exactly-once; you must pick between skipping and repeatingGoogle · 2016 Ch 25Data Processing Pipelines — the enemy isn't data volume, it's the periodic schedule itself: idle troughs, herd peaks, and a middle you can't monitorGoogle · 2016 Ch 26Data Integrity: What You Read Is What You Wrote — replicas don't protect your data, they just sync the bad delete faster; three lines of defense doGoogle · 2016 Ch 27Reliable Product Launches at Scale — every line on the checklist is an incident's epitaph, and it must shrink or it rots into a rubber stampGoogle · 2016 Ch 33Lessons Learned from Other Industries — almost nothing in SRE was invented by software; the error budget is what doesn't transfer, because a meltdown can't be budgetedGoogle · 2016 Ch 34Conclusion — reliability isn't a virtue but a quantity you can measure, budget and auto-brake on; only the implementation needs the scaleGoogle · 2016 DigestOn-Call and Incident Response — the commander holds no keyboard, one crew changes the system, and every page gets bookedGoogle · 2016 DigestSRE as an Organization — people are the scarce resource: block the interrupts, send a coach not a labourer, and end by making the readiness review itself disappearGoogle · 2016 Ch 1Accelerate — speed and stability aren't a trade-off; improve by finding your weakest capability, not by climbing maturity levelsForsgren et al. · 2018 Ch 2Measuring Performance — stop counting effort; count four outcomes that constrain each other so no side can be won by wrecking the otherForsgren et al. · 2018 Ch 3Measuring and Changing Culture — stop asking what the culture is like; watch whether bad news reaches the person who needs itForsgren et al. · 2018 Ch 4Technical Practices — continuous delivery isn't a pipeline you buy; it's keeping trunk shippable, and who writes the tests separates teams more than whether tests existForsgren et al. · 2018 Ch 5Architecture — stop arguing monolith vs microservices; ask two questions: can you test alone, can you ship aloneForsgren et al. · 2018 Ch 6Integrating Infosec into the Delivery Lifecycle — security isn't a door before release; it's paving the road so the right thing is easier than going aroundForsgren et al. · 2018 Ch 7Management Practices for Software — a WIP limit alone does almost nothing, and external change approval buys delay rather than stabilityForsgren et al. · 2018 Ch 8Product Development — team autonomy over the spec is the sharpest claim, but without customer feedback it only builds the wrong thing fasterForsgren et al. · 2018 Ch 9Making Work Sustainable — don't ask if the team is tired; ask what day and hour they last deployed. Burnout is an output of the environmentForsgren et al. · 2018 Ch 10Employee Satisfaction, Identity, and Engagement — three questions you can actually ask, driven mostly by your engineering practicesForsgren et al. · 2018 Ch 11Leaders and Managers — five measurable dimensions, but leadership creates conditions, not results: weak leadership all but guarantees low performance, strong leadership guarantees nothingForsgren et al. · 2018 Ch 16High-Performance Leadership and Management — leaders only set direction and clear the road; the improving belongs to the people doing the work, and it never shipsForsgren et al. · 2018 DigestThe Research — several items per concept, hypothesis before data, and a claim that stops at “predicts”Forsgren et al. · 2018 Ch 1Introduction and Overview — four layers, then three dials: buffer or not, update in place or append, keep it key-ordered or notPetrov · 2019 Ch 2B-Tree Basics — what you save isn't comparisons, it's trips to disk: pack one page with signposts and 31 levels collapse into 4Petrov · 2019 Ch 3File Formats — the directory keeps the order, the cells lie wherever: an insert shifts 2-byte offsets, not kilobytes of recordsPetrov · 2019 Ch 4Implementing B-Trees — the split algorithm is the easy part; the engineering is elsewhere: breadcrumbs to find the parent, borrow from a sibling, never halve a sequencePetrov · 2019 Ch 5Transaction Processing and Recovery — the log is the master copy, the data files only a fair copy; after a crash, repeat history verbatim before undoing what never finishedPetrov · 2019 Ch 6B-Tree Variants — expensive to change, not to search: every variant dismantles the same assumption, updating in placePetrov · 2019 Ch 7Log-Structured Storage — it never made writing cheaper; it swapped random updates for sequential appends and deferred the bill to compactionPetrov · 2019 Ch 8Introduction and Overview — pin down how reliable the link is, how trustworthy time is and how nodes fail, or every later algorithm stands on sandPetrov · 2019 Ch 9Failure Detection — dead and merely slow are indistinguishable, so emit a tunable suspicion level, not a booleanPetrov · 2019 Ch 10Leader Election — no election can guarantee a single leader, so uniqueness comes from fencing on an epochPetrov · 2019 Ch 11Replication and Consistency — consistency is a contract, not a performance dial; w+r>n buys overlap, not linearizabilityPetrov · 2019 Ch 12Anti-Entropy and Dissemination — the "eventually" is an operating expense; read repair only fixes what gets readPetrov · 2019 Ch 13Distributed Transactions — atomic commitment needs unanimity, not a majority, so 2PC's disease is not latency but locks held while the coordinator is downPetrov · 2019 Ch 14Consensus — a majority exists for set intersection, not for votes, so a decided value can only be repeated, never rewrittenPetrov · 2019 Ch 1Scale From Zero To Millions Of Users — a seven-rung ladder ordered by return, where only the last rung, sharding, cannot be walked backAlex Xu · 2020 Ch 2Back-of-the-Envelope Estimation — three minutes to the right order of magnitude, where the output is a chain of assumptions, not a numberAlex Xu · 2020 Ch 3A Framework for System Design Interviews — four steps that converge a deliberately vague question, where the process is graded, not the diagramAlex Xu · 2020 Ch 4Design a Rate Limiter — five algorithms, separated by one question: does the business tolerate burstsAlex Xu · 2020 Ch 5Design Consistent Hashing — it does not make data more even; it cuts the data you must move on resize from nearly all of it to 1/NAlex Xu · 2020 Ch 6Design a Key-Value Store — once the leader is gone, correctness has to be rebuilt out of quorums, vector clocks and anti-entropyAlex Xu · 2020 Ch 7Design a Unique ID Generator — uniqueness is the easy part; short, time-ordered and coordination-free all at once is notAlex Xu · 2020 Ch 8Design a URL Shortener — the seven-character code is not a guess; it is derived from 365 billion rows over ten yearsAlex Xu · 2020 Ch 9Design a Web Crawler — the hard part is not downloading but queueing; two tiers split "fetch what first" from "overwhelm nobody"Alex Xu · 2020 Ch 10Design a Notification System — the last mile belongs to someone else; all you control is the queue, the idempotency key, and not annoying users into switching it offAlex Xu · 2020 Ch 11Design a News Feed System — print ahead or assemble on arrival; the cost only relocates, and the routing key is the publisherAlex Xu · 2020 Ch 12Design a Chat System — the hard part is receiving, not sending; HTTP cannot be server-initiated, so everything is rebuilt around one long-lived connectionAlex Xu · 2020 Ch 13Design a Search Autocomplete System — it never actually searches; every prefix's answer was written last week, and daytime only fetches itAlex Xu · 2020 Ch 14Design YouTube — playback is the settled part; what you design is a transcoding pipeline that parallelises and a six-figure daily CDN billAlex Xu · 2020 Ch 15Design Google Drive — not a storage system but a sync system; storage is outsourced to the cloud and the hard part is all in the ledgerAlex Xu · 2020 Ch 16The Learning Continues — the questions run out, the reading list doesn't: pair each exercise with one real system's public write-upAlex Xu · 2020 Ch 1Proximity Service — not a search problem but a numbering one: flatten a coordinate pair into a one-dimensional cell id and the index works againXu & Lam · 2022 Ch 2Nearby Friends — not a search problem: the candidate set is already known, so locations are pushed along the friend graph instead of looked upXu & Lam · 2022 Ch 3Design Google Maps — most of it isn't computed live: tiles are baked offline onto a CDN, and only traffic earns real-time computeXu & Lam · 2022 Ch 4Distributed Message Queue — not a megaphone but a ledger: make it an append-only log and partitions, replicas and replay all followXu & Lam · 2022 Ch 5Metrics Monitoring and Alerting System — you think it's a read system for charts; it writes a million points a second, and must never depend on what it watchesXu & Lam · 2022 Ch 6Ad Click Event Aggregation — not a counter but a ledger: the number becomes money, so the fast answer is for people and a nightly recount pays the billXu & Lam · 2022 Ch 7Hotel Reservation System — three bookings a second; the hard part was never traffic, it's two people tapping the last room at onceXu & Lam · 2022 Ch 8Distributed Email Service — the partition key is handed to you: nobody reads someone else's mailbox, so the expensive half of distributed systems never gets boughtXu & Lam · 2022 Ch 9S3-like Object Storage — every power it has was subtracted into existence: give up in-place update and you buy unlimited scale and eleven nines at 1.5x spaceXu & Lam · 2022 Ch 10Real-time Gaming Leaderboard — do the arithmetic first: 5M DAU fits on one Redis node; only when you must shard do you hit it — rank is global, sharding is localizationXu & Lam · 2022 Ch 11Payment System — the lowest-throughput chapter in the book: a timeout is neither success nor failure, and correctness is stacked from idempotency keys, double-entry and daily reconciliationXu & Lam · 2022 Ch 12Digital Wallet — the whole chapter does one thing: delete the mutable balance field and replace it with a log anyone can recomputeXu & Lam · 2022 Ch 13Design a Stock Exchange — the one chapter whose answer is do not distribute: a sequencer stamps the order at the door, one thread inside works strictly by numberXu & Lam · 2022 Ch 1Encountering Complex Systems — failure lives not in a broken part but in the seams between healthy ones; components grow linearly, seams quadraticallyRosenthal & Jones · 2020 Ch 2Navigating Complex Systems — of the three boundaries only safety gives no warning before you cross it, so drift is structural, not negligenceRosenthal & Jones · 2020 Ch 3Overview of Principles — it is experimentation, not testing: five principles that turn “I think it holds up” into a falsifiable hypothesisRosenthal & Jones · 2020 Ch 4Slack's Disasterpiece Theater — for systems never designed to fail, step one isn't a tool but a document, a dry run and a measured abort planRosenthal & Jones · 2020 Ch 5Google DiRT — the redundancy is mostly fine; the real single points are process, documents and people, so the drill breaks people tooRosenthal & Jones · 2020 Ch 6Microsoft: Variation and Prioritization of Experiments — the fault space explodes while the budget is a few dozen, so the craft is ordering, not injectionRosenthal & Jones · 2020 Ch 7LinkedIn: Being Mindful of Members — blast radius is measured in people, so pin the failure to one request and wire every rung to an automatic abortRosenthal & Jones · 2020 Ch 8Capital One: Chaos in a Regulated Industry — regulators want evidence, so start outside production, gate the pipeline on chaos, and trade the records for productionRosenthal & Jones · 2020 Ch 9Creating Foresight — much of an experiment's value comes before injection: make everyone state expectations, and the disagreements are the blind spotsRosenthal & Jones · 2020 Ch 10Humanistic Chaos — the organisation is a distributed system too: people are single points and communication has latency, so probe it with small, stoppable drillsRosenthal & Jones · 2020 Ch 11People in the Loop — the output of a chaos experiment is human understanding: automate the how, keep the why, the when and the meaning with peopleRosenthal & Jones · 2020 Ch 12The Experiment Selection Problem — what to inject is hidden in success: compute minimal failure sets from a request's lineage and test only thoseRosenthal & Jones · 2020 Ch 13The ROI of Chaos Engineering — "nothing happened" is hardest to prove: incident counts get eaten by speed, so build evidence up Kirkpatrick's four levelsRosenthal & Jones · 2020 Ch 14Open Minds, Open Science, and Open Chaos — hit each pothole once: write drills as cards others can rerun, and publish findings like scienceRosenthal & Jones · 2020 Ch 15Chaos Maturity Model — stop counting experiments: plot sophistication × adoption, then push the lagging axisRosenthal & Jones · 2020 Ch 16Continuous Verification — moving chaos from Game Day into the pipeline: auto-selected experiments, control vs experiment, automatic verdicts and abortsRosenthal & Jones · 2020 Ch 17Let's Get Cyber-Physical — when failure can hurt people: FMEA imagines failures on paper, chaos experiments confirm them in simulation and on the benchRosenthal & Jones · 2020 Ch 18HOP Meets Chaos Engineering — human error is a symptom, not a root cause: fix the context, not the person, and let experiments hunt gaps, not culpritsRosenthal & Jones · 2020 Ch 19Chaos Engineering on a Database — database bugs are quiet: inject faults at four layers, then audit against invariants like a conserved bank totalRosenthal & Jones · 2020 Ch 20The Case for Security Chaos Engineering — make a small misconfiguration on purpose and check whether your controls stop it, see it, and handle itRosenthal & Jones · 2020 Ch 21Conclusion — nobody holds the whole system, so reliability comes only from controlled experiments that keep correcting our mental mapsRosenthal & Jones · 2020 Ch 1Data Engineering Described — own the data lifecycle, not a tool, and build the bottom of the pyramid that data science stands onReis & Housley · 2022 Ch 2The Data Engineering Lifecycle — settle each stage's questions before picking tools; batch stays the default, real time must earn its costReis & Housley · 2022 Ch 3Designing Good Data Architecture — keep most decisions reversible; nine principles, and an honest price on warehouse, lake, lakehouse and meshReis & Housley · 2022 Ch 4Choosing Technologies Across the Lifecycle — architecture is strategy, tools are tactics; build only for your edge and price in the cost of leavingReis & Housley · 2022 Ch 5Data Generation in Source Systems — you don't own the source, so stop re-reading the ledger and follow the database log (CDC)Reis & Housley · 2022 Ch 6Storage — a three-layer stack of trade-offs: object storage + columnar files + on-demand compute, and separation is really a hybridReis & Housley · 2022 Ch 7Ingestion — a batch is just a boundary on an unbounded stream: go incremental, and let at-least-once plus idempotency absorb duplicates and late dataReis & Housley · 2022 Ch 8Queries, Modeling, and Transformation — scan less, fix the grain and definitions first, keep history with Type 2, and make transformations rerunnable codeReis & Housley · 2022 Ch 9Serving Data for Analytics, ML, and Reverse ETL — trust breaks once, so ask who uses it, define metrics once, and fit brakes on reverse ETLReis & Housley · 2022 Ch 10Security and Privacy — most breaches are people and process: don't ingest sensitive data you don't need, grant least privilege, and treat encryption as the baselineReis & Housley · 2022 Ch 11The Future of Data Engineering — the cloud absorbs the ops grind while the lifecycle stays; from the batch modern data stack to a live stack looped into the appReis & Housley · 2022 Ch 1It's All About Complexity — understanding is the real ceiling; eliminate what you can, encapsulate the rest, and never stop designingOusterhout · 2021