Resources

Microsoft Research; Hal Berenson, Phil Bernstein, Jim Gray, Jim Melton, Elizabeth O’Neil, Patrick O’Neil; ACM SIGMOD 1995 (1995)

Shows that the ANSI SQL isolation levels, defined by forbidden phenomena, are ambiguous; adds dirty write and lost update; and gives the first careful definition of snapshot isolation, including write skew. Short, foundational and still the basis of most isolation discussions.

Alternatives: arXiv version (cs/0701157)(opens in a new tab)

Google (The Keyword blog) (2022)

A 2022 Google blog post with an engineer’s advice on technical interviews. Treat it as dated, personal advice published by Google, not as a current process specification.

PyTorch tutorials; Vincent Moens

Careful, measured tutorial on what page-locked memory and non-blocking copies really do, the conditions under which a copy can overlap with kernels, why pinning a tensor right before copying it can be slower than a plain copy, and the wrong results that unsynchronized device-to-host copies produce.

arXiv; Kevin Musgrave, Serge Belongie, Ser-Nam Lim; ECCV 2020 (2020)

Re-evaluates deep metric learning methods under matched architectures, embedding sizes and hyperparameter search without test-set feedback, and finds that reported improvements largely disappear. Read it to see exactly which uncontrolled factors inflated earlier comparisons.

Andrej Karpathy's blog; Andrej Karpathy (2019)

A practitioner process for training networks without silent failures: inspect the data, build an end-to-end skeleton with simple baselines, overfit a single batch, then regularize and tune. Its checklist maps directly onto "my model does not learn" questions.

arXiv; Stéphane Ross, Geoffrey J. Gordon, J. Andrew Bagnell; AISTATS 2011 (2011)

Introduces DAgger, which repeatedly collects expert labels on the states the learned policy actually visits, and analyzes why plain behavior cloning suffers from compounding errors. The foundational reference for covariate shift in imitation learning.

UC San Diego (author copy); Mohammad Al-Fares, Alexander Loukissas, Amin Vahdat; ACM SIGCOMM 2008 (2008)

Shows how to build a fat-tree (Clos) data-center fabric with high bisection bandwidth from identical commodity switches, and the addressing and multipath routing it needs. A good starting point for data-center topology questions.

University of Waterloo (author page); Tim Brecht (adapted from Alan Mackworth)

Practitioner advice in the form of a chapter-by-chapter outline of a graduate thesis: thesis statement and hypothesis, motivation, goals, contributions, background, design, evaluation and conclusions. Use it to scope a thesis proposal backwards from what the finished document must show.

The Go Project (go.dev)

The official interactive introduction, organized into Basics, Methods and interfaces, Generics and Concurrency modules with runnable examples and short exercises. The quickest route to writing Go fluently in an interview; do the exercises rather than only reading the slides.

arXiv; Xavier Bouthillier et al.; MLSys 2021 (2021)

Models the whole benchmarking process and shows that data sampling, parameter initialization and hyperparameter choice each move results markedly; recommends randomizing more sources of variation when comparing models. A good reference for "how many seeds and splits?" discussions.

arXiv; Priya Goyal, Piotr Dollár, et al. (2017)

Describes the linear learning-rate scaling rule for growing batch sizes together with a gradual warmup, and reports where the recipe stops working. A concrete reference for how batch size, learning rate and warmup interact; treat the rule as an empirical recipe for its setting.

Brendan Gregg's website; Brendan Gregg

Argues that a benchmark number means little until you have identified what limited it, and shows how to analyze a benchmark while it runs to catch configuration and measurement errors. A compact antidote to run-it-and-report-the-number benchmarking.

arXiv; Evan Miller (2024)

Applies basic statistics to LLM evaluations: standard errors from the central limit theorem, clustered errors when questions are related, paired comparisons between models, variance reduction by resampling answers, and power analysis. A concise reference for reporting eval results honestly.

CoderPad (interview-platform vendor)

A platform partner’s account of a Meta pilot of AI-enabled coding interviews. It describes a specific program, not a universal Meta policy; follow the instructions in your own interview invitation.

Airbnb

Airbnb’s candidate FAQ. It answers general hiring questions; the current technical loop is not fully established from this source.

Jeff Erickson, University of Illinois Urbana-Champaign; Jeff Erickson (2019); 1st edition (June 2019)

A rigorous but readable textbook focused on designing algorithms and arguing that they are correct: recursion, dynamic programming, greedy exchange arguments and graph search. Use single chapters to understand why a technique works; the companion notes cover disjoint sets, proof by induction and solving recurrences.

Jeff Erickson, University of Illinois Urbana-Champaign; Jeff Erickson (2019)

Two chapters of a free algorithms textbook that teach recursion as reduction to smaller instances and backtracking as recursive search over a sequence of decisions, with careful running-time analysis. The companion amortized-analysis notes work through aggregate, accounting and potential arguments.

Princeton University; Robert Sedgewick, Kevin Wayne

Free companion site to the Sedgewick and Wayne textbook, with section summaries, tested Java implementations and exercises. The union-find case study builds from naive versions to weighted quick-union with path compression, and the graph pages pair each algorithm with working code.

Princeton University; Robert Sedgewick, Kevin Wayne

Section pages from the free companion site to the Sedgewick and Wayne textbook, each pairing a concise explanation with tested Java code. The quicksort, priority-queue, search-tree, hash-table and trie sections back the data-structure topics in this curriculum.

Alibaba (GitHub)

Production traces from Alibaba data centers, including co-located online services and batch jobs, GPU clusters for machine-learning workloads, microservice call graphs and microarchitectural contention metrics. Especially relevant for co-location and interference questions.

USENIX; Thanumalayan Sankaranarayana Pillai et al.; OSDI 2014 (2014)

Shows that crash guarantees differ across file systems and configurations and that widely used applications silently depend on ordering and atomicity the file system does not promise. Read it to see why durable-update recipes exist and where real applications got them wrong.

Amazon Jobs

Amazon’s official list of its Leadership Principles, each with a short description. Amazon’s SDE preparation pages tie its behavioral interviews to these principles; use the page to map your own true stories to stated values, not to invent new ones.

Amazon Jobs

Official Amazon preparation page for Software Development Engineer II candidates, covering the technical areas and Leadership Principles-based behavioral preparation.

Amazon Jobs

Official Amazon preparation page for senior (SDE III) candidates; expectations differ from SDE II, notably around system design scope and behavioral depth.

Amazon Jobs

Official Amazon list of technical topics software development candidates should review.

Amazon Web Services

Concrete documentation of a managed queue: standard queues may deliver a message more than once, the visibility timeout governs redelivery, and FIFO queues deduplicate only within a bounded interval. A good example of how narrow "exactly-once" claims are in practice.

University of Wisconsin–Madison (Multifacet project); Mark D. Hill, Michael R. Marty; IEEE Computer, July 2008 (2008)

Short, readable article that restates Amdahl’s law and extends it to symmetric, asymmetric and dynamic multicore designs under a fixed chip budget. Useful for naming what the basic law assumes (fixed work, identical cores, no parallel overhead) and how conclusions change when those assumptions move.

USENIX; Ahmed Alquraan, Hatem Takruri, Mohammed Alfatafta, Samer Al-Kiswany; OSDI 2018 (2018)

Analyzes partition-induced failures across widely used distributed systems: most are catastrophic, many can be triggered by isolating a single node, and many were avoidable through design review or partition testing. Includes a testing framework for injecting partition faults.

PVLDB (VLDB Endowment); Yingjun Wu, Joy Arulraj, Jiexi Lin, Ran Xian, Andrew Pavlo; PVLDB, vol. 10, no. 7 (2017)

Breaks MVCC into design dimensions (concurrency protocol, version storage, garbage collection, index management) and evaluates combinations in one system. Read it for the design-space map and for how the experiments isolate each dimension.

arXiv; Sam McCandlish, Jared Kaplan, et al. (2018)

Introduces the gradient noise scale as a predictor of the critical batch size, beyond which larger batches give diminishing returns per example. Read the definitions and main figures to reason quantitatively about SGD noise and batch-size choices.

PVLDB (VLDB Endowment); Rachael Harding, Dana Van Aken, Andrew Pavlo, Michael Stonebraker; PVLDB, vol. 10, no. 5 (2017)

Compares six distributed concurrency-control protocols, including a deterministic one, in a common framework on cloud machines and identifies how contention, update rate and commit coordination limit scalability. Useful both for its results and as a template for fair protocol comparisons.

USENIX (reprinted with the authors’ permission); Roy Levin, David D. Redell; ACM SIGOPS Operating Systems Review 17(3), 1983 (1983)

Practitioner advice from two program-committee chairs on how they judged systems papers: original ideas, reality of the system, lessons, design choices, context and focus. Old, but still a sharp checklist for asking whether an idea is new and how it relates to prior work.

Anthropic

Anthropic’s careers page with open roles and hiring information.

Anthropic

Anthropic’s published policy on when candidates may and may not use AI tools during the application and interview process.

Apache Flink documentation

Official concept pages on event time versus processing time, watermarks, lateness and windowing, and on keyed state, checkpoint barriers and recovery. They describe one engine, but the vocabulary transfers to other stream processors.

Check note: Not requested: the site's robots.txt disallows automated access to this path.

Apache Software Foundation; 4.3

The official design notes for Kafka: how consumer positions are tracked, what at-most-once, at-least-once and exactly-once mean for producers and consumers, and how idempotent producers and transactions narrow duplicates within Kafka.

Apache Parquet documentation

Describes how a Parquet file is organized into row groups, column chunks and pages with metadata and statistics. A compact real-world example of hybrid columnar layout and of the min/max statistics that let readers skip data.

Apple

Describes Apple software and services teams and areas of work. It provides role context only; it does not describe a universal interview loop.

UC Berkeley (author-hosted PDF); Joseph M. Hellerstein, Michael Stonebraker, James Hamilton; Foundations and Trends in Databases, vol. 1, no. 2 (2007)

A long survey of how real relational systems are assembled: process models, parallelism, the query processor and optimizer, storage and buffer management, and transactional storage with locking and logging. Use it to see how textbook algorithms fit into one system; skim it once, then return to the chapter that matches the topic you are studying.

arXiv; Xiaoying Wang, Changbo Qu, Weiyuan Wu, Jiannan Wang, Qingqing Zhou; PVLDB, vol. 14, no. 9 (arXiv version) (2021)

Evaluates learned single-table cardinality estimators against traditional methods under one setup, including dynamic data, and examines training cost, update handling and unpredictable errors. Essential for an honest view of the learned-estimation debate.

arXiv; Maurizio Ferrari Dacrema, Paolo Cremonesi, Dietmar Jannach; RecSys 2019 (2019)

Attempts to reproduce recently published neural recommendation methods and compares them with carefully tuned simple baselines; only a minority could be reproduced and most of those were beaten by the simple methods. A concrete case study of weak baselines, untuned comparisons and missing artifacts.

CIDR; Andrew Crotty, Viktor Leis, Andrew Pavlo; CIDR 2022 (2022)

Argues, with correctness problems and experiments, why relying on mmap and the OS page cache instead of a DBMS-managed buffer pool causes transactional-safety, I/O-stall, error-handling and scalability issues. Good evidence for a common interview question.

Alternatives: Project page at CMU(opens in a new tab)

W3C Web Accessibility Initiative

W3C guidance for building accessible widgets: design patterns with keyboard interaction tables and working examples (dialogs, menus, tabs, comboboxes and more) plus practice pages on keyboard interfaces and accessible names. Start with Read Me First, which explains why incorrect ARIA is worse than none.

ACM (2020)

ACM policy defining repeatability, reproducibility and replicability (the latter two swapped in version 1.1 to match other sciences) and the badges for available, functional and reusable artifacts and for reproduced and replicated results. The reference vocabulary for artifact evaluation at ACM venues.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

Python Software Foundation (docs.python.org)

Official asyncio documentation. The Coroutines and tasks page covers tasks, task groups, timeouts, cancellation and why you must keep references to tasks; Developing with asyncio explains debug mode and how a blocking call stalls every task on the loop.

SQLite documentation

Walks step by step through how SQLite makes a transaction atomic and durable with a rollback journal, and lists the assumptions it makes about the OS and hardware (what fsync does, sector writes, disks that acknowledge writes early). A concrete case study in reasoning about persistence boundaries.

arXiv; Ashish Vaswani et al.; NeurIPS 2017 (2017)

Introduces the Transformer: scaled dot-product attention, multi-head attention, positional encodings and an encoder-decoder built without recurrence. The baseline vocabulary for every later LLM paper.

Amazon Builders' Library; David Yanacek

Covers how queue-based systems fall so far behind that they cannot recover, and the countermeasures: measuring backlog age, isolating tenants, prioritizing fresh work and bounding retries. Useful for job-scheduler and fan-out designs.

Alternatives: Official PDF version(opens in a new tab)

arXiv; Ji Lin et al.; MLSys 2024 (2023)

Weight-only quantization that identifies salient weight channels from activation statistics and protects them with per-channel scaling instead of keeping them in higher precision, without backpropagation. Also discusses the kernels needed to turn smaller weights into faster decoding.

Amazon Web Services

Official description of the init, invoke and shutdown phases of a Lambda execution environment, what happens during a cold start, and the platform features meant to reduce cold-start latency. A concrete production view to compare with the research papers.

Microsoft Azure and Microsoft Research (GitHub)

Collection of sanitized Azure traces with documentation per dataset: VM workloads, a VM packing trace, Azure Functions invocations, LLM inference request traces with token counts, and benchmark noise data. Each dataset page names the paper it accompanies, which you should read before drawing conclusions.

IETF Datatracker; Neal Cardwell, Ian Swett, Joseph Beshay

Working-group draft specifying the current version of BBR (BBRv3), with its path model, state machine and use of the packet loss rate. Use it to state precisely which BBR version a result applies to; the original 2016 article describes BBRv1.

Google Research; Neal Cardwell, Yuchung Cheng, C. Stephen Gunn, Soheil Hassas Yeganeh, Van Jacobson; ACM Queue, vol. 14, 2016 (2016)

Introduces BBR, which estimates bottleneck bandwidth and round-trip propagation time instead of treating loss as the congestion signal. Read it as a design argument plus deployment observations; later independent studies examined fairness and buffer-dependent behavior across versions.

beej.us (author site); Brian "Beej Jorgensen" Hall

Long-standing free guide to the BSD sockets API in C: addresses, socket, bind, listen, accept, connect, send and recv, blocking versus non-blocking sockets and poll. Write the examples yourself rather than reading them.

GitHub (CMU Database Group)

JDBC-based framework (the successor of OLTP-Bench) that runs implementations of TPC-C, YCSB and other workloads against many relational databases with controlled rates and mixes. Useful for reproducible OLTP experiments without writing a load generator.

arXiv; Ryan Marcus, Andreas Kipf, Alexander van Renen, et al.; arXiv preprint (2020) (2020)

Compares tuned learned index structures with strong traditional baselines on several real datasets and analyzes why learned structures win where they do (read-only, in-memory lookups over sorted arrays). The counterweight to reading the original learned-index paper alone.

UC Berkeley

Graduate deep-RL course with public slides and homework handouts covering imitation learning, policy gradients, actor-critic, value-based and model-based RL. Its behavioral-cloning lectures and imitation-learning homework are a practical entry point to robot learning.

UC Berkeley CS186

Concise, free course notes covering SQL, storage, B+ trees, sorting and hashing, join costs, query optimization, concurrency control, recovery, parallel query processing and distributed transactions, with worked examples and, in most notes, practice questions with solutions. A good second explanation next to the CMU lecture notes, especially for I/O cost arithmetic.

arXiv; Jacob Devlin, Ming-Wei Chang, Kenton Lee, Kristina Toutanova; NAACL 2019 (2018)

Introduces masked-language-model pretraining for a bidirectional transformer encoder, followed by task-specific fine-tuning. Read it to contrast the masked objective with next-token prediction and to see why encoder models still underpin many embedding and reranking systems.

Swarthmore College (author copy); Ranysha Ware, Matthew K. Mukerjee, Srinivasan Seshan, Justine Sherry; ACM HotNets 2019 (2019)

Position paper arguing that new congestion-control algorithms should be judged by the harm they cause to existing traffic rather than by equal shares. Useful for choosing and defending fairness metrics in an evaluation.

Internet Systems Consortium (BIND 9 documentation)

Official manual pages for the BIND tools, including dig. Use the dig page for query options such as +trace, +norecurse and choosing which server to ask.

Stanford University (author page); Sean Eron Anderson

A long-standing catalogue of bit-level tricks for C, such as power-of-two tests, counting and reversing bits, and sign manipulation. Use it as a pattern reference and verify each trick with your own tests; many assume fixed-width unsigned arithmetic that does not carry over to Python.

Google Research; Brendan Burns, Brian Grant, David Oppenheimer, Eric Brewer, John Wilkes; ACM Queue, vol. 14, 2016 (2016)

Design lessons from three generations of container managers: why pods, labels, a uniform API and independent reconciling controllers replaced a monolithic master. Explains the reasoning behind Kubernetes rather than its commands.

martinfowler.com; Martin Fowler (2014)

Short explanation of the domain-driven design practice of dividing a large domain model into bounded contexts, each internally consistent, with explicit relationships between them. Useful vocabulary for discussing data ownership across teams and services.

ACM Queue; Jim Gettys, Kathleen Nichols (2011)

Accessible article on bufferbloat: oversized, persistently full buffers in home routers and access links that add large delays without adding throughput. Read it for the mechanism and the motivation for AQM.

Check note: Not requested: the site's robots.txt disallows automated access to this path.

Anthropic Engineering

Practitioner guidance distinguishing predefined workflows (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) from autonomous agents, and arguing for the simplest pattern that works.

Standard C++ Foundation (isocpp.github.io); Bjarne Stroustrup, Herb Sutter (editors)

A large, continuously maintained set of rules for modern C++, each with a reason, examples and enforcement notes. Use it by rule number for ownership, lifetime, class design and concurrency questions rather than reading it front to back.

Amazon Builders' Library; Matt Brinkley, Jas Chhabra

Practitioner guidance on local versus external caches, choosing TTLs, negative caching, cold caches after deploys, and the danger of a service silently depending on its hit rate to stay within capacity.

Alternatives: Official PDF version(opens in a new tab)

Yale University (author-hosted PDF); Alexander Thomson, Thaddeus Diamond, Shu-Chun Weng, Kun Ren, Philip Shao, Daniel J. Abadi; ACM SIGMOD 2012 (2012)

Deterministic transaction processing: replicate and order transaction inputs first, then execute them in that order on every replica, which removes the need for two-phase commit at commit time. Read it as the main contrast to Spanner’s clock-based approach, paying attention to the requirement to know read and write sets.

Alternatives: Copy on Daniel Abadi’s UMD page(opens in a new tab)

USENIX; Anthony Rebello et al.; USENIX ATC 2020 (2020)

Studies how file systems behave after an fsync failure and how several applications, including databases, react, finding cases of data loss and corruption. Read it to see how durability assumptions in logging protocols can fail underneath them.

Google (free online edition); Betsy Beyer, Niall Richard Murphy, David K. Rensin, Kent Kawahara, Stephen Thorne (eds.) (2018)

Practical chapter on canarying: how it fits into release engineering, choosing and evaluating metrics, comparing a canary with a control population, dependencies and isolation, and canarying non-interactive systems. Read it before designing any progressive rollout.

refactoring.com (martinfowler.com); Martin Fowler

Online index of named, behavior-preserving transformations from Fowler’s Refactoring. Useful for planning a restructuring as a sequence of small, testable steps and for naming what you are doing in a review or interview.

The Linux Kernel documentation (docs.kernel.org)

Kernel documentation for container resource control. The main page explains CPU quota and period, throttling statistics and the caveats for multithreaded groups; the linked cgroup v2 specification defines the CPU, memory, I/O and PID controllers and every interface file. Use them to state precisely what cpu.weight, cpu.max, memory.high and memory.max do and where throttling and OOM kills are counted.

Amazon Builders' Library; Jacob Gabrielson

Decomposes one request-reply exchange into its separate steps, shows that each can fail independently, and stresses the outcome where the caller cannot know whether the server acted. A good template for failure-mode tables.

Alternatives: Official PDF version(opens in a new tab)

arXiv; Ali Basiri, Niosha Behnam, Ruud de Rooij, Lorin Hochstein, Luke Kosewski, Justin Reynolds, Casey Rosenthal; IEEE Software, 2016 (2016)

Describes chaos engineering as controlled experimentation on a production distributed system: define steady state, hypothesize it continues, introduce real-world events, and automate the experiments. Pair it with the community principles page for a concise checklist.

Google (developer.chrome.com)

Step-by-step tutorial for recording and reading a Performance panel trace: CPU throttling, the main-thread flame chart, warnings on long tasks and forced reflows. The features reference and the Lighthouse introduction cover the remaining measurement tools.

Citadel

Citadel/Citadel Securities description of its campus engineering interview process.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

LLVM Project (clang.llvm.org)

Official documentation for the runtime checkers that turn silent undefined behavior, memory errors and data races into reports with stack traces. Use it to learn the -fsanitize flags, what each checker detects and what it cannot detect.

Cloudflare

Cloudflare’s careers page with roles and hiring information.

Carnegie Mellon University Database Group

Database internals course with public lecture videos and slides on storage, buffer pools, indexes, query execution, optimization, concurrency control and recovery. Its BusTub projects (buffer pool, index, execution, concurrency control) are excellent implementation practice.

Carnegie Mellon University Database Group

Graduate course on modern analytical database internals: storage formats, vectorized and compiled execution, scheduling, joins, optimizers and system case studies, with a paper reading list. Use it for database research preparation after 15-445-level foundations.

CNCF TAG App Delivery

Vendor-neutral description of internal platforms: what capabilities they offer, treating the platform as a product for internal users, self-service interfaces and how to measure success. Good vocabulary for platform-engineering conversations.

University of Maryland (author-hosted PDF); Daniel J. Abadi, Samuel R. Madden, Nabil Hachem; ACM SIGMOD 2008 (2008)

Asks whether a row store can imitate a column store through physical design, and which column-store techniques (compression, late materialization, block iteration, invisible joins) account for the difference. A good example of an ablation-style systems evaluation.

CSES; Antti Laaksonen (2018)

A compact, implementation-oriented book with C++ examples. Its chapters on greedy algorithms, dynamic programming, bit manipulation and graph algorithms give short, code-level explanations; it is contest-oriented, so pair it with a course for proofs and with interview practice for communication.

CSES; Antti Laaksonen (2018)

A compact, implementation-oriented book with C++ examples. Its short sections on the two-pointer method, nearest smaller elements, the sliding-window minimum, prefix sums and difference arrays explain the amortized patterns in this curriculum together with the argument for why each is linear.

Systems Approach (open online edition); Larry Peterson, Bruce Davie; Open online edition; section numbers as shown on the site

Free, continuously updated edition of a standard networking textbook (listed as an optional text by Stanford CS144). Each section pairs a mechanism with the design reasoning behind it; read the linked sections per topic rather than cover to cover.

arXiv; Dario Amodei, Chris Olah, Jacob Steinhardt, Paul Christiano, John Schulman, Dan Mané (2016)

Frames practical safety research problems: negative side effects, reward hacking, scalable oversight, safe exploration and robustness to distribution shift. A short conceptual map that gives shared vocabulary for alignment-evaluation discussions.

Lawrence Berkeley National Laboratory (author copy); Van Jacobson, Michael J. Karels; ACM SIGCOMM 1988 (revised version, November 1988) (1988)

The paper that introduced slow start, RTT-variance-based retransmission timeouts and AIMD congestion avoidance after the congestion collapses of the mid-1980s. Read it for the conservation-of-packets argument that still frames congestion control.

arXiv; Jim Gray, Leslie Lamport; arXiv preprint (published in ACM TODS, 2006) (2004)

Explains why two-phase commit blocks when the coordinator fails and presents Paxos Commit, which runs consensus on each participant’s vote. The clearest bridge between atomic commit and consensus.

Jepsen; Kyle Kingsbury

A map of consistency models ordered by strength, with one short page per model saying what it allows and whether it can remain available during a partition. Use it to place linearizability, serializability, strict serializability, causal consistency and the session guarantees relative to each other.

University of Maryland (author copy); Daniel J. Abadi; IEEE Computer, vol. 45, 2012 (2012)

Introduces the PACELC framing: beyond the partition-time choice between availability and consistency, replicated systems trade latency against consistency in normal operation. Useful for explaining why systems weaken consistency even when the network is healthy.

martinfowler.com; Ian Robinson (2006)

Introduces consumer-driven contracts: each consumer states the parts of a provider’s interface it relies on, and the provider checks itself against those expectations so it can evolve without breaking them. The conceptual basis of today’s contract-testing tools.

ACM Queue; Kathleen Nichols, Van Jacobson (2012)

Introduces CoDel by separating queues that absorb bursts from standing queues that only add delay, and controls the latter using packet sojourn time. A model of reasoning from queue dynamics to a mechanism.

Check note: Not requested: the site's robots.txt disallows automated access to this path.

arXiv; Charlie Curtsinger, Emery D. Berger; SOSP 2015 (2015)

Causal profiling runs virtual-speedup experiments, slowing everything else down to estimate how much end-to-end throughput or latency would improve if one code region were faster. Read it to understand why the hottest code is not always the code that matters.

Google Research; Xiao Zhang, Eric Tune, Robert Hagmann, Rohit Jnagal, Vrigo Gokhale, John Wilkes; EuroSys 2013 (2013)

Uses cycles-per-instruction measurements from hardware counters to notice when a task is slowed by interference in shared caches or memory, identify likely antagonists and throttle them. A concrete answer to "how would you detect and handle a noisy neighbor?"

cppreference.com

Community-maintained reference that tracks the C++ standard closely. The container pages state complexity guarantees and per-operation iterator-invalidation rules; read them with the std::sort, std::priority_queue and std::lower_bound pages if C++ is your interview language.

cppreference.com (community-maintained reference)

The most precise freely available reference for the C++ language and standard library, organized by feature and annotated by standard version. Treat the pages below as ground truth for lifetime, move, ownership, container invalidation, undefined behavior and atomics questions.

Stanford University (CS229 section notes); Arian Maleki, Tom Do

Compact refresher on probability spaces, random variables, expectation, variance, covariance, joint and conditional distributions and the common distributions. Read it in one sitting with the CS229 linear algebra review before redoing likelihood-based derivations.

NVIDIA Documentation

Practical guide organized around assessing, parallelizing, optimizing and deploying GPU code. Its memory-optimization chapter (pinned memory, overlapping transfers with computation, coalesced access, shared memory) and its occupancy discussion are the parts most relevant to ML systems work.

NVIDIA Documentation

The reference description of the CUDA programming model: grids, thread blocks and warps, the memory hierarchy, streams and asynchronous execution, multi-GPU systems and CUDA Graphs. Read the programming-model chapter for vocabulary and use the rest as reference when a profiler trace raises a question.

MIT CSAIL (author copy); Mohammad Alizadeh, Albert Greenberg, David A. Maltz, Jitendra Padhye, Parveen Patel, Balaji Prabhakar, Sudipta Sengupta, Murari Sridharan; ACM SIGCOMM 2010 (2010)

Characterizes data-center traffic and its impairments (incast, queue buildup, buffer pressure), then proposes ECN marking at a queue threshold with a sender that reduces its window in proportion to the fraction of marked packets. Combines measurement, analysis and testbed evaluation.

Chip Huyen's blog (practitioner); Chip Huyen (2022)

Long practitioner essay on why deployed models degrade: covariate, label and concept shift, how to detect shifts statistically, and what to monitor when labels arrive late or never. A good bridge from textbook definitions of shift to operational practice.

The Go Project (go.dev)

How to run the race detector with go test -race, how to read its reports, and a catalogue of typical races such as loop-counter capture and unsynchronized send and close. It only reports races on code paths that actually execute, so realistic test coverage matters.

Databricks (2025)

Databricks’ April 2025 engineering interview preparation PDF, including guidance on systems-programming and database-specific assessments.

Databricks

Databricks’ official interview preparation hub linking role-specific guides.

Schloss Dagstuhl – Leibniz Center for Informatics

Open bibliography of computer science venues and authors. Use it to list a venue’s proceedings by year, read a lab’s or author’s complete publication record and check for closely related work before claiming novelty.

Check note: Not requested: the site's robots.txt disallows automated access to this path.

arXiv; Ilya Loshchilov, Frank Hutter; ICLR 2019 (2017)

Shows that an L2 penalty and weight decay stop being equivalent under adaptive optimizers such as Adam, and proposes applying the decay directly to the weights (AdamW). Read the introduction and method to explain why AdamW became the usual choice for transformer training.

MIT Press (free online edition at deeplearningbook.org); Ian Goodfellow, Yoshua Bengio, Aaron Courville (2016)

Standard deep-learning textbook. Its applied-math chapters and its chapters on regularization, optimization and practical methodology remain solid references; it predates transformers and current LLM practice, so use newer material for those.

Google Research on GitHub (not an officially supported Google product); Varun Godbole, George E. Dahl, Justin Gilmer, Christopher J. Shallue, Zachary Nado (2023)

Systematic guidance on choosing an architecture, optimizer, batch size and initial configuration, then running incremental, hypothesis-driven tuning experiments. Useful for explaining how you would tune under a fixed compute budget instead of listing hyperparameters.

arXiv; Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, David Meger; AAAI 2018 (2017)

Shows how random seeds, hyperparameters, environment details and codebase differences change deep-RL results, and recommends reporting practices and significance testing. Essential context for RL claims and a vivid general demonstration of seed variance.

arXiv; Edoardo Debenedetti et al. (2025)

Proposes CaMeL, a system layer that extracts control and data flow from the trusted user query so untrusted tool data cannot change the program flow, and uses capabilities to enforce policies on what data may reach which tool calls. Read it as a systems-security answer to injection rather than a better prompt.

Cornell University (author copy); Bowen Alpern, Fred B. Schneider; Information Processing Letters, 1985 (1985)

Gives formal definitions of safety and liveness properties and shows that every property is the intersection of a safety property and a liveness property. Short; read it for precise vocabulary when classifying guarantees.

Anthropic Engineering

Practitioner article on designing evaluations for agents: defining tasks and success, grading approaches, handling nondeterminism and using evals during development. Use it alongside classic ML evaluation material.

arXiv; Vladimir Karpukhin et al.; EMNLP 2020 (2020)

Trains a dual encoder (separate question and passage encoders) with in-batch negatives and BM25-mined hard negatives, so retrieval becomes a maximum inner-product search over precomputed passage vectors. Read it for the training recipe and for how retrieval accuracy is reported separately from answer accuracy.

Industrial Empathy (Malte Ubl’s blog); Malte Ubl

Describes the informal design documents used at Google: context and scope, goals and non-goals, the design itself, alternatives considered and cross-cutting concerns. The same structure works for preparing a project deep dive or a written design proposal.

OpenProceedings (EDBT); Manos Athanassoulis, Michael S. Kester, Lukas M. Maas, Radu Stoica, Stratos Idreos, Anastasia Ailamaki, Mark Callaghan; EDBT 2016 (2016)

Short vision paper arguing that access methods trade read overhead, update overhead and memory (space) overhead, and that improving two costs the third. A useful frame for comparing B+ trees, LSM trees, hash indexes and filters.

arXiv; John Hewitt, Percy Liang; EMNLP 2019 (2019)

Introduces control tasks and selectivity to separate what a representation encodes from what a flexible probe can learn on its own, and shows how probe-capacity choices change conclusions. The standard reference for doing probing carefully.

O'Reilly Media (author's book site); Martin Kleppmann (2nd edition with Chris Riccomini); 1st edition (2017) chapter numbering; 2nd edition reorganized

The standard bridge between databases and distributed systems: storage engines, replication, partitioning, transactions, consistency, consensus, batch and stream processing. Chapter references below use the 1st edition numbering; the 2nd edition reorganizes some chapters, so match by chapter title.

Cornell University (LADIS 2009 workshop site); Jeff Dean; LADIS 2009 keynote (2009)

Keynote slides that include a table of approximate latencies for memory, disk, network and datacenter operations and short back-of-the-envelope design examples. The absolute numbers are dated (hardware has moved on); the habit of estimating before designing is the point.

Oracle (dev.java)

Oracle’s current official Java tutorials, updated for recent releases. The collections framework, generics, records and virtual-threads tutorials cover most of what an interviewer checks when Java is your chosen language.

ICSI (author copy); Sally Floyd, Vern Paxson; IEEE/ACM Transactions on Networking (2001)

Classic methodology paper on why the Internet is hard to model: heterogeneity of links, protocols and traffic, and constant change. Its advice to search for results that hold across wide parameter ranges applies to emulation and testbeds too.

arXiv; Cheng Chi, Zhenjia Xu, et al.; RSS 2023 (2023)

Represents a robot policy as a conditional denoising diffusion process over short action sequences, which handles multimodal demonstrations and improves temporal consistency. A representative modern imitation-learning method to read after behavior cloning and DAgger.

arXiv; Rafael Rafailov et al.; NeurIPS 2023 (2023)

Derives a classification-style loss on preference pairs that optimizes the same KL-regularized objective as RLHF without training a separate reward model or running RL. Study the derivation and the role of the reference policy.

Amazon Web Services (whitepaper)

Defines recovery time and recovery point objectives and compares DR strategies from backup-and-restore through pilot light and warm standby to active-active, with their cost and recovery tradeoffs. The concepts transfer to any provider.

Distill

Archive of interactive, peer-reviewed explanatory articles on machine learning, including foundational interpretability work on feature visualization, circuits and attribution baselines. The journal stopped publishing new articles in 2021, so treat it as a high-quality archive rather than a current venue.

University of Cambridge; Martin Kleppmann (2021)

A compact, rigorous undergraduate course on system models, clocks, broadcast, quorum replication, Raft, two-phase commit, linearizability and eventual consistency, with free lecture notes and recorded lectures. The clearest short source for fault and timing models and for consistency definitions.

USENIX; Yinmin Zhong et al.; OSDI 2024 (2024)

Frames serving quality as goodput, the request rate that can be served while meeting time-to-first-token and time-per-output-token targets, and argues for running prefill and decode on separate GPUs to avoid their interference. Read the problem framing even if you never deploy disaggregation.

d2l.ai (open-source book); Aston Zhang, Zachary C. Lipton, Mu Li, Alexander J. Smola

Interactive deep-learning book with runnable code for every concept, from linear models through attention, transformers, optimization and computational performance. Good for implementing ideas yourself rather than only reading about them.

arXiv; Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, Vaishaal Shankar; ICML 2019 (2019)

Rebuilds test sets by following the original dataset-creation process and measures accuracy drops across many published models. Read it to understand test-set reuse, sensitivity to small collection differences, and why model rankings can be more stable than absolute numbers.

Cognitect blog; Michael Nygard (2011)

The short post that introduced architecture decision records: one small document per significant decision with its context, the decision, its status and its consequences. A lightweight format for recording and later explaining design choices.

arXiv; Jesse Dodge, Maarten Sap, et al.; EMNLP 2021 (2021)

Audits a widely used web-scale pretraining corpus, including how much benchmark data it contains and what its filtering removes. A practical model for contamination checks against pretraining data and for documenting a corpus before trusting evaluations of models trained on it.

arXiv; Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, Pieter Abbeel; IROS 2017 (2017)

Trains an object-localization network only on simulated images with heavily randomized textures, lighting and camera poses and uses it on a real robot. The canonical reference for visual domain randomization.

USENIX; Ali Ghodsi, Matei Zaharia, Benjamin Hindman, Andy Konwinski, Scott Shenker, Ion Stoica; NSDI 2011 (2011)

Generalizes max-min fairness to several resource types by equalizing each user’s dominant share, and proves that the result provides sharing incentive, strategy-proofness, envy-freeness and Pareto efficiency, comparing it with asset fairness and competitive equilibrium. The standard reference for multi-resource fairness.

Node.js documentation (Learn)

Explains why one slow callback delays every client of an event-loop server, what the worker pool is for, and two remedies for expensive work: partitioning it into short steps or offloading it. The lessons carry over directly to asyncio, Tokio and other event-loop runtimes.

All Things Distributed (Werner Vogels); Giuseppe DeCandia et al.; SOSP 2007 (2007)

Design of a leaderless, always-writable key-value store using consistent hashing, sloppy quorums, hinted handoff, vector clocks and anti-entropy. A key example of choosing availability and pushing conflict resolution to the application.

The Go Project (go.dev)

The classic guide to idiomatic Go: slices and maps, interfaces, errors, panics, goroutines and channels. Its sections on data, interfaces and concurrency remain the reference for idiom even though later language features are missing.

arXiv; Deepak Narayanan et al.; SC 2021 (2021)

Combines tensor, pipeline and data parallelism and analyzes how they interact: the pipeline bubble as a function of stages and micro-batches, an interleaved schedule that shrinks it, and why tensor parallelism belongs inside a node. Read the analysis sections for the reasoning, not only the throughput plots.

arXiv; Woosuk Kwon et al.; SOSP 2023 (2023)

The vLLM paper: stores the KV cache in fixed-size blocks managed like virtual-memory pages, reducing fragmentation and enabling sharing, which lets continuous batching admit more concurrent requests.

PVLDB (VLDB Endowment); Thomas Neumann; PVLDB, vol. 4, no. 9 (2011)

Introduces data-centric code generation: compile each pipeline into tight code that pushes tuples from one pipeline breaker to the next, keeping them in registers. The reference design for compiling query engines.

Hudson River Trading (HRTbeat) (2025)

HRT’s October 2025 post describing engineering work and its interview process.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

LWN.net; Jeff Moyer (2011)

Follows data through each buffering layer between an application and stable storage (library buffers, page cache, device cache) and shows which calls move it across each boundary: fflush, fsync, fdatasync, O_SYNC, O_DIRECT and fsync on the parent directory. Direct preparation for “what does durable mean?”.

Envoy Proxy project

Concise reference for how a modern L7 proxy chooses backends (round robin, least request, ring hash, Maglev and others) and the related pages on health checking, outlier detection and panic thresholds.

etcd project (CNCF)

States precisely which consistency etcd offers for reads and writes and how revisions, leases and watches behave. A concrete example of a Raft-backed coordination store, and the store behind the Kubernetes control plane.

curl project; Daniel Stenberg

Free book from the curl project. The write-out section lists the timing variables that split a request into name lookup, connect, TLS handshake, time to first byte and total time.

PVLDB (VLDB Endowment); Timo Kersten, Viktor Leis, Alfons Kemper, Thomas Neumann, Andrew Pavlo, Peter Boncz; PVLDB, vol. 11, no. 13 (2018)

Implements both execution paradigms in one testbed so that differences come from the paradigm rather than from different systems, and compares them on several query types and hardware effects. Read it for the controlled-comparison method as much as for the findings.

martinfowler.com; Pramod Sadalage, Martin Fowler (2016)

Treats every schema change as a versioned, automated migration integrated continuously with application code, and describes a transition phase in which the database supports old and new access patterns at the same time. The practical basis for expand-and-contract schema changes without downtime.

Karlsruhe Institute of Technology (authors' copy); Mario Hock, Roland Bless, Martina Zitterbart; IEEE ICNP 2017 (2017)

Early independent testbed evaluation of BBRv1 that varies buffer size, RTT and competing flows. Read it next to the original article and record each experiment's conditions alongside its finding.

Hannes Mühleisen (author-hosted PDF); Mark Raasveldt, Pedro Holanda, Tim Gubner, Hannes Mühleisen; DBTest 2018 (SIGMOD workshop) (2018)

A short catalog of the ways database performance comparisons go wrong: unequal tuning, cold versus hot runs, incorrect results, client overheads and more, with a checklist. Read before designing or judging any database benchmark.

arXiv; Noam Shazeer (2019)

Introduces multi-query attention (all heads share one key and value projection) and argues from memory-bandwidth analysis that incremental decoding is limited by loading keys and values. A short paper whose performance reasoning is worth reproducing by hand.

martinfowler.com; Pete Hodgson (2017)

Long-form guide to feature toggles: release, experiment, ops and permissioning toggles, how long each kind should live, how toggle configuration can be managed, and how to keep the extra code paths testable and the toggle count under control.

University of Utah (author preprint); Xuejun Yang, Yang Chen, Eric Eide, John Regehr; PLDI 2011 (2011)

Introduces Csmith, a generator of random C programs used for randomized differential testing: the same program is compiled by several compilers and differing outputs reveal bugs. A clear large-scale example of checking an implementation against independent references.

Firecracker project (GitHub)

Source and documentation of the Firecracker VMM. The design document covers scope, host integration, internal architecture and threat containment, the machine model, I/O rate limiting and sandboxing as maintained today; the getting-started guide boots a microVM; the production host setup lists hardening steps, including noisy-neighbor and side-channel mitigations.

USENIX; Alexandru Agache et al.; NSDI 2020 (2020)

Describes the microVM monitor behind AWS Lambda and Fargate: a minimal KVM-based VMM chosen to get VM-grade isolation with container-like density and startup time. A good case study in isolation versus overhead tradeoffs.

Marc Brooker's blog; Marc Brooker (2022)

Compares fixed retry counts with token-bucket retry budgets and circuit breakers by how much extra load each adds as the failure rate grows. A compact quantitative argument for retry budgets.

Brendan Gregg's website; Brendan Gregg

The originator’s guide to flame graphs: how sampled stacks are merged, how to read width and ancestry, and variants for CPU, off-CPU, memory and differential analysis, with instructions for common profilers. The off-CPU page explains how to find time spent blocked rather than running.

arXiv; Tri Dao; ICLR 2024 (2023)

Follow-up to FlashAttention that keeps the IO-aware algorithm but changes how work is split across thread blocks and warps, parallelizes over sequence length and trims non-matmul operations. Read after the original to see how kernel-level work partitioning affects utilization.

arXiv; Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, Christopher Ré; NeurIPS 2022 (2022)

Computes exact attention with tiling and an online softmax so the full attention matrix never travels to GPU high-bandwidth memory. The key lesson is that memory traffic, not FLOPs, often bounds performance.

FoundationDB documentation

Describes how FoundationDB runs its distributed database inside a deterministic simulator with injected network, disk and machine faults, so failures reproduce from a seed. The clearest public description of deterministic simulation testing; the SIGMOD paper gives more detail.

Git project (git-scm.com)

Official reference for finding the commit that introduced a change by binary search over history, including skipping untestable commits and automating the search with bisect run and a test script whose exit status marks each commit.

The Go Authors (go.dev)

Official Go blog posts and package documentation covering the behaviors that matter for algorithmic Go: slices sharing a backing array, append growth, unspecified map iteration order, sort stability and the heap.Interface contract. Start with the slices post.

PLOS Computational Biology (open access); Greg Wilson, Jennifer Bryan, Karen Cranston, Justin Kitzes, Lex Nederbragt, Tracy K. Teal; PLOS Computational Biology 13(6), 2017 (2017)

Minimum practical habits for research projects: data management, software, collaboration, project organization, tracking changes and manuscripts. Pitched at researchers rather than professional software engineers, which makes it a realistic baseline for prototype code.

Google

Google’s numbered API design guidance, each AIP covering one decision such as pagination, request identifiers, errors, conditional updates, compatibility or versioning. The individual AIPs are short enough to use as checklists during an API design exercise; they encode Google’s conventions, so adapt rather than copy them.

Google (GitHub)

Documentation and access instructions for Borg cluster traces: a single cell from 2011 and eight cells from May 2019 with resource requests, CPU usage histograms, alloc sets and parent-job information, plus a bibliography of papers that used the traces.

Google DeepMind

Google DeepMind’s careers page describing teams, roles and hiring information.

Google (eng-practices documentation)

Google’s published guidance for reviewers and authors of code changes: the standard for approving a change, what to look for, how to write and label comments, and why small changes review better. Short, concrete and directly usable for code review exercises.

Google Research

Describes research roles and programs at Google Research. Useful for understanding how research scientist, research engineer and student researcher roles are framed; it is not an interview-format guide.

arXiv; Elias Frantar, Saleh Ashkboos, Torsten Hoefler, Dan Alistarh; ICLR 2023 (2022)

One-shot, layer-by-layer weight quantization that uses approximate second-order information from a small calibration set to adjust the remaining weights as each one is quantized. The reference method for low-bit weight-only quantization.

arXiv; Joshua Ainslie et al.; EMNLP 2023 (2023)

Proposes grouped-query attention, where groups of query heads share key/value heads, as a middle ground between multi-head and multi-query attention, and shows how to convert existing multi-head checkpoints by uptraining. Read it for the KV-cache and bandwidth motivation.

Google Research; David Lo, Liqun Cheng, Rama Govindaraju, Parthasarathy Ranganathan, Christos Kozyrakis; ISCA 2015 (2015)

A feedback controller that lets best-effort batch tasks share servers with latency-critical services by coordinating several isolation mechanisms (cores, cache partitioning, memory bandwidth, network and power) based on the latency slack of the critical service. The reference design for interference-aware co-location.

GitHub (Martin Kleppmann); Martin Kleppmann and contributors

A set of two-session test scripts that probe which anomalies each isolation level of several databases allows. Use the PostgreSQL scripts as a ready-made lab for reproducing dirty writes, lost updates, read skew and write skew by hand.

Alistair Cockburn's website; Alistair Cockburn (2005)

The original description of ports and adapters: the application core reaches databases, user interfaces and external services only through ports, with adapters at the edges. Explains why that boundary lets the core be tested with in-memory substitutes and run without its infrastructure.

NeurIPS Proceedings; D. Sculley et al.; NeurIPS 2015 (then NIPS) (2015)

Argues that ML systems accumulate system-level debt beyond ordinary code debt: entanglement (the paper’s "changing anything changes everything"), undeclared consumers, unstable data dependencies, feedback loops, glue code and configuration debt. Short, and still the best shared vocabulary for ML system design discussions.

O'Reilly (free online edition); Ilya Grigorik (2013)

Performance-oriented explanations of latency, TCP, TLS, HTTP/1.x and HTTP/2 with careful round-trip accounting. It predates TLS 1.3 and HTTP/3, so pair its TLS and HTTP chapters with the current RFCs.

Oracle (docs.oracle.com)

Oracle’s guide to how the HotSpot collectors work and how to choose and tune them. The early chapters on generations and the available collectors are the right depth for interviews; the tuning chapters matter once you operate JVM services.

PVLDB (VLDB Endowment); Viktor Leis, Andrey Gubichev, Atanas Mirchev, Peter Boncz, Alfons Kemper, Thomas Neumann; PVLDB, vol. 9, no. 3 (2015)

Introduces the Join Order Benchmark and measures how cardinality estimation, the cost model and plan enumeration each affect query performance, by injecting estimated and true cardinalities into one engine. The reference methodology for optimizer research.

InfoQ; Gil Tene (2016)

Talk on latency measurement: why percentiles and maxima matter more than averages, how coordinated omission makes load generators under-report latency exactly when the system stalls, and how to record latency with histograms. The usual reference for coordinated omission.

Martin Kleppmann's blog; Martin Kleppmann (2016)

Shows why a lock that expires on a timer cannot by itself protect a resource from a client that pauses, and why fencing tokens checked by the resource fix it. The clearest short treatment of leases, process pauses and timing assumptions.

UC Berkeley (author page); David A. Patterson

Practitioner advice in satirical form: a one-page list of commandments for a bad talk, from cluttered slides to ignoring the time limit. Invert each item to get a checklist for your own explanations.

Simon Peyton Jones's website; Simon Peyton Jones

Practitioner advice (slides, a short paper and links) on structuring research talks: aim to make listeners want to read the work, cover only part of it, lead with examples and keep the key idea unmistakable. Directly applicable to 10-minute and longer explanations.

Performance Dynamics; Neil J. Gunther

The author’s overview of the Universal Scalability Law, which extends Amdahl-style reasoning with contention and coherency terms so that throughput can peak and then fall as threads or nodes are added. Use it to fit measured scaling curves rather than to memorize formulas.

S. Keshav (author's site, University of Cambridge); S. Keshav; ACM SIGCOMM Computer Communication Review, 2007 (2007)

Two-page note describing a three-pass method for reading papers and a short procedure for surveying a new area. Use it as the default reading routine and as the starting point for bounded literature searches.

Alternatives: Author's page for the note (updated reading links and translations)(opens in a new tab)

Google DeepMind (online book); Jacob Austin et al. (2025)

Free online book on rooflines, accelerator memory and interconnects, transformer FLOP and memory accounting, parallelism for training and the arithmetic of inference. Written mainly around TPUs with a dedicated GPU chapter; the estimation habits transfer directly to GPU interviews.

Simon Peyton Jones's website; Simon Peyton Jones

Practitioner advice: seven concrete suggestions for research writing, including identifying one clear idea, stating contributions explicitly, using examples before generalities and placing related work deliberately. The same structure works for spoken explanations of a project.

WHATWG

The normative definition of tasks, task queues, microtask checkpoints and the rendering update that browsers implement. Dense and algorithmic; read the definitions and the processing model once so you can tell which simplifications in articles are safe.

haxx.se (author site); Daniel Stenberg

Short free booklet by the curl maintainer on why HTTP/3 and QUIC exist, how they differ from HTTP/2 over TCP, and what deployment issues remain. A readable first pass before the RFCs.

Hugging Face documentation

Documentation for a library of parameter-efficient fine-tuning methods, including LoRA and its variants, with conceptual guides and configuration options such as rank, scaling and target modules. Use it to connect the LoRA paper to the settings you would actually choose.

Hypothesis documentation

Official quickstart for a Python library that generates test inputs from strategies and shrinks failing cases to minimal examples. Use it to differential-test optimized research code against a naive reference.

Amazon Builders' Library; David Yanacek

Contrasts shallow liveness checks with deeper local and dependency checks, shows how a deep check can remove an entire healthy fleet when a shared dependency fails, and discusses failing open. Directly applicable to probe design.

Alternatives: Official PDF version(opens in a new tab)

MIT CSAIL Theory of Distributed Systems group (author copy); Michael J. Fischer, Nancy A. Lynch, Michael S. Paterson; Journal of the ACM, 1985 (1985)

The FLP result: in an asynchronous system no deterministic protocol can guarantee consensus if even one process may crash. Read the statement and the proof idea (bivalent configurations) to understand why practical protocols keep safety unconditionally and need timing assumptions only for liveness.

arXiv; Joelle Pineau et al.; JMLR 2021 (arXiv 2020) (2020)

Describes the three parts of the NeurIPS 2019 reproducibility program (a code submission policy, a community reproducibility challenge and a checklist) and what the organizers learned. Read it to understand why ML venues ask the questions they now ask.

raft.github.io; Diego Ongaro, John Ousterhout; USENIX ATC 2014 (extended version) (2014)

The Raft paper: leader election, log replication, safety argument and membership changes, designed for understandability. Read with the Figure 2 summary at hand and connect it to the 6.5840 Raft lab.

UK AI Security Institute and Meridian Labs

An evaluation framework with datasets, solvers, scorers (including model-graded scoring), agents and logging for reproducible LLM evaluations. Use it to build small evals quickly and to see how a mature harness separates tasks, generation and grading.

Anthropic Engineering (2024)

Practitioner article on a common chunking failure: chunks lose the document context needed to retrieve them. It prepends generated context to each chunk before embedding and BM25 indexing, combines both retrievers and adds reranking. The reported gains are the vendor’s measurements on its own data; reproduce them on yours.

Cambridge University Press (free online edition hosted by the Stanford NLP Group); Christopher D. Manning, Prabhakar Raghavan, Hinrich Schütze (2008)

The standard IR textbook: inverted indexes, tf-idf and the vector space model, probabilistic retrieval including BM25, and evaluation of ranked results. It predates dense retrieval, but its scoring and evaluation chapters are still the right foundation for retrieval work in RAG systems.

kernel.org (author-maintained free book); Paul E. McKenney (editor); Continuously updated; chapter numbers below follow the 2026.06.21a release, so match chapters by title

Free book by the long-time maintainer of Linux RCU on making parallel code both correct and fast: hardware realities, counting, partitioning, locking, deferred processing (reference counting, hazard pointers, sequence locks, RCU), validation and memory ordering. Dense and practical; read the named chapters rather than the whole book.

Jane Street

An official mock interview built on a retired question, showing how an interviewer extends a problem and evaluates the conversation.

Jane Street

Jane Street’s official guidance for software engineering candidates, which differs from its trading-role preparation.

Oracle

The normative definition of Java’s <<, >> and >>> operators: shift distances are masked to the low five bits for int (six for long), >> sign-extends and >>> fills with zeros. Read it if Java is your interview language.

Oracle (docs.oracle.com)

The Javadoc for Java SE 25, a long-term-support release. The java.lang.Object page states the equals and hashCode contracts precisely, and the java.util.concurrent package summary maps executors, queues, synchronizers, concurrent collections and their memory-consistency guarantees.

Oracle

Official Javadoc for the collection classes used in interview code. The class descriptions state the costs and behaviors that matter: PriorityQueue ordering and linear-time removal, HashMap iteration order and resizing, ArrayDeque as the preferred stack and queue, TreeMap navigation methods and the algorithms behind Arrays.sort.

MDN Web Docs

Explains agents, realms, the job queue and the event loop as JavaScript specifies them. Read it before reasoning about promise ordering, microtasks versus tasks, and why long synchronous work blocks rendering.

Jepsen; Kyle Kingsbury

Short pages defining serializability, strict serializability, snapshot isolation, repeatable read and read committed, with the anomalies each excludes and pointers to the formal literature. Useful for placing database isolation levels within the wider map of consistency models.

Jepsen (jepsen.io); Kyle Kingsbury

Independent analyses of databases and queues under injected faults, a map of consistency models with precise definitions, and the open-source testing library and history checkers behind them. Read two or three analyses to absorb the method: workload, nemesis faults, recorded history and checker.

GitHub (community-maintained copy)

The JOB schema and multi-join queries over IMDB data, with a pointer to the original data snapshot. The standard workload for studying cardinality estimation and join ordering on real, correlated data; the repository is a convenience copy, not maintained by the original authors.

Alternatives: IMDB data snapshot used in the paper (CWI)(opens in a new tab)

JSON Schema (json-schema.org)

Official getting-started guide to JSON Schema: types, required properties, enums, numeric ranges and nested objects. LLM tool and structured-output definitions are commonly expressed in this vocabulary, so it is the contract language for validating model-produced arguments.

arXiv; Lianmin Zheng et al.; NeurIPS 2023 Datasets and Benchmarks Track (2023)

Studies strong LLMs as graders of open-ended answers, documents position, verbosity and self-enhancement biases and mitigations, and measures agreement with human preferences. Read the bias analysis before trusting any model-graded evaluation.

Stanford Encyclopedia of Philosophy; Stephen Thornton

Scholarly overview of Popper’s philosophy of science. Sections 3 and 4 explain demarcation and falsifiability: why a useful empirical claim must forbid some observable outcomes. Read those two sections only; the rest is optional background.

Kubernetes project

Official overview of the control plane (API server, etcd, scheduler, controller manager) and node components (kubelet, kube-proxy, container runtime). Start here to understand Kubernetes as a set of reconciling controllers around a consistent store.

Kubernetes project

Official description of the HorizontalPodAutoscaler control loop: how metrics are collected, the proportional replica calculation, handling of unready pods and missing metrics, tolerance, stabilization windows and scaling policies. The walkthrough lets you watch it react to load on a test cluster.

Kubernetes project

How Kubernetes classifies pods as Guaranteed, Burstable or BestEffort from their requests and limits and uses that class under node pressure, plus the related pages on exclusive CPUs with the static CPU manager policy, bin-packing scoring strategies, priority and preemption, and eviction.

Google Research; Abhishek Verma, Luis Pedrosa, Madhukar Korupolu, David Oppenheimer, Eric Tune, John Wilkes; EuroSys 2015 (2015)

Describes Google’s production cluster manager, which mixes latency-sensitive services and batch jobs: cells, jobs, tasks and allocs, priorities and quota, feasibility checking and scoring, reclaiming reserved but unused resources, and isolation. Its lessons shaped Kubernetes, and its cell-compaction methodology is a model for evaluating packing policies.

Alternatives: Full paper PDF hosted by Google(opens in a new tab)

arXiv; Sayash Kapoor, Arvind Narayanan; Patterns (2023) (2022)

Surveys published studies whose results were inflated by data leakage and organizes the causes into a taxonomy: no clean separation between training and test data (including preprocessing and duplicates), illegitimate features that proxy the outcome, and test sets not drawn from the distribution of interest (such as temporal leakage and non-independence). Use it as a review checklist.

Alternatives: Project page with the taxonomy and a model info sheet(opens in a new tab)

arXiv; Andreas Kipf, Thomas Kipf, Bernhard Radke, Viktor Leis, Peter Boncz, Alfons Kemper; CIDR 2019 (arXiv version) (2018)

Introduces MSCN, a query-driven model that represents tables, joins and predicates as sets and adds sample information to estimate cardinalities of correlated joins. A representative learned-estimator design to analyze for training data, generalization and evaluation choices.

Shan Lu's publications page (University of Chicago); Shan Lu, Soyeon Park, Eunsoo Seo, Yuanyuan Zhou; ASPLOS 2008 (2008)

Empirical study of concurrency bugs in large open-source applications that classifies non-deadlock bugs into atomicity and order violations and examines how deadlocks arise and how developers fixed both kinds. OSTEP’s concurrency-bugs chapter builds on it; read it for the taxonomy and the fix strategies.

Check note: Not requested: robots.txt could not be fetched (UNABLE_TO_VERIFY_LEAF_SIGNATURE).

LeetCode

Compact official LeetCode list grouped by technique. Useful as a first pass across the core patterns once you know each pattern; it is a practice sequence, not an explanation of the ideas.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

LeetCode

Official LeetCode sequence of SQL exercises covering selection, joins, aggregation, subqueries and window-style problems. Use it to build query fluency; pair it with a reference on NULL semantics and window functions.

Check note: Not requested individually: leetcode.com refused or challenged earlier automated requests (HTTP 403), so the check stopped contacting it. Open the link in a browser.

LeetCode

Broader official LeetCode list with more problems per pattern. Good for review rotation after a pattern is understood, so you can revisit an idea through a problem you have not seen.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

Hugging Face (GitHub)

A PyTorch library of robot-learning datasets in a common format, pretrained policies and training tools, with support for low-cost hardware. Optional; useful to see how imitation-learning data and policies are packaged in practice.

libuv documentation

Compact description of the event loop underneath Node.js: loop phases, handles and requests, the platform pollers it wraps (epoll, kqueue, event ports, IOCP) and the thread pool it uses for file I/O because no portable non-blocking file interface exists. A concrete model of a production event loop.

arXiv; Paris Carbone, Gyula Fóra, Stephan Ewen, Seif Haridi, Kostas Tzoumas; arXiv preprint (2015)

Describes the barrier-based asynchronous snapshot algorithm behind Flink’s checkpoints, adapted from distributed snapshot ideas to dataflow graphs, including the handling of cycles. Read it to understand how exactly-once state is achieved without pausing the pipeline.

Maurice Herlihy's page (Brown University); Maurice P. Herlihy, Jeannette M. Wing; ACM Transactions on Programming Languages and Systems 12(3), 1990 (1990)

The paper that defines linearizability: histories, the real-time order of non-overlapping operations, locality (linearizable objects compose) and the comparison with sequential consistency and serializability. Sections 1–3 give interview depth; Sections 4–5 cover verification and reasoning techniques.

The Linux Kernel documentation

Kernel interface for partitioning the last-level cache and throttling memory bandwidth per group of tasks on hardware that supports it, plus monitoring of cache occupancy and bandwidth. It covers exactly the resources that cgroup CPU and memory controllers (linked below) do not partition, which makes it central to interference experiments.

The Linux Kernel documentation (docs.kernel.org)

Short kernel-written overview of how Linux realizes virtual memory: huge pages, zones and nodes, page cache, anonymous memory, reclaim, compaction and the OOM killer. It bridges textbook paging and the vocabulary you meet when debugging memory pressure in production.

Brendan Gregg's website; Brendan Gregg

Large, example-driven reference for Linux perf: counting events with perf stat, sampling stacks with perf record, tracepoints, symbol and stack-walking problems, and many one-liners. Keep it open during hands-on profiling rather than reading it end to end.

man7.org (Linux man-pages project)

Exact Linux semantics for TCP sockets: socket options such as TCP_NODELAY and keepalive settings, buffer sysctls, socket-level options, and what the listen backlog bounds. Read the option lists and NOTES rather than the whole pages.

arXiv; Tim Dettmers, Mike Lewis, Younes Belkada, Luke Zettlemoyer; NeurIPS 2022 (2022)

Documents emergent large-magnitude outlier features in transformer activations and handles them with vector-wise quantization plus a mixed-precision decomposition that keeps outlier dimensions in 16-bit. Read it for the outlier analysis that later methods build on.

Aaron Turon's blog; Aaron Turon (2015)

Accessible explanation of epoch-based memory reclamation as used by Rust’s crossbeam library: why a lock-free structure cannot free an unlinked node immediately, how epochs bound when freeing becomes safe, and what the scheme costs. Good intuition before the hazard-pointer literature.

arXiv; Edward J. Hu et al.; ICLR 2022 (2021)

Freezes pretrained weights and learns a low-rank update for selected matrices, cutting trainable parameters and optimizer memory while allowing the update to be merged for inference.

Google for Developers

Short interactive modules on core ML practice. The pages on dividing datasets, classification metrics, ROC and thresholds, embeddings and production ML systems are fast refreshers; they stay introductory, so pair them with deeper sources.

MLRC organizers

Annual venue for reproducing recent ML papers; recent editions publish through TMLR and the 2026 edition is a NeurIPS track. Past proceedings show how reproduction reports separate what was confirmed, what was not and why.

USENIX; Danielle E. Eisenbud, Cheng Yi, Carlo Contavalli, Cody Smith, Roman Kononov, Eric Mann-Hielscher, Ardas Cilingiroglu, Bin Cheyney, Wentao Shang, Jinnah Dylan Hosein; USENIX NSDI 2016 (2016)

Design of a software L4 load balancer that scales out behind ECMP, using a consistent-hashing lookup table plus connection tracking so connections survive changes in the balancer and backend sets. A concrete case study for L4 balancing questions.

USENIX; Ravi Netravali, Anirudh Sivaraman, Somak Das, Ameesh Goyal, Keith Winstein, James Mickens, Hari Balakrishnan; USENIX ATC 2015 (2015)

Describes Mahimahi, a set of composable shells for record-and-replay of web traffic and for emulating delay, loss and trace-driven link capacity. Its link shell replays recorded cellular traces, and later congestion-control platforms such as Pantheon build their emulators on it.

Horace He's website; Horace He (2022)

Sorts the time a model spends into compute, memory bandwidth and overhead, and shows how operator fusion and framework overhead fit that picture. The fastest way to acquire the vocabulary used in GPU performance discussions.

Amazon Builders' Library; Malcolm Featonby

Describes caller-supplied request identifiers, recording the identifier atomically with the effect, returning an equivalent response to duplicates and rejecting a reused identifier whose parameters differ. A concrete design for idempotency keys.

MANRS initiative

Global initiative that defines baseline routing-security actions for network operators (filtering, anti-spoofing, coordination, validation) and runs an observatory of routing-security data. Good for awareness of how leaks and hijacks are mitigated in practice.

Google Research; Jeffrey Dean, Sanjay Ghemawat; OSDI 2004 (2004)

The programming model and runtime for fault-tolerant batch processing on commodity clusters: deterministic re-execution, the master, stragglers and backup tasks, and locality. Short and foundational; it is the subject of 6.5840 Lab 1.

Cambridge University Press (free PDF on the companion site); Marc Peter Deisenroth, A. Aldo Faisal, Cheng Soon Ong (2020)

Builds the linear algebra, matrix decompositions, vector calculus, probability and optimization that ML relies on, then applies them to regression, PCA, mixture models and SVMs. Use the decomposition and vector-calculus chapters to make SVD and gradient identities routine.

MDN Web Docs

Mozilla’s guide and reference for the JavaScript language, precise enough to settle most semantics questions. The pages below cover closures, this, the prototype chain, equality algorithms, number encoding and promises.

MDN Web Docs (Mozilla)

Readable guides and reference pages for HTTP: the message model, methods, status codes, headers, cookies, authentication, CORS and caching. Use the guides to refresh concepts and the reference pages to check exact semantics while designing endpoints.

MDN Web Docs (Mozilla)

Concise reference guides on HTTP. The evolution guide gives a version-by-version overview through HTTP/3, the connection-management guide explains keep-alive, pipelining and connection limits, and the caching guide covers Cache-Control and validators.

MDN Web Docs

MDN’s accessibility hub, linking a learning path and reference material. The learning pages on semantic HTML and WAI-ARIA basics explain the accessibility tree and when ARIA is needed; the ARIA reference documents each role and attribute.

MDN Web Docs

Reference pages for JavaScript behaviors that matter in algorithmic code: default string comparison and stability in sort, comparator requirements, front removal with shift(), and key equality and ordering in Map and Set.

MDN Web Docs

Explains tasks versus microtasks with runnable examples and when queueMicrotask is appropriate; the in-depth companion page walks through execution contexts, the window, worker and worklet event loops, and why microtasks queued by microtasks still run before the next task.

MDN Web Docs

How fetch reports success and failure (it resolves on HTTP error statuses), how to cancel a request with an AbortController, and how AbortSignal helpers such as timeouts and combined signals work. The reference for the request-race and error-handling exercises in the frontend topics.

research!rsc (Russ Cox); Russ Cox (2021)

Clear essays on hardware memory models (sequential consistency, x86-TSO, ARM) and programming-language memory models (Java, C++, Go), built around small litmus tests and the idea of data-race-free programs. The best intuition-level preparation for explaining happens-before and acquire/release.

Meta (mirrored on a third-party CloudFront host)

Meta-authored preparation guide for the software engineering full loop, hosted by a third party. Treat its format details as a dated snapshot and confirm current applicability with your recruiter.

ACM SIGOPS (HotOS proceedings); Nathan Bronson, Abutalib Aghayev, Aleksey Charapko, Timothy Zhu; HotOS 2021 (2021)

Names a class of outages in which a temporary trigger pushes a system into a bad state that sustains itself (for example through retries or cache misses) after the trigger is gone. Short and useful for explaining why mitigation often means shedding load rather than fixing the trigger.

GitHub (Andrej Karpathy); Andrej Karpathy

A tiny scalar reverse-mode autodiff engine with a small neural-network library on top. Reading engine.py makes topological ordering, gradient accumulation and the chain rule inside backward() concrete before you study how PyTorch does the same for tensors.

Microsoft Careers

Official Microsoft guidance on preparing for technical interviews.

Microsoft Research

Overview of research careers, internships and programs at Microsoft Research. Use it for role context and program types; it does not describe a standardized interview loop.

Irrational Exuberance (Will Larson’s blog); Will Larson (2018)

Argues that well-run migrations are the main way to pay down technical debt at scale and describes a derisk, enable and finish playbook. Useful for structuring migration stories and plans in senior interviews.

Mistral AI

Mistral AI’s careers page with open roles.

MIT OpenCourseWare; Erik Demaine, Jason Ku, Justin Solomon (2020)

Full undergraduate algorithms course with lecture notes, recitations, problem sets and videos. Use it to relearn the reasoning behind data structures, graph algorithms and dynamic programming rather than memorizing solutions; the recitation notes are especially compact.

MIT OpenCourseWare; Erik Demaine, Srini Devadas, Nancy Lynch (2015)

The follow-on course to 6.006, with lecture notes on greedy proofs, divide and conquer, amortized analysis and randomized algorithms. Use the selected lectures for the correctness and expected-time arguments behind interval scheduling, median finding, quicksort and union-find-based MST.

MIT EECS

Readings from MIT’s software construction course on testing, specifications, abstract data types, representation invariants, code review and debugging, each with short exercises. The testing reading shows how to choose test cases by partitioning the input space and including boundaries; the debugging reading treats debugging as reproduce, hypothesize, experiment.

MIT PDOS

Hands-on OS course built around the small xv6 teaching kernel. The labs (system calls, page tables, traps, copy-on-write fork, locks, file system) turn OS concepts into code you must get right; the xv6 book explains the kernel source.

MIT PDOS

Graduate distributed-systems course organized around reading classic papers (MapReduce, GFS, Raft, ZooKeeper, Spanner and more) with Go labs that build MapReduce, a key/value service, Raft and a sharded store. The labs are the best available practice for fault-tolerance reasoning.

arXiv; Paulius Micikevicius et al.; ICLR 2018 (2017)

Introduces the standard recipe for half-precision training: an fp32 master copy of the weights, loss scaling to keep small gradients representable, and higher-precision accumulation. Read it to understand why each piece exists rather than treating autocast as magic.

martinfowler.com; Martin Fowler (2007)

Explains the test-double vocabulary (dummy, fake, stub, spy, mock) and contrasts state verification with behavior verification, and the classical with the mockist testing style. Read it to argue precisely about when a mock helps and when it ties tests to implementation details.

Swarthmore College (author copy); Ranysha Ware, Matthew K. Mukerjee, Srinivasan Seshan, Justine Sherry; ACM IMC 2019 (2019)

Models why BBRv1 competing with Cubic or Reno becomes limited by its in-flight cap, which then sets its share of the link, and validates the model experimentally. A good example of explaining a measured unfairness with a mechanism.

CIDR; Peter Boncz, Marcin Zukowski, Niels Nes; CIDR 2005 (2005)

Analyzes why tuple-at-a-time execution uses modern CPUs poorly and proposes vectorized execution over column batches. The starting point for vectorized engines.

GitHub (Jacob Leverich)

Open-source memcached load generator built for high request rates and tail-latency measurement. Its README explains why one connection that waits for each reply cannot load a server realistically and how threads, connections, pipelining and remote agents change that. Later GitHub forks such as memcache-perf (whose binary is also called mcperf) and its dynamic-load variant build on it; an unrelated tool, twemperf, is also known as mcperf.

GitHub (Andrej Karpathy); Andrej Karpathy

A compact GPT training and sampling codebase whose model.py holds causal self-attention, MLP blocks and generation in a few hundred lines. Read it as a reference decoder-only implementation and use it as the base for exercises such as adding a KV cache; it is not a current production training stack.

NVIDIA Documentation

Precise definitions of AllReduce, Broadcast, Reduce, AllGather, ReduceScatter and related collectives as implemented by NCCL. The linked nccl-tests performance note explains algorithm bandwidth versus bus bandwidth, which you need to interpret collective benchmarks.

Netflix Jobs

Netflix’s public page for new-graduate candidates. Its process description applies to the new-grad program, not to experienced hires.

arXiv; Rico Sennrich, Barry Haddow, Alexandra Birch; ACL 2016 (2015)

Adapts byte-pair encoding to learn a subword vocabulary by repeatedly merging the most frequent adjacent symbol pair, giving open-vocabulary models without unknown-word tokens. Short; read it for the merge algorithm that LLM tokenizers build on.

NeurIPS

The checklist NeurIPS submissions must include, with guidance on claims, limitations, theory assumptions, result reproducibility, access to data and code, experimental details, statistical significance, compute resources, ethics and licenses. A good self-review for any ML project report or thesis chapter.

Vercel / Next.js documentation

Official Next.js App Router setup guide. Listed because this planner is built with Next.js; it is not part of the interview curriculum.

National Institute of Standards and Technology (NIST) (2023)

Voluntary US framework for managing AI risks across the lifecycle, organized around the Govern, Map, Measure and Manage functions; NIST later published a Generative AI Profile (NIST-AI-600-1) linked from this page. Useful vocabulary for senior discussions of risk ownership, documentation and monitoring.

arXiv; Kai Greshake, Sahar Abdelnabi, Shailesh Mishra, Christoph Endres, Thorsten Holz, Mario Fritz (2023)

Introduces indirect prompt injection: instructions planted in content that an LLM application later retrieves (web pages, emails, documents) and then acts on with the user’s privileges. Read the threat taxonomy to reason about any system that feeds untrusted text to a model with tools.

NumPy project (numpy.org)

The user-guide chapters on how arrays behave. Broadcasting, Copies and views, Data types and Indexing together explain most silent bugs in array code: unexpected result shapes, writes through views, hidden copies from advanced indexing, and overflow or precision loss from dtype choices.

NVIDIA Documentation

Short official guides on how streaming multiprocessors, tensor cores and memory bandwidth bound deep-learning operations, how to compute arithmetic intensity, and how to tell math-limited from memory-limited work. The matrix-multiplication guide adds tile and wave quantization; the mixed-precision guide covers formats and loss scaling.

NVIDIA Documentation

Concise definitions of time to first token, end-to-end latency, inter-token latency, tokens per second and requests per second, with explicit notes on where benchmarking tools disagree (for example whether the first token is included in inter-token latency). Use it to pin down definitions before comparing numbers.

NVIDIA Documentation

Documentation for NVIDIA’s system-wide timeline profiler, which places CPU threads, CUDA API calls, kernels, memory copies and communication on one timeline. Use it to find idle gaps and missing overlap; move to Nsight Compute (linked below) only when one kernel needs explaining.

NVIDIA

Official NVIDIA description of its hiring process and candidate guidance.

arXiv; Chuan Guo, Geoff Pleiss, Yu Sun, Kilian Q. Weinberger; ICML 2017 (2017)

Shows that modern deep classifiers tend to be overconfident, defines reliability diagrams and expected calibration error, and finds temperature scaling (one scalar fitted on validation data) to be a strong post-hoc fix. Short and directly usable.

Communications of the ACM (ACM Digital Library); D. L. Parnas; Communications of the ACM 15(12), 1972 (1972)

The classic short paper arguing that modules should hide design decisions that are likely to change, instead of mirroring the steps of a processing flowchart. Read it for the core idea behind information hiding, interfaces and module boundaries; the example system is dated, the argument is not.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

arXiv; Gábor Melis, Chris Dyer, Phil Blunsom; ICLR 2018 (2017)

Re-evaluates several recurrent language-model architectures with large-scale automatic hyperparameter tuning and concludes that properly regularized standard LSTMs compare favourably with newer models. A widely cited case study for why baselines need the same tuning effort as the proposed method.

Stripe Engineering Blog; Jacqueline Xu (2017)

A worked account of moving a large dataset to a new data model while the system stays live: dual writing, backfilling, switching reads with verification, then removing the old path. Shows each step and what it protects against.

arXiv; Maxim Milakov, Natalia Gimelshein (2018)

Shows how to compute the softmax normalizer in one pass by keeping a running maximum and rescaling the partial sum. This is the trick that lets tiled attention kernels stream over keys; read it before deriving blocked attention yourself.

arXiv; Stephen Casper, Xander Davies, et al. (2023)

Surveys challenges across RLHF: collecting human feedback, training reward models and optimizing policies, separating tractable problems from fundamental limitations. A good map for questions about preference data quality and reward hacking.

USENIX; Bianca Schroeder, Adam Wierman, Mor Harchol-Balter; NSDI 2006 (2006)

Compares closed, open and partly-open workload models and shows that the choice of load generator changes measured response times and the apparent benefit of scheduling policies. Read it before choosing a load generator for any latency experiment.

OpenAI

Official OpenAI guide describing its interview process and preparation expectations.

Check note: The site refused or challenged the automated request (HTTP 403). This is common for bot protection and does not mean the link is broken.

OpenTelemetry documentation (CNCF)

Short introduction to observability vocabulary as OpenTelemetry uses it: telemetry, logs, spans, distributed traces and reliability measures. Continue to the signals pages for how traces, metrics and logs relate and how context propagates between services.

University of Wisconsin–Madison (free online book); Remzi H. Arpaci-Dusseau, Andrea C. Arpaci-Dusseau

Readable, free OS textbook organized around virtualization, concurrency and persistence. Each chapter is short and ends with homework simulations; use the chapter PDFs listed per topic rather than reading cover to cover.

VLDB Endowment; Andrea Vattani, Flavio Chierichetti, Keegan Lowenstein; PVLDB vol. 8, 2015 (2015)

Analyzes probabilistic early recomputation: each reader refreshes a still-valid entry with a probability that rises as expiry approaches, scaled by how long recomputation takes. Read the algorithm and the intuition; skip the proofs on a first pass.

USENIX; Gyeong-In Yu, Joo Seong Jeong, Geon-Woo Kim, Soojeong Kim, Byung-Gon Chun; OSDI 2022 (2022)

Introduces iteration-level scheduling, where the batch is re-formed at every model iteration so finished requests leave and new ones join immediately, plus selective batching for operations that cannot be batched across different sequence lengths. The origin of what is now called continuous batching.

OWASP Foundation

Concise, practitioner-maintained guidance on specific application security problems. Read the relevant sheets as checklists when designing authentication, sessions, authorization, tenant isolation, input handling and secrets, and cite them when explaining a mitigation.

OWASP Foundation; 2025 edition (current when this entry was written)

Awareness document ranking the most critical web application security risk categories, revised every few years from contributed data. Use it as a map of what can go wrong; each category page describes the risk, examples and prevention. The 2025 edition files SSRF under Broken Access Control and cross-site scripting under Injection.

OWASP Gen AI Security Project

Community-maintained list of major security risks in LLM applications: prompt injection, sensitive information disclosure, supply chain, data and model poisoning, improper output handling, excessive agency, system prompt leakage, vector and embedding weaknesses, misinformation and unbounded consumption. Each entry gives scenarios and mitigations.

Palantir

Palantir’s page for students and early-career candidates. The detailed current technical loop is not verified from this source.

Stanford University; Francis Y. Yan, Jestin Ma, Greg D. Hill, Deepti Raghavan, Riad S. Wahby, Philip Levis, Keith Winstein; USENIX ATC 2018 (paper) (2018)

Community platform that ran many congestion-control schemes over real wired, cellular and cloud paths, published the results, and provided emulators calibrated to those paths. Valuable as a model of reproducible, multi-path comparison and for its archived results.