Two-Year ML, Systems & Quantum Research Plan

UW undergraduate research roadmap, 2026–2028 · Aug 17, 2026 – Sep 4, 2028 · 750 days · 13 periods

Become the undergraduate who can take a real ML/NLP question from evidence to implementation to measurement, who understands the systems underneath it, and who can then carry the same discipline onto a machine that does not work like the one underneath it.

The unit is the day, not the week and not the three-day block. Five lanes every day — a paper, a systems chapter, an AI chapter, a system implemented, an open-source contribution — for 750 days, with both reading lanes bending toward quantum computing once the classical pillars have shipped.

By 2028: sustained lab trust, a first-author-ready arc, four or five serious repositories, rigorous experiment logs, one measured ML-systems contribution, and one quantum-systems artifact benchmarked against an established tool.

USACO Gold and two AIME qualifications already demonstrate algorithmic strength and mathematical maturity. The missing evidence is open-ended work: experiments, systems reliability, research judgment, technical writing, and sustained contributions to a group.

Priority order

1. Course performance. Protect grades and turn CSE 446/447/451/452 work into artifacts instead of duplicating it with unrelated side projects.
2. Research capability. ML/DL study and systems study count as research. Build, test, measure, and write; maintain a mentor relationship.
3. The daily contract. Five lanes a day. It outranks everything below it because it is the thing that compounds — a quarter of kept days is a portfolio, and a quarter of skipped ones is a plan nobody can tell you followed.
4. Open-source contribution. Something every day; a pull request opened two or three times a week. Logged from /Admin, gaps included.
5. Startup. Only continue a cycle when it shares data, infrastructure, or a research question with the main track.
6. Codeforces. Practice and selected contests for sharpness; never chase rating at the expense of research evidence.
7. Putnam. Optional proof practice. Pause first under a heavy course, research, or application deadline.

• Free weeks (summer and breaks). 70 hours a week, about 7 a day: paper 0:45, systems chapter 1:15, AI chapter 1:15, the day's system 2:30, open source 0:45, and half an hour to write down what shipped and what slipped.
• Term weeks (inside a UW quarter). 45 extracurricular hours a week on top of 25–30 hours of coursework — about 6.4 a day across seven days, which is exactly what the daily contract costs. The floor is 40, and the floor version shortens only the day's system. This restores the source document's original budget; an earlier revision cut the term week to 45 hours in total, and that figure is what used to justify pausing the independent systems track inside a quarter.
• All five lanes run during term. The independent systems track no longer pauses in a quarter. At 15–20 extracurricular hours it could not fit; at 40–45 it does, and pausing it was costing the long projects two thirds of the year.
• Every sixth day is catch-up. No new chapter, no new system, no new increment — one paper, and whatever slipped. 124 of the 750 days — every sixth, except the last day of the plan, which should not be a rest day. It used to be three consecutive days every eighteen, which was an artefact of a calendar cut into three-day blocks; spread singly it is the same slack and it lands before the backlog has had a week to grow.
• Parallel lanes, sequential gates. Sequential inside a lane: interface and invariant → smallest correct version → tests → benchmark and analysis → write the next decision. The five daily lanes are parallel by construction; nothing else should be.

Operating policy

Daily lanes

Learning spine

ML branch map. Base: differentiable programs → learning dynamics → representations and sequence models → NLP data and tokenization → transformers and LM behavior → research-grade evaluation. Then the AI lane widens into the fields that consume it — structural biology, robotics and control, scientific computing — and finally into quantum mechanics as physics. The systems lane runs OS → machine → data → distributed → architecture → parallel → compilers, and then turns: quantum information, quantum theory of computation, error correction, quantum systems. The two meet at the neural-network-as-wavefunction papers and at the learned decoder, which is trained on the autograd engine tensorforge already provides.

Quarter-by-quarter outcomes

13 periods, 750 days

The long projects

Most days implement something whole in the day. The rest are increments on one of these: a project with a thesis, built one step a day across a named stretch of the calendar. A day that increments one names the track and the step number.

9 tracks

Research and career rules

The day contract

A day is kept when all five lanes produced their artifact — not when the hours were spent. Write down which it was. Two consecutive days missing the same lane is the signal to re-plan, not to catch up.

Research cycle

Observe → read → hypothesis → implement → measure → disconfirm → revise → communicate. Weekly update: question, expectation, experiment, result, alternative explanation, next cheapest informative experiment.

Outreach rule

Apply through formal lab routes where they are listed. Otherwise: read one paper deeply, inspect the code and data, build a small relevant artifact, email the closest student first, and offer a scoped task. Never lead with a frontier-lab aspiration.

Portfolio rule

A serious repo includes a one-command run, correctness checks, a benchmark or result, limitations, and a clear statement of your own contribution. Keep four or five; archive shallow work.

Open-source rule

Something every day, a pull request two or three times a week, and the log tells the truth. A day with no contribution is recorded as a day with no contribution — a fabricated entry costs more than the gap it hides.

Quantum entry rule

No quantum system is built until the classical systems pillar has shipped an artifact someone else has run, and no quantum chapter is counted read until the problem set is worked or the simulator reproduces the number.

Club rule

At most one build team. ARUW, Husky Robotics, Aerial Robotics, and Satellite Lab are useful only when you can own a systems or software subproject. Competitive Programming at UW is maintenance; DubHacks is a bounded startup network.

What to cut when the plan fights itself

Putnam → extra Codeforces → startup breadth → optional exploration → the day's system shrinks to atomic. Do not cut a mentor commitment, a core experiment, a serious systems artifact near completion, a course deliverable that can become research evidence, or the same lane two days running.

The reading list

One paper a day, across all 750 days, each chosen for what that day builds.

1. Day 1 (AI): Attention Is All You Need — Vaswani et al., 2017. The architecture everything else in the two years is built on or measured against. Read it first, and again on day 29 when you are implementing it.
2. Day 2 (systems): ARIES: A Transaction Recovery Method Supporting Fine-Granularity Locking and Partial Rollbacks Using Write-Ahead Logging — Mohan et al., 1992. The write-ahead log ferrodb is about to implement, including why redo and undo are separate passes. Read it the day you design the record format, not after.
3. Day 3 (AI): Automatic Differentiation in Machine Learning: a Survey — Baydin, Pearlmutter, Radul, Siskind, 2018. Names what reverse mode actually is before you write it, and why the numerical gradient check is the test that matters.
4. Day 4 (systems): A Fast File System for UNIX — McKusick, Joy, Leffler, Fabry, 1984. Inodes, cylinder groups and the locality argument. Read it against the page layout you froze on day 2 — FFS is the same decision made for a disk that rotates.
5. Day 5 (AI): Adam: A Method for Stochastic Optimization — Kingma, Ba, 2015. The other half of this week's SGD-versus-Adam comparison; read the bias-correction argument, not just the update rule.
6. Day 6 (systems): Ethernet: Distributed Packet Switching for Local Computer Networks — Metcalfe, Boggs, 1976. Carrier sense, collision detection, exponential backoff — a complete system argued in fifteen pages. A catch-up day is the right day for a paper with nothing to implement.
7. Day 7 (systems): The Design and Implementation of a Log-Structured File System — Rosenblum, Ousterhout, 1992. The counterargument to FFS, and the one that makes crash recovery cheap. Compare it against the WAL you finished yesterday: both turn a random write into a sequential one.
8. Day 8 (systems): The Working Set Model for Program Behavior — Denning, 1968. Why page replacement is a locality question. The eviction policy ferrodb's buffer pool gets in three days is an answer to this paper.
9. Day 9 (AI): Learning Representations by Back-Propagating Errors — Rumelhart, Hinton, Williams, 1986. Four pages. Read it the day after you wrote backprop by hand, not before — it is much better when you already know what it costs.
10. Day 10 (AI): Multilayer Feedforward Networks are Universal Approximators — Hornik, Stinchcombe, White, 1989. What a two-layer MLP can represent in principle — and why that says nothing about what it will learn. Read it the day you train one.
11. Day 11 (systems): End-to-End Arguments in System Design — Saltzer, Reed, Clark, 1984. The design principle that decides which layer of ferrodb owns the checksum. Answer that question in the note, in the paper's terms.
12. Day 12 (AI): Dropout: A Simple Way to Prevent Neural Networks from Overfitting — Srivastava, Hinton, Krizhevsky, Sutskever, Salakhutdinov, 2014. The ensemble interpretation is the part worth arguing with. If your day-14 ablation disagreed with it, say so in the card.
13. Day 13 (AI): Understanding the Difficulty of Training Deep Feedforward Neural Networks — Glorot, Bengio, 2010. Where initialization ablations come from. Reproduce one of its activation-variance plots on your own classifier this week.
14. Day 14 (AI): Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification — He, Zhang, Ren, Sun, 2015. The correction to Glorot for ReLU nets — a factor of two that decides whether deep stacks train at all. Run both initializations today.
15. Day 15 (systems): Experience with Processes and Monitors in Mesa — Lampson, Redell, 1980. Why a condition variable wakes into a loop and not into a guarantee. Read it before ferrodb has concurrent readers, not after they deadlock.
16. Day 16 (AI): Gradient-Based Learning Applied to Document Recognition — LeCun, Bottou, Bengio, Haffner, 1998. LeNet, and the case for learned features over engineered ones. Long — read sections I–III today and stop there.
17. Day 17 (AI): ImageNet Classification with Deep Convolutional Neural Networks — Krizhevsky, Sutskever, Hinton, 2012. The same idea as LeNet fourteen years later with GPUs behind it. Note what changed: scale and engineering, not the concept.
18. Day 18 (AI): Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift — Ioffe, Szegedy, 2015. The stated mechanism has since been disputed. Say in your card whether your own evidence supports it — you have run the ablation.
19. Day 19 (systems): Congestion Avoidance and Control — Jacobson, Karels, 1988. Slow start, RTT estimation, self-clocking. Read it as a control-loop paper — it is the same shape as the group-commit decision ferrodb makes later.
20. Day 20 (AI): Long Short-Term Memory — Hochreiter, Schmidhuber, 1997. The constant error carousel, stated as a fix to a specific failure. Read it before you train the RNN that diverges, and note what the gate is protecting.
21. Day 21 (AI): On the Difficulty of Training Recurrent Neural Networks — Pascanu, Mikolov, Bengio, 2013. Names the exploding and vanishing gradient precisely enough to measure. Gives you clipping, and the reason for it.
22. Day 22 (systems): Development of the Domain Name System — Mockapetris, Dunlap, 1988. A retrospective on a live system: what the design got right, and what caching cost. Read it for the retrospective form — you will write these.
23. Day 23 (AI): A Neural Probabilistic Language Model — Bengio, Ducharme, Vincent, Jauvin, 2003. Distributed word representations and the curse of dimensionality, a decade before it was obvious. This is the baseline word2vec is beating.
24. Day 24 (systems): Cramming More Components onto Integrated Circuits — Moore, 1965. Three pages, an economic argument rather than a physical law. Worth reading once, properly, instead of quoting.
25. Day 25 (AI): Efficient Estimation of Word Representations in Vector Space — Mikolov, Chen, Corrado, Dean, 2013. word2vec. What was thrown away to make it fast is the interesting part, not the analogy arithmetic.
26. Day 26 (systems): The Case for the Reduced Instruction Set Computer — Patterson, Ditzel, 1980. Eight pages, and a design argument rather than a specification. Read it now; riscv-vm implements the descendant of this argument in December.
27. Day 27 (AI): Neural Machine Translation by Jointly Learning to Align and Translate — Bahdanau, Cho, Bengio, 2015. Attention before transformers, invented to fix a fixed-length bottleneck. Implement this form before the scaled dot-product one.
28. Day 28 (AI): Effective Approaches to Attention-based Neural Machine Translation — Luong, Pham, Manning, 2015. The controlled comparison of scoring functions — the ablation you would otherwise have to run yourself.
29. Day 29 (systems): An Efficient Algorithm for Exploiting Multiple Arithmetic Units — Tomasulo, 1967. Register renaming and reservation stations, 1967. Read it as the first out-of-order design; the pipeline you write in riscv-vm stalls where this one does not.
30. Day 30 (AI): Deep Residual Learning for Image Recognition — He, Zhang, Ren, Sun, 2016. The degradation problem is an optimization failure, not an overfitting one. That distinction is the one your own training notes keep getting wrong.
31. Day 31 (AI): Language Models are Unsupervised Multitask Learners — Radford, Wu, Child, Luan, Amodei, Sutskever, 2019. GPT-2: the decoder-only stack you implement tomorrow, and the zero-shot claim that made scale the story.
32. Day 32 (AI): On Layer Normalization in the Transformer Architecture — Xiong et al., 2020. Pre-LN versus post-LN, with the gradient analysis. Decides whether the block you write today needs a warmup schedule.
33. Day 33 (systems): First Draft of a Report on the EDVAC — von Neumann, 1945. Where the stored-program machine is argued from logic elements up. Read the first twenty pages; you are about to spend a day on how it represents a number.
34. Day 34 (AI): Neural Machine Translation of Rare Words with Subword Units — Sennrich, Haddow, Birch, 2016. BPE, and the open-vocabulary problem it was invented for. This is the tokenizer you implement tomorrow.
35. Day 35 (AI): SentencePiece: A Simple and Language Independent Subword Tokenizer and Detokenizer for Neural Text Processing — Kudo, Richardson, 2018. What breaks when tokenization assumes whitespace. The reversibility requirement is the design constraint to steal.
36. Day 36 (AI): Mixed Precision Training — Micikevicius et al., 2018. Loss scaling and the master-weights copy. Read it before you profile the transformer in a few days — it explains the memory numbers you are about to see.
37. Day 37 (systems): The UNIX Time-Sharing System — Ritchie, Thompson, 1974. Everything is a file, including the device. Read it for how much of an operating system fits in eleven pages.
38. Day 38 (AI): BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding — Devlin, Chang, Lee, Toutanova, 2019. The encoder you fine-tune shortly, and the masked-LM objective that makes bidirectionality possible.
39. Day 39 (AI): RoBERTa: A Robustly Optimized BERT Pretraining Approach — Liu et al., 2019. A replication that found the original was undertrained. The clearest example in NLP of why you rerun the baseline yourself.
40. Day 40 (systems): LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation — Lattner, Adve, 2004. Why the IR is the interface. Read it while you are looking at what -O2 did to your loop yesterday.
41. Day 41 (AI): GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding — Wang et al., 2019. What a benchmark is trying to be, and the diagnostic set most people ignore. Your evaluation script's error buckets start here.
42. Day 42 (systems): Dynamo: Amazon's Highly Available Key-value Store — DeCandia et al., 2007. The availability argument for giving up consistency, made concretely and with the operational consequences admitted. Read it before autumn's distributed-systems term.
43. Day 43 (AI): Show Your Work: Improved Reporting of Experimental Results — Dodge et al., 2019. Why a single number with a single seed is not a result. This is where your reporting standard comes from, today, not later.
44. Day 44 (systems): How To Write Shared Libraries — Drepper, 2011. ELF segments, relocation, the GOT and PLT, from the person who maintained the loader. Sections 1–2 today.
45. Day 45 (AI): Sequence to Sequence Learning with Neural Networks — Sutskever, Vinyals, Le, 2014. Encoder-decoder in its first form, fixed-length bottleneck and all. The thing the attention paper on day 27 was fixing.
46. Day 46 (AI): Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer — Raffel et al., 2020. T5, and a systematic ablation across a whole design space. Read it as an experiment design, not as an architecture.
47. Day 47 (systems): A Unified Theory of Garbage Collection — Bacon, Cheng, Rajan, 2004. Tracing and reference counting are duals. Read it as an argument that two things you thought were different are one thing.
48. Day 48 (AI): Scaling Laws for Neural Language Models — Kaplan et al., 2020. The empirical claim that made the last five years look inevitable. Read the fit methodology as carefully as the conclusion.
49. Day 49 (AI): Dense Passage Retrieval for Open-Domain Question Answering — Karpukhin et al., 2020. The dual encoder your pipeline is a version of, plus the in-batch negatives trick that makes it trainable.
50. Day 50 (AI): Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks — Lewis et al., 2020. Where retrieval error and generation error separate — the audit you did on day 46, done first here.
51. Day 51 (systems): Scalable Parallel Programming with CUDA — Nickolls, Buck, Garland, Skadron, 2008. The execution model — threads, blocks, warps, shared memory — as its designers explain it. Read it before the first kernel, which is next summer.
52. Day 52 (AI): FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness — Dao, Fu, Ermon, Rudra, Ré, 2022. The systems thread and the AI thread meeting: attention is memory-bound, and the fix is tiling, not approximation. You measured this yesterday.
53. Day 53 (AI): Self-attention Does Not Need O(n²) Memory — Rabe, Staats, 2021. The same result as yesterday's paper argued from the algebra rather than the hardware. Say in the card which framing you find more useful, and why.
54. Day 54 (AI): Training Compute-Optimal Large Language Models — Hoffmann et al., 2022. Chinchilla, which corrected the paper you read yesterday by rerunning it properly. Two papers, one lesson about baselines.
55. Day 55 (systems): The Google File System — Ghemawat, Gobioff, Leung, 2003. A file system designed around the failure rate of its hardware and the shape of one workload. The clearest example of assumptions stated up front.
56. Day 56 (AI): Distilling the Knowledge in a Neural Network — Hinton, Vinyals, Dean, 2015. Soft targets carry more than the label does. Read it as the first serious answer to "make it smaller without making it worse".
57. Day 57 (AI): LoRA: Low-Rank Adaptation of Large Language Models — Hu et al., 2021. The parameter-efficient method you will actually use during term, when the compute budget is a laptop and an hour.
58. Day 58 (systems): In Search of an Understandable Consensus Algorithm (Raft) — Ongaro, Ousterhout, 2014. CSE 452 will make you implement this. Read it before the lab spec, so the lab is an implementation of a paper you understand rather than a spec you are decoding.
59. Day 59 (AI): Random Forests — Breiman, 2001. Where the variance reduction actually comes from, argued rather than asserted. 446 will use this; the out-of-bag estimate is the part most courses skip.
60. Day 60 (systems): Impossibility of Distributed Consensus with One Faulty Process — Fischer, Lynch, Paterson, 1985. Six pages that bound what 452 is about to ask you to build. Read it on a day with nothing to implement — the proof deserves the attention.
61. Day 61 (AI): Understanding Deep Learning Requires Rethinking Generalization — Zhang, Bengio, Hardt, Recht, Vinyals, 2017. The random-label experiment that broke the standard capacity story. Read it in the same week 446 teaches you the standard capacity story.
62. Day 62 (systems): The Log-Structured Merge-Tree (LSM-Tree) — O'Neil, Cheng, Gawlick, O'Neil, 1996. The other half of the storage-engine argument, and the one ferrodb did not take. Read it knowing exactly what your B-tree cost you on write.
63. Day 63 (AI): Reconciling Modern Machine Learning Practice and the Bias-Variance Trade-off — Belkin, Hsu, Ma, Mandal, 2019. Double descent, stated carefully. Read it against the U-shaped curve 446 draws on the board this week and decide which you believe when.
64. Day 64 (AI): A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting — Freund, Schapire, 1997. AdaBoost, and the training-error bound that made it surprising. Read the bound; it is the reason boosting was interesting before it was standard.
65. Day 65 (systems): MapReduce: Simplified Data Processing on Large Clusters — Dean, Ghemawat, 2004. The programming model that made a cluster look like a function. Read the fault-tolerance section closely; that is the part the model is actually buying.
66. Day 66 (AI): Maximum Likelihood from Incomplete Data via the EM Algorithm — Dempster, Laird, Rubin, 1977. EM as one idea rather than a recipe per model. Read the convergence argument; the derivation is what makes k-means obvious later.
67. Day 67 (AI): Support-Vector Networks — Cortes, Vapnik, 1995. The margin argument in its original form. 446 teaches the dual; the paper is where the soft margin comes from and why.
68. Day 68 (AI): Greedy Function Approximation: A Gradient Boosting Machine — Friedman, 2001. Boosting reframed as gradient descent in function space. Read it after AdaBoost so the reframing is visibly a generalization.
69. Day 69 (systems): Bigtable: A Distributed Storage System for Structured Data — Chang et al., 2006. An LSM engine, a lock service and a data model, described as one system. You have now written two of the three pieces.
70. Day 70 (AI): On Calibration of Modern Neural Networks — Guo, Pleiss, Sun, Weinberger, 2017. Modern networks are confidently wrong, and temperature scaling mostly fixes it. Your evaluation script should report calibration from now on.
71. Day 71 (AI): Hidden Technical Debt in Machine Learning Systems — Sculley et al., 2015. The paper about everything around the model. Read it while you are the entire team, so the failure modes are recognisable when you are not.
72. Day 72 (AI): Visualizing Data using t-SNE — van der Maaten, Hinton, 2008. Read it for the honesty about what the plot does not mean — cluster sizes and distances between clusters, both of which people read anyway.
73. Day 73 (systems): Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services — Gilbert, Lynch, 2002. CAP as an actual theorem with actual definitions, which is not what the slogan says. Read the definitions first and the conclusion second.
74. Day 74 (AI): k-means++: The Advantages of Careful Seeding — Arthur, Vassilvitskii, 2007. A change to the initialization with a proof attached. The clearest small example of theory that changed practice.
75. Day 75 (AI): Auto-Encoding Variational Bayes — Kingma, Welling, 2014. The reparameterization trick, which is the part to understand: it is what makes the gradient exist at all.
76. Day 76 (systems): Time, Clocks, and the Ordering of Events in a Distributed System — Lamport, 1978. Happens-before, and the reason a distributed system cannot simply read a clock. Everything in 452 after this depends on it.
77. Day 77 (AI): Generative Adversarial Networks — Goodfellow et al., 2014. The minimax formulation and the theoretical optimum. Read the proof of the global optimum, then note how little of it survives contact with training.
78. Day 78 (systems): The Chubby Lock Service for Loosely-Coupled Distributed Systems — Burrows, 2006. Consensus packaged as a product, with the operational surprises admitted. The section on how clients misused it is the valuable part.
79. Day 79 (AI): Denoising Diffusion Probabilistic Models — Ho, Jain, Abbeel, 2020. The simplification from the variational bound to a plain noise-prediction loss is the whole paper. Follow that derivation specifically.
80. Day 80 (systems): Paxos Made Simple — Lamport, 2001. Read it after Raft, not before: the comparison is the lesson, and Raft was explicitly written because this paper is hard.
81. Day 81 (AI): Semi-Supervised Classification with Graph Convolutional Networks — Kipf, Welling, 2017. The renormalized propagation rule, derived from a spectral argument and then justified empirically. Both halves matter.
82. Day 82 (AI): A Simple Framework for Contrastive Learning of Visual Representations — Chen, Kornblith, Norouzi, Hinton, 2020. The ablation on augmentations is the paper. Read it as a study of what the pretext task is actually teaching.
83. Day 83 (systems): Chain Replication for Supporting High Throughput and Availability — van Renesse, Schneider, 2004. Strong consistency with a much simpler protocol than consensus, by constraining the topology. Read it as a lesson in changing the problem.
84. Day 84 (AI): Learning Transferable Visual Models From Natural Language Supervision — Radford et al., 2021. CLIP: the supervision signal is the contribution, not the architecture. Note how much of the paper is dataset and evaluation work.
85. Day 85 (AI): Momentum Contrast for Unsupervised Visual Representation Learning — He, Fan, Wu, Xie, Girshick, 2020. The queue and the momentum encoder solve the batch-size problem SimCLR papers over. Read the two together and say which constraint each is fighting.
86. Day 86 (AI): "Why Should I Trust You?": Explaining the Predictions of Any Classifier — Ribeiro, Singh, Guestrin, 2016. LIME, and the local-fidelity idea. Read the failure cases at the end as carefully as the method.
87. Day 87 (systems): Spanner: Google's Globally-Distributed Database — Corbett et al., 2012. TrueTime buys external consistency by making clock uncertainty explicit rather than pretending it is zero. Read it after Lamport, on purpose.
88. Day 88 (AI): A Unified Approach to Interpreting Model Predictions — Lundberg, Lee, 2017. SHAP, and the axioms that make it the unique attribution under them. Read the axioms; they are the argument.
89. Day 89 (AI): An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale — Dosovitskiy et al., 2021. The inductive-bias argument, tested by scale. Read the data-size ablation — it is the part that explains why this took until 2021.
90. Day 90 (AI): The Bitter Lesson — Sutton, 2019. Not a paper, and worth an hour anyway. Argue with it in the card: your whole systems pillar is a bet that the details still matter.
91. Day 91 (systems): The Tail at Scale — Dean, Barroso, 2013. Why the 99th percentile is the number that matters once a request fans out, and the techniques that fight it. Read it before you benchmark anything distributed.
92. Day 92 (AI): Deep Learning with Differential Privacy — Abadi et al., 2016. The moments accountant, and what a privacy budget costs in accuracy. Read it as an example of a constraint stated precisely enough to optimize against.
93. Day 93 (AI): Datasheets for Datasets — Gebru et al., 2021. What a dataset should tell you before you train on it. Write one for whatever data your 446 project uses — it takes an hour and it is the difference between a result and a claim.
94. Day 94 (systems): Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web — Karger et al., 1997. The hash ring, from the paper that introduced it. You built a partitioner on day 73; this is the version that survives a node joining.
95. Day 95 (AI): Deep Contextualized Word Representations (ELMo) — Peters et al., 2018. Contextual embeddings before the transformer took over. Read it for the layer-wise analysis: different layers encode different things, which is still the most useful finding in it.
96. Day 96 (systems): Dapper, a Large-Scale Distributed Systems Tracing Infrastructure — Sigelman et al., 2010. How you find out what a distributed system actually did. Sampling and the annotation API are the two decisions worth stealing.
97. Day 97 (AI): Universal Language Model Fine-tuning for Text Classification (ULMFiT) — Howard, Ruder, 2018. Discriminative fine-tuning and gradual unfreezing, from before "just fine-tune it" was obvious. The schedule tricks still work and are still mostly ignored.
98. Day 98 (systems): Chord: A Scalable Peer-to-peer Lookup Service for Internet Applications — Stoica, Morris, Karger, Kaashoek, Balakrishnan, 2001. Consistent hashing turned into a routing structure with a proof about hop count. Read the finger table as a data structure, not as a protocol.
99. Day 99 (AI): ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators — Clark, Luong, Le, Manning, 2020. A cheaper pretraining objective that beats masked LM at the same compute. Read it as a compute-efficiency argument, which is the argument that keeps mattering.
100. Day 100 (AI): SQuAD: 100,000+ Questions for Machine Comprehension of Text — Rajpurkar, Zhang, Lopyrev, Liang, 2016. How the dataset was built is the paper. Read the collection protocol and then ask what a model could exploit in it.
101. Day 101 (systems): Scaling Memcache at Facebook — Nishtala et al., 2013. Caching as a distributed-systems problem: stampedes, leases, invalidation, cross-region. The operational detail is the value.
102. Day 102 (AI): Chain-of-Thought Prompting Elicits Reasoning in Large Language Models — Wei et al., 2022. Read the scale plot: the effect does not exist below a size threshold, which is the part that makes the result interesting and fragile.
103. Day 103 (AI): Longformer: The Long-Document Transformer — Beltagy, Peters, Cohan, 2020. Sliding-window plus global attention, with the cost argument made explicitly. Compare it against what FlashAttention did to the same problem from the hardware side.
104. Day 104 (AI): RoFormer: Enhanced Transformer with Rotary Position Embedding — Su et al., 2021. Rotary embeddings, derived from the property you actually want: attention that depends on relative position. Read the derivation, not the implementation.
105. Day 105 (systems): Kafka: a Distributed Messaging System for Log Processing — Kreps, Narkhede, Rao, 2011. The log as a primitive other systems are built on — the same object as your WAL and your Raft log, sold as infrastructure.
106. Day 106 (AI): DistilBERT, a distilled version of BERT — Sanh, Debut, Chaumond, Wolf, 2019. Distillation applied to the encoder you fine-tuned in the summer, with the ablation on which loss terms matter. A practical version of the day-56 paper.
107. Day 107 (AI): Model Cards for Model Reporting — Mitchell et al., 2019. The reporting standard to apply to your own 446 artifact today, while every number is still reproducible from a command you remember.
108. Day 108 (AI): Climbing towards NLU: On Meaning, Form, and Understanding in the Age of Data — Bender, Koller, 2020. The argument you should be able to state fairly whether or not you agree with it. Write the strongest version of the counterargument in your card.
109. Day 109 (systems): Conflict-free Replicated Data Types — Shapiro, Preguiça, Baquero, Zawirski, 2011. Convergence without consensus, by constraining the operations. Read it directly after 2PC — it is the other way out of the same problem.
110. Day 110 (AI): Holistic Evaluation of Language Models (HELM) — Liang et al., 2022. Evaluation designed as a system, with coverage stated as a matrix. This is the shape your own evaluation work should take next year.
111. Day 111 (AI): Deep Reinforcement Learning from Human Preferences — Christiano et al., 2017. The reward model, before language models used it. Read it now so that InstructGPT later is an application rather than a revelation.
112. Day 112 (systems): The Design Philosophy of the DARPA Internet Protocols — Clark, 1988. The priority list that produced TCP/IP, in the designer's own order. Read it before you implement the stack, and note which goal your version quietly drops.
113. Day 113 (AI): Training Language Models to Follow Instructions with Human Feedback — Ouyang et al., 2022. InstructGPT. Read the data-collection sections as carefully as the method: most of the work is annotation infrastructure.
114. Day 114 (systems): BBR: Congestion-Based Congestion Control — Cardwell, Cheng, Gunn, Yeganeh, Jacobson, 2016. Congestion control that models the bottleneck instead of treating loss as the signal. Read it against Jacobson 1988, which the same person wrote 28 years earlier.
115. Day 115 (AI): Direct Preference Optimization: Your Language Model is Secretly a Reward Model — Rafailov et al., 2023. The derivation that removes the reward model entirely. Read it against yesterday's implementation, which you now have a reason to delete.
116. Day 116 (systems): A Protocol for Packet Network Intercommunication — Cerf, Kahn, 1974. TCP and IP before they were separated, and the gateway argument that made internetworking possible. Read it the week you write the header parser.
117. Day 117 (AI): Beyond the Imitation Game: Quantifying and Extrapolating the Capabilities of Language Models — Srivastava et al., 2023. BIG-bench, and the tasks where scale does not help. Read the breakdown of task types — that is where research questions come from.
118. Day 118 (AI): TruthfulQA: Measuring How Models Mimic Human Falsehoods — Lin, Hilton, Evans, 2022. A benchmark built adversarially against the training distribution. Read the construction method; it is a template for building an evaluation that is not already solved.
119. Day 119 (systems): Random Early Detection Gateways for Congestion Avoidance — Floyd, Jacobson, 1993. Queue management as the other half of congestion control. Read it against the AIMD you derived — this is the router's side of the same negotiation.
120. Day 120 (AI): GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism — Huang et al., 2019. The bubble is the cost, and micro-batching is the fix. Draw the pipeline schedule yourself before reading their figure.
121. Day 121 (AI): Fast Transformer Decoding: One Write-Head is All You Need — Shazeer, 2019. Multi-query attention, from the memory-bandwidth argument. Four pages, and it is the reason inference stacks look the way they do.
122. Day 122 (AI): GQA: Training Generalized Multi-Query Transformer Models from Multi-Head Checkpoints — Ainslie et al., 2023. The interpolation between yesterday's two extremes, plus a recipe for converting an existing checkpoint. Read them as a pair.
123. Day 123 (systems): Kademlia: A Peer-to-peer Information System Based on the XOR Metric — Maymounkov, Mazières, 2002. Routing by a metric that is symmetric and unidirectional at once, which is the trick. Read it against Chord and say which one you would implement and why.
124. Day 124 (AI): Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism — Shoeybi et al., 2019. Tensor parallelism explained as where you cut the matrix multiply. Read it with your own matmul in front of you — the cut is the whole idea.
125. Day 125 (AI): ZeRO: Memory Optimizations Toward Training Trillion Parameter Models — Rajbhandari, Rajbhandari, Ruwase, He, 2020. The accounting of what is actually in GPU memory during training — states, gradients, activations — and what each stage of partitioning removes. Read it as an accounting paper.
126. Day 126 (AI): Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer — Shazeer et al., 2017. Conditional computation with the load-balancing problem stated honestly. Everything current about MoE is a footnote to this.
127. Day 127 (systems): ZooKeeper: Wait-free Coordination for Internet-scale Systems — Hunt, Konar, Junqueira, Reed, 2010. Coordination as a filesystem-shaped API, with the ordering guarantees stated precisely. Read the API section as a design lesson in what to expose.
128. Day 128 (AI): Efficient Memory Management for Large Language Model Serving with PagedAttention — Kwon et al., 2023. The KV cache managed like virtual memory — the paper where your OS work and your ML work are visibly the same skill. Read it the same week you finish a page table.
129. Day 129 (AI): Fast Inference from Transformers via Speculative Decoding — Leviathan, Kalman, Matias, 2023. The acceptance criterion is the paper: it makes the output distribution identical to the target model's. Read the proof, then decide whether you believe the speedup claim.
130. Day 130 (systems): Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases — Verbitski et al., 2017. "The log is the database" taken literally, with the network cost as the thing being optimized. Read it against your own WAL, which is the same idea at one machine's scale.
131. Day 131 (AI): LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale — Dettmers, Lewis, Belkada, Zettlemoyer, 2022. The outlier features are the finding, not the kernel. Read it as an empirical discovery about what transformers put in their activations.
132. Day 132 (systems): Hints for Computer System Design — Lampson, 1983. Thirty years of systems judgment as a list of hints, each with the counterexample attached. Read it once a year; the hints you disagree with change, which is the useful part.
133. Day 133 (AI): GPTQ: Accurate Post-Training Quantization for Generative Pre-trained Transformers — Frantar, Ashkboos, Hoefler, Alistarh, 2023. Second-order information used to decide rounding. Read it as the strongest version of the problem you attempted yesterday by hand.
134. Day 134 (systems): Managing Update Conflicts in Bayou, a Weakly Connected Replicated Storage System — Terry et al., 1995. Application-specific conflict resolution, decades before anyone called it offline-first. Read the dependency-check and merge-procedure design.
135. Day 135 (AI): LLaMA: Open and Efficient Foundation Language Models — Touvron et al., 2023. The training-compute versus inference-compute argument, made explicitly: train longer on more tokens so that serving is cheap. That trade is the flagship's subject.
136. Day 136 (AI): Highly Available Transactions: Virtues and Limitations — Bailis et al., 2014. Which isolation levels are achievable without giving up availability, stated as a hierarchy. The clearest map of the space CSE 452 walked you through.
137. Day 137 (systems): End-to-End Arguments in System Design — Saltzer, Reed, Clark, 1984. Reread it — you have now written the layers it is about. The second reading is a different paper from the first, which is the point of rereading.
138. Day 138 (AI): A Few Useful Things to Know About Machine Learning — Domingos, 2012. The folk knowledge that courses assume and rarely state, from a UW professor. Read it as a checklist against your own last three experiments.
139. Day 139 (AI): Language Models are Few-Shot Learners — Brown et al., 2020. GPT-3, read now rather than in 2020: as a scaling experiment with an evaluation appendix, most of which has since been contested. Note which claims survived.
140. Day 140 (AI): Emergent Abilities of Large Language Models — Wei et al., 2022. Then read the objection — that emergence can be an artefact of the metric — and decide what evidence would settle it. This is the shape of a good research question.
141. Day 141 (AI): The NumPy array: a structure for efficient numerical computation — van der Walt, Colbert, Varoquaux, 2011. Shape, stride, offset and views, described by the people who chose them. Read it as the specification for the thing you are about to write, and note every decision they defend rather than assert.
142. Day 142 (systems): Practical Byzantine Fault Tolerance — Castro, Liskov, 1999. The paper that made Byzantine agreement cheap enough to run. Read the view-change protocol carefully — it is where the complexity actually lives, and where every later BFT paper claims to improve.
143. Day 143 (AI): Neural Architectures for Named Entity Recognition — Lample, Ballesteros, Subramanian, Kawakami, Dyer, 2016. The LSTM-CRF that was the NER baseline for four years, with the transition-based alternative in the same paper. Read it as the strongest pre-BERT number your own tagger has to beat.
144. Day 144 (systems): The Byzantine Generals Problem — Lamport, Shostak, Pease, 1982. The impossibility for three generals, then the algorithm for four, worked in full. Do the three-general case on paper before reading their argument; it is the only way the bound stops feeling arbitrary.
145. Day 145 (AI): End-to-end Sequence Labeling via Bi-directional LSTM-CNNs-CRF — Ma, Hovy, 2016. The same architecture as yesterday from a different group in the same month, with character CNNs instead of character LSTMs. Read them as a pair and decide what the difference is actually worth.
146. Day 146 (systems): Distributed Snapshots: Determining Global States of Distributed Systems — Chandy, Lamport, 1985. The marker algorithm, and the definition of a consistent cut that makes it correct. Read it before you write it — the proof is short and the algorithm is unmotivated without it.
147. Day 147 (AI): Accurate Unlexicalized Parsing — Klein, Manning, 2003. Most of lexicalized parsing's gain recovered by splitting states by hand. Read it as an ablation of a whole subfield, and as evidence that a strong baseline is usually cheaper than a new model.
148. Day 148 (AI): Constituency Parsing with a Self-Attentive Encoder — Kitaev, Klein, 2018. The same chart decoder as yesterday under a transformer encoder, with an ablation separating content from position. Read the ablation: it is the clearest statement anywhere of what the encoder is contributing.
149. Day 149 (systems): Virtual Time and Global States of Distributed Systems — Mattern, 1988. Vector clocks derived properly, with the lattice structure that makes them the right answer rather than a hack. Read it after implementing them, so the algebra lands on code you already have.
150. Day 150 (systems): The Humble Programmer — Dijkstra, 1972. The argument that our capacity to build is limited by our capacity to reason about what we built, made the year the field admitted it had a crisis. Read it the day before you scope a quarter, and cut the plan that fails his test.
151. Day 151 (AI): A Fast and Accurate Dependency Parser using Neural Networks — Chen, Manning, 2014. The paper that replaced millions of sparse features with a small dense network and got faster as well as better. Read the feature-template table — it is what the embedding layer is standing in for.
152. Day 152 (AI): Deep Biaffine Attention for Neural Dependency Parsing — Dozat, Manning, 2017. Two small MLPs and a bilinear score, and it beat everything. Read the dimensionality argument for why the biaffine form is the right one, then check it against the attention you already implemented.
153. Day 153 (systems): Unreliable Failure Detectors for Reliable Distributed Systems — Chandra, Toueg, 1996. The paper that says exactly how much failure detection consensus needs, which is the constructive other half of FLP. Read it against the day-60 impossibility result you already have a card for.
154. Day 154 (AI): Building a Large Annotated Corpus of English: The Penn Treebank — Marcus, Santorini, Marcinkiewicz, 1993. How the annotation was actually produced — the guidelines, the two-stage process, the agreement numbers. You are about to build an annotation tool; this is the paper that says what one is for.
155. Day 155 (AI): Universal Dependencies v1: A Multilingual Treebank Collection — Nivre et al., 2016. One annotation scheme negotiated across forty languages, and the compromises that took. Read the design principles section as an exercise in specifying a label set you cannot later change.
156. Day 156 (AI): Green AI — Schwartz, Dodge, Smith, Etzioni, 2019. The argument for reporting compute alongside accuracy, from the institute across the street. Decide today whether your own results tables will carry a cost column, because retrofitting one is a lie.
157. Day 157 (systems): Wait-Free Synchronization — Herlihy, 1991. The consensus hierarchy: which primitives can implement which objects wait-free, proven rather than asserted. It is why compare-and-swap is in every instruction set and test-and-set is not enough.
158. Day 158 (AI): Transition-Based Dependency Parsing with Stack Long Short-Term Memory — Dyer, Ballesteros, Ling, Matthews, Smith, 2015. A recurrent network over the parser's own stack, so the state representation is learned rather than templated. Noah Smith is at UW; read it as an example of what the group next door builds.
159. Day 159 (AI): Class-Based n-gram Models of Natural Language — Brown, deSouza, Mercer, Della Pietra, Lai, 1992. Brown clusters: distributional word classes learned by maximizing mutual information, thirty years before anyone said embedding. Read it and note how much of word2vec's intuition is already stated here.
160. Day 160 (systems): PNUTS: Yahoo!'s Hosted Data Serving Platform — Cooper, Ramakrishnan, Srivastava, Silberstein, Bohannon, Jacobsen, Puz, Weaver, Yerneni, 2008. Per-record timeline consistency with record-level mastership — a consistency model chosen by asking what the applications could actually tolerate. Read it as the counterexample to picking a model off a hierarchy.
161. Day 161 (AI): Byte Pair Encoding is Suboptimal for Language Model Pretraining — Bostrom, Durrett, 2020. A controlled comparison of BPE against unigram-LM tokenization, with morphology as the diagnostic. Read it the day you write a tokenizer, because it names the choice you are about to make by default.
162. Day 162 (systems): Linearizability: A Correctness Condition for Concurrent Objects — Herlihy, Wing, 1990. The definition your day-83 checker has been enforcing without you having read where it comes from. Read the composability theorem — it is the reason linearizability is the condition people chose.
163. Day 163 (AI): Between words and characters: A Brief History of Open-Vocabulary Modeling and Tokenization in NLP — Mielke et al., 2021. The whole design space laid out, from morphological analysers to bytes, with the trade-off stated at each point. Read it after your own tokenizer exists so you can locate it on their map.
164. Day 164 (systems): Flexible Paxos: Quorum Intersection Revisited — Howard, Malkhi, Spiegelman, 2016. Majorities were never required — only that the two phases' quorums intersect. A small result that invalidates an assumption everyone made, which is the kind of paper worth studying for its shape.
165. Day 165 (AI): How Good is Your Tokenizer? On the Monolingual Performance of Multilingual Language Models — Rust, Pfeiffer, Vulić, Ruder, Gurevych, 2021. They separate the tokenizer's contribution from the model's by swapping only the tokenizer. Read the experimental design — that isolation is the thing to copy, not the result.
166. Day 166 (AI): CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation — Clark, Garrette, Turc, Wieting, 2021. The other end of the design space: no vocabulary at all, with downsampling to make it affordable. Read it against yesterday's paper and decide what a vocabulary is actually buying you.
167. Day 167 (systems): Calvin: Fast Distributed Transactions for Partitioned Database Systems — Thomson, Diamond, Weng, Ren, Shao, Abadi, 2012. Agree on the order first, then execute deterministically, and two-phase commit disappears. Read it directly after your own 2PC blocked on day 98 — this is the design that refuses the problem.
168. Day 168 (AI): A Maximum Entropy Approach to Natural Language Processing — Berger, Della Pietra, Della Pietra, 1996. Logistic regression derived from a principle rather than assumed as a loss. Read the duality argument once properly; every log-linear model in the course is a corollary of it.
169. Day 169 (AI): ByT5: Towards a token-free future with pre-trained byte-to-byte models — Xue, Barua, Constant, Al-Rfou, Narang, Kale, Roberts, Raffel, 2021. Bytes all the way down, with the compute cost stated honestly and the noise-robustness gain measured. Read the cost table: it is the argument against, written by the people arguing for.
170. Day 170 (AI): The Pile: An 800GB Dataset of Diverse Text for Language Modeling — Gao et al., 2020. A corpus documented component by component, with the composition argued for rather than scraped. Read it as the datasheet you will have to write for whatever data your lab component consumes.
171. Day 171 (systems): Large-scale Incremental Processing Using Distributed Transactions and Notifications — Peng, Dabek, 2010. Percolator: transactions bolted onto Bigtable so an index can be updated incrementally instead of rebuilt. Read the two-phase commit implemented in client library code — no coordinator, just columns.
172. Day 172 (AI): Deduplicating Training Data Makes Language Models Better — Lee, Ippolito, Nystrom, Zhang, Eck, Callison-Burch, Carlini, 2022. Duplication inflates benchmark numbers and increases memorisation, both measured. Read it the day after you build the near-duplicate detector, and check your own corpus against their rates.
173. Day 173 (AI): Documenting Large Webtext Corpora: A Case Study on the Colossal Clean Crawled Corpus — Dodge, Sap, Marasović, Agnew, Ilharco, Groeneveld, Mitchell, Gardner, 2021. What the filters actually removed, measured — including whole dialects. Read it as the audit you should run on your own corpus rather than as a criticism of someone else's.
174. Day 174 (AI): An Empirical Study of Smoothing Techniques for Language Modeling — Chen, Goodman, 1996. The comparison that settled n-gram smoothing, with every method reimplemented under one protocol. It is the best example in NLP of a paper whose contribution is the experiment, not the method.
175. Day 175 (systems): Don't Settle for Eventual: Scalable Causal Consistency for Wide-Area Storage with COPS — Lloyd, Freedman, Kaminsky, Andersen, 2011. Causal consistency made to scale by tracking dependencies explicitly, with the metadata cost paid openly. Read it against the vector clocks you implemented on day 145 — this is what they cost in production.
176. Day 176 (AI): WiC: the Word-in-Context Dataset for Evaluating Context-Sensitive Meaning Representations — Pilehvar, Camacho-Collados, 2018. A sense task framed as binary same-meaning judgements, so it needs no sense inventory. Read the construction: it is the cleanest example of turning an unanswerable annotation problem into an answerable one.
177. Day 177 (AI): How Contextual are Contextualized Word Representations? Comparing the Geometry of BERT, ELMo, and GPT-2 Embeddings — Ethayarajh, 2019. Contextual vectors occupy a narrow cone, and self-similarity falls with depth — measured, not asserted. Read it before you trust cosine similarity between two contextual vectors ever again.
178. Day 178 (systems): Amdahl's Law in the Multicore Era — Hill, Marty, 2008. Amdahl applied to how you spend a fixed transistor budget across cores, with asymmetric and dynamic designs compared. Four pages, and it reframes the law from a warning into a design tool.
179. Day 179 (AI): Deep Semantic Role Labeling: What Works and What's Next — He, Lee, Lewis, Zettlemoyer, 2017. A strong neural SRL system followed by an error analysis that says exactly which linguistic phenomena remain broken. The error analysis is the model for the one you will write in March.
180. Day 180 (systems): Simple Testing Can Prevent Most Critical Failures — Yuan et al., 2014. An analysis of real catastrophic failures in distributed systems, and how many were reachable by three nodes and a unit test of the error handler. Read it and then look at your own empty catch blocks.
181. Day 181 (AI): The Berkeley FrameNet Project — Baker, Fillmore, Lowe, 1998. Frames as the unit of meaning, with the lexicographic method that produced them. Read it against PropBank and write the one-paragraph answer to why two role inventories exist at all.
182. Day 182 (systems): The Case for Energy-Proportional Computing — Barroso, Hölzle, 2007. Servers spend their lives at 10-50% utilisation and are least efficient exactly there. Read the utilisation histogram, then ask what your own GPU box's histogram looks like.
183. Day 183 (AI): The Proposition Bank: An Annotated Corpus of Semantic Roles — Palmer, Gildea, Kingsbury, 2005. How a million-word role-annotated corpus was actually built: frame files, the annotation interface, the double-blind pass and adjudication. This is the process your annotation tool has to support.
184. Day 184 (AI): Distant supervision for relation extraction without labeled data — Mintz, Bills, Snow, Jurafsky, 2009. Align a knowledge base to text and call every co-occurrence a label. Read it for the assumption stated in one sentence, which is both the whole idea and the whole problem.
185. Day 185 (systems): Dark Silicon and the End of Multicore Scaling — Esmaeilzadeh, Blem, St. Amant, Sankaralingam, Burger, 2011. The projection that most of a chip must stay switched off, and the speedup ceiling that implies. Read it as the reason accelerators exist, which is the reason your CUDA work has a point.
186. Day 186 (AI): Automatic Labeling of Semantic Roles — Gildea, Jurafsky, 2002. The paper that created semantic role labelling as a task, with the feature set that every later system inherited. Read the feature list as an inventory of what syntax contributes to semantics.
187. Day 187 (AI): Position-aware Attention and Supervised Data Improve Slot Filling — Zhang, Zhong, Chen, Angeli, Manning, 2017. TACRED, and the finding that a large supervised set beats a clever distant-supervision model. Read the data-collection section as the argument that annotation is a modelling decision.
188. Day 188 (AI): Matching the Blanks: Distributional Similarity for Relation Learning — Baldini Soares, FitzGerald, Ling, Kwiatkowski, 2019. A pretraining objective invented for one task, with an ablation over six ways of marking the entity spans. The span-marking ablation is the useful part and takes an afternoon to reproduce.
189. Day 189 (systems): A Case for Redundant Arrays of Inexpensive Disks (RAID) — Patterson, Gibson, Katz, 1988. Reliability computed from component MTTF, then designed around, in a paper that named an entire product category. Read the arithmetic in section 3 — it is the dependability chapter made concrete.
190. Day 190 (AI): Zero-Shot Relation Extraction via Reading Comprehension — Levy, Seo, Choi, Zettlemoyer, 2017. Relations reformulated as questions, so an unseen relation needs a template rather than data. Read it as the earliest clean example of task reformulation, which is what prompting later became.
191. Day 191 (AI): Language Models as Knowledge Bases? — Petroni, Rocktäschel, Lewis, Bakhtin, Wu, Miller, Riedel, 2019. Probing a language model for relational facts with cloze templates, against a real extraction pipeline as the baseline. Read the baseline comparison and note how much of the effect is template sensitivity.
192. Day 192 (AI): Abstract Meaning Representation for Sembanking — Banarescu et al., 2013. A whole-sentence semantic representation designed to be annotatable by humans at speed, which is the constraint that shaped every choice in it. Read the design rationale, not the formalism.
193. Day 193 (systems): What Every Programmer Should Know About Memory — Drepper, 2007. A hundred pages on the memory hierarchy from the person who wrote the libc allocator, with measurements throughout. Read the cache and prefetching sections against your simulator and see which of your results it predicts.
194. Day 194 (AI): Introduction to the CoNLL-2003 Shared Task: Language-Independent Named Entity Recognition — Tjong Kim Sang, De Meulder, 2003. The task definition, the data split and the scorer that the field then used for twenty years. Read it to see how much of a benchmark's longevity comes from the scorer being unambiguous.
195. Day 195 (AI): Don't Stop Pretraining: Adapt Language Models to Domains and Tasks — Gururangan, Marasović, Swayamdipta, Lo, Beltagy, Downey, Smith, 2020. Domain- and task-adaptive pretraining, with a clean factorial design across four domains and eight tasks. It is from the group you are trying to work with; read the experimental grid as a template for your own.
196. Day 196 (systems): The Case for Learned Index Structures — Kraska, Beutel, Chi, Dean, Polyzotis, 2017. An index as a learned CDF, argued from cache behaviour rather than from novelty. Read it the week you finish the cache simulator: the whole case rests on numbers your simulator can check.
197. Day 197 (AI): End-to-end Neural Coreference Resolution — Lee, He, Lewis, Zettlemoyer, 2017. No mention detector, no parser — score every span and prune. Read the pruning: the whole system is a careful answer to the quadratic blowup you wrote about on day 182.
198. Day 198 (systems): Roofline: An Insightful Visual Performance Model for Multicore Architectures — Williams, Waterman, Patterson, 2009. Arithmetic intensity against attainable performance, on one plot, with the optimisation ceilings drawn in. Every performance conversation you have for the next two years can be held on this diagram.
199. Day 199 (AI): Higher-order Coreference Resolution with Coarse-to-fine Inference — Lee, He, Zettlemoyer, 2018. A coarse scorer to prune before the expensive one, plus antecedent refinement. Read the coarse-to-fine trick as a systems decision inside a model, which is exactly what it is.
200. Day 200 (systems): In-Datacenter Performance Analysis of a Tensor Processing Unit — Jouppi et al., 2017. A production accelerator described with a roofline for every workload, and the honest finding that most of them are memory bound. Read it the week before you write a tiled GEMM.
201. Day 201 (AI): SpanBERT: Improving Pre-training by Representing and Predicting Spans — Joshi, Chen, Liu, Weld, Zettlemoyer, Levy, 2020. Mask contiguous spans and predict them from the boundaries, because the downstream tasks are span tasks. Read the ablation separating span masking from the boundary objective; only one of them is doing the work.
202. Day 202 (AI): BERT for Coreference Resolution: Baselines and Analysis — Joshi, Levy, Zettlemoyer, Weld, 2019. Swap the encoder, keep the model, and analyse what improved. The analysis section — which error categories moved and which did not — is the shape of the writeup you owe in March.
203. Day 203 (systems): EIE: Efficient Inference Engine on Compressed Deep Neural Network — Han, Liu, Mao, Pu, Pedram, Horowitz, Dally, 2016. Sparsity and quantization taken all the way into the datapath, with energy per operation as the metric. Read it against your own GEMM: it is what happens when the memory wall is attacked at the hardware level.
204. Day 204 (AI): The Winograd Schema Challenge — Levesque, Davis, Morgenstern, 2012. A test designed so that statistics over the corpus should not suffice, with the design constraints stated as rules. Read it and then decide whether the constraints held, which is a live question.
205. Day 205 (AI): CoNLL-2012 Shared Task: Modeling Multilingual Unrestricted Coreference in OntoNotes — Pradhan, Moschitti, Xue, Uryupina, Zhang, 2012. The averaged metric everyone reports, and the reason it is an average of three metrics that disagree. Read the task setup before you claim your system beats a published number.
206. Day 206 (AI): Centering: A Framework for Modeling the Local Coherence of Discourse — Grosz, Joshi, Weinstein, 1995. Coherence as constraints on which entity is in focus across adjacent sentences, stated precisely enough to implement. Read it and then implement the transition types; the theory is testable, which is rare.
207. Day 207 (systems): Coordination Avoidance in Database Systems — Bailis, Fekete, Franklin, Ghodsi, Hellerstein, Stoica, 2014. Invariant confluence: exactly when transactions need not coordinate at all. It is speculation one layer up — assume the common case, detect the violation, recover — so read it beside the reorder buffer and write down what plays the part of the flush.
208. Day 208 (AI): Modeling Local Coherence: An Entity-Based Approach — Barzilay, Lapata, 2008. Centering turned into a feature vector that a classifier can learn from, with three evaluation tasks. Read the evaluation design: they had to invent the tasks, and the tasks outlived the model.
209. Day 209 (AI): The Penn Discourse TreeBank 2.0. — Prasad, Dinesh, Lee, Miltsakaki, Robaldo, Joshi, Webber, 2008. A lexically grounded annotation scheme, chosen because it could be annotated reliably rather than because it was theoretically complete. Read the reliability argument — it is the correct reason to choose a scheme.
210. Day 210 (AI): WinoGrande: An Adversarial Winograd Schema Challenge at Scale — Sakaguchi, Le Bras, Bhagavatula, Choi, 2019. The answer to yesterday: crowdsource at scale, then adversarially filter out the items a model can shortcut. AFLite is the technique worth stealing for your own evaluation set.
211. Day 211 (systems): An Analysis of Network-Partitioning Failures in Cloud Systems — Alquraan, Takruri, Alfatafta, Al-Kiswany, 2018. A hundred and thirty-six real partition failures, categorised, with how each was found and how long it took to report. Read it on the day you write a status email: most of these bugs were invisible until someone described a symptom precisely.
212. Day 212 (AI): Survey Article: Inter-Coder Agreement for Computational Linguistics — Artstein, Poesio, 2008. Which kappa, when, and what chance agreement means for each. Read it before you report an agreement number, because most reported kappas use the wrong expected-agreement model.
213. Day 213 (AI): Cheap and Fast – But is it Good? Evaluating Non-Expert Annotations for Natural Language Tasks — Snow, O'Connor, Jurafsky, Ng, 2008. How many non-expert annotations equal one expert, measured per task. Read it as the budgeting model for whatever labelled data your lab component ends up needing.
214. Day 214 (systems): Efficient Processing of Deep Neural Networks: A Tutorial and Survey — Sze, Chen, Yang, Emer, 2017. Dataflows, reuse and energy for neural hardware, organised as a taxonomy rather than a product list. Read the data-reuse section against your tiled GEMM: it names what your tiling was doing.
215. Day 215 (AI): Towards a Human-like Open-Domain Chatbot — Adiwardana et al., 2020. They invent a human metric — sensibleness and specificity — and then show perplexity correlates with it. Read the correlation plot: it is a rare honest attempt to justify an automatic metric.
216. Day 216 (systems): SWIM: Scalable Weakly-consistent Infection-style Process Group Membership Protocol — Das, Gupta, Motivala, 2002. Failure detection separated from membership dissemination, with the detection time and false-positive rate both derived rather than tuned. A short protocol paper with real analysis in it — the right shape for a tired evening.
217. Day 217 (AI): MultiWOZ -- A Large-Scale Multi-Domain Wizard-of-Oz Dataset for Task-Oriented Dialogue Modelling — Budzianowski, Wen, Tseng, Casanueva, Ultes, Ramadan, Gašić, 2018. The Wizard-of-Oz collection protocol, and the annotation errors later versions spent years fixing. Read both the protocol and its corrections as one lesson about collecting dialogue data.
218. Day 218 (systems): MLPerf Inference Benchmark — Reddi et al., 2019. What it takes to make two systems' numbers comparable: fixed scenarios, latency bounds, accuracy targets and a load generator. Read the rules section as a design document for your own evaluation harness.
219. Day 219 (AI): Recipes for building an open-domain chatbot — Roller et al., 2020. Blending skills, and the finding that decoding-length control mattered as much as model scale. Read the human evaluation protocol; it is the most carefully described one in the dialogue literature.
220. Day 220 (AI): AllenNLP: A Deep Semantic Natural Language Processing Platform — Gardner et al., 2018. A research framework built around declarative configuration and reproducible experiments, from the institute you are trying to join. Read it for the abstractions, then decide which ones your own harness should have stolen.
221. Day 221 (systems): Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing — Zaharia et al., 2012. Fault tolerance by remembering the lineage of a computation instead of replicating its data. Read it as the cleanest example in the literature of a restriction — coarse-grained transformations — that buys a property.
222. Day 222 (AI): Data Statements for Natural Language Processing: Toward Mitigating System Bias and Enabling Better Science — Bender, Friedman, 2018. What a dataset must state about its speakers, its curation and its situation, from the linguist down the hall. Write one for the data you annotated this month; the schema is short and the exercise is not.
223. Day 223 (AI): Annotation Artifacts in Natural Language Inference Data — Gururangan, Swayamdipta, Levy, Schwartz, Bowman, Smith, 2018. A hypothesis-only model gets 67% on SNLI, which means the dataset leaks. Read it before you trust any number you produced this quarter, including your own annotation batch.
224. Day 224 (AI): Right for the Wrong Reasons: Diagnosing Syntactic Heuristics in Natural Language Inference — McCoy, Pavlick, Linzen, 2019. HANS: a test set built so that three named heuristics all fail, and models trained on SNLI collapse on it. Read the construction, then build the equivalent for your own task before the quarter ends.
225. Day 225 (systems): Large-scale cluster management at Google with Borg — Verma, Pedrosa, Korupolu, Oppenheimer, Tune, Wilkes, 2015. Ten years of running everyone's jobs on one cluster, with the quota, priority and preemption policy explained. Read it before you complain about a lab scheduler; every rule in it exists because something went wrong.
226. Day 226 (AI): Errudite: Scalable, Reproducible, and Testable Error Analysis — Wu, Ribeiro, Heer, Weld, 2019. Error analysis as queries over the whole dataset rather than as twenty cherry-picked examples, from a UW group. Read it and then check whether your buckets from day 223 would survive their three principles.
227. Day 227 (AI): Beyond Accuracy: Behavioral Testing of NLP Models with CheckList — Ribeiro, Wu, Guestrin, Singh, 2020. A test matrix of capabilities against test types, and commercial systems failing tests nobody had written. Read it as the argument that a single number is not an evaluation, which is the argument your component embodies.
228. Day 228 (AI): Language (Technology) is Power: A Critical Survey of "Bias" in NLP — Blodgett, Barocas, Daumé III, Wallach, 2020. A survey of 146 bias papers finding that most never say what harm they mean. Read it as an argument about specification, which is the same discipline as writing a measurable claim.
229. Day 229 (systems): TAO: Facebook's Distributed Data Store for the Social Graph — Bronson et al., 2013. A read-optimised graph store whose API was chosen by what the application actually asked for. Read the API section next to your evaluation component and ask whether yours was designed for its callers or for you.
230. Day 230 (AI): A Call for Clarity in Reporting BLEU Scores — Post, 2018. Two BLEU scores in two papers are usually not the same measurement, because tokenization and normalisation are unreported parameters. Comparability comes before significance: fix the measurement today, then let the test mean something.
231. Day 231 (AI): Dataset Cartography: Mapping and Diagnosing Datasets with Training Dynamics — Swayamdipta, Schwartz, Lourie, Wang, Hajishirzi, Smith, Choi, 2020. Confidence and variability across training turn a dataset into a map of easy, ambiguous and mislabelled regions. Run it on the data you annotated in February — it is the cheapest audit you will ever perform, and it is from the group you are joining.
232. Day 232 (systems): Anatomy of High-Performance Matrix Multiplication — Goto, van de Geijn, 2008. The layered blocking argument your tiled kernel is groping toward without knowing it: which operand gets which level of the hierarchy, and why the packing routine exists at all.
233. Day 233 (systems): Benchmarking GPUs to Tune Dense Linear Algebra — Volkov, Demmel, 2008. Where the registers-not-occupancy argument comes from. Read it today, because today is the day you stop adding threads and start giving each one more work.
234. Day 234 (systems): Out of the Tar Pit — Moseley, Marks, 2006. Accidental against essential complexity, argued at length. Read it the week before CSE 331 starts telling you the same thing in Java, so you arrive with the general form already in your head.
235. Day 235 (systems): Roofline: An Insightful Visual Performance Model for Multicore Architectures — Williams, Waterman, Patterson, 2009. The one performance model worth carrying for the rest of the plan. Read it the day you have a kernel whose arithmetic intensity you can compute by hand.
236. Day 236 (systems): Producing Wrong Data Without Doing Anything Obviously Wrong! — Mytkowicz, Diwan, Hauswirth, Sweeney, 2009. Link order and environment size change your measurements by more than your optimizations do. Read it before you believe any number you produced this week.
237. Day 237 (systems): How to Read a Paper — Keshav, 2007. Three passes, with a stated purpose for each. You are about to read eighty papers in eighty-four days; decide now which of them get the third pass.
238. Day 238 (systems): The Structure of the THE-Multiprogramming System — Dijkstra, 1968. Layering proposed as a way to make a correctness argument possible, not as a way to organise files. CSE 451 will ask you to add to a kernel that already has layers; this is what they were for.
239. Day 239 (AI): Distinctive Image Features from Scale-Invariant Keypoints — Lowe, 2004. SIFT, and more usefully the evaluation methodology: repeatability measured under a transformation you applied on purpose. Steal the methodology today and the detector tomorrow.
240. Day 240 (systems): Reflections on Trusting Trust — Thompson, 1984. Three pages that make the whole notion of "I read the source" conditional. Read it once a year and each time notice a different piece of your toolchain you have never questioned.
241. Day 241 (systems): Lottery Scheduling: Flexible Proportional-Share Resource Management — Waldspurger, Weihl, 1994. A scheduler whose fairness property is stated up front and then measured. That order — property, then implementation, then measurement — is the whole shape of this term.
242. Day 242 (systems): Data Movement Is All You Need: A Case Study on Optimizing Transformers — Ivanov, Dryden, Ben-Nun, Li, Hoefler, 2021. A taxonomy of transformer operators by whether they are compute or memory bound, with the fusion decisions falling out of it. Read it as the justification for the next four tensorforge steps.
243. Day 243 (AI): A Computational Approach to Edge Detection — Canny, 1986. An operator derived from three stated criteria rather than proposed and then justified. Read the derivation; the algorithm everybody implements is the last two pages.
244. Day 244 (systems): Meltdown: Reading Kernel Memory from User Space — Lipp et al., 2018. The consequence of the design decision you are reading about this week: the kernel mapped into every address space, cheaply, for twenty years. Read it while mprotect and the page table are fresh.
245. Day 245 (systems): Scheduler Activations: Effective Kernel Support for the User-Level Management of Parallelism — Anderson, Bershad, Lazowska, Levy, 1991. The interface problem between a user-level thread package and a kernel that does not know it exists — written here, by this department. Read it before you decide your thread pool is the kernel's equal.
246. Day 246 (systems): What Every Programmer Should Know About Memory — Drepper, 2007. A hundred pages on the memory hierarchy, and the reason half of this term's measurements come out the way they do. Read the cache and NUMA sections today; the rest can wait for the next catch-up day.
247. Day 247 (systems): The Linux Scheduler: a Decade of Wasted Cores — Lozi, Lepers, Funston, Gaud, Quéma, Fedorova, 2016. Four bugs that left cores idle while threads waited, in the scheduler everyone runs, found only because somebody built a visualiser. Read it as an argument for instrumenting your own run queue today rather than later.
248. Day 248 (AI): Image Quality Assessment: From Error Visibility to Structural Similarity — Wang, Bovik, Sheikh, Simoncelli, 2004. Why mean squared error is a bad metric for images, argued with pairs of images that have identical MSE and obviously different quality. You will need a metric next week; pick it now, with a reason.
249. Day 249 (systems): The Slab Allocator: An Object-Caching Kernel Memory Allocator — Bonwick, 1994. Object caching and constructor reuse, from the paper that put slabs in every kernel since. Read it against your own free list, which is currently doing the general thing for objects that are all one size.
250. Day 250 (systems): EIE: Efficient Inference Engine on Compressed Deep Neural Network — Han, Liu, Mao, Pu, Pedram, Horowitz, Dally, 2016. Compression treated as an architecture problem: the energy numbers per memory level are the argument, not the accuracy. Read the energy table before you decide quantization is about model size.
251. Day 251 (AI): SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models — Xiao, Lin, Seznec, Wu, Demouth, Han, 2023. The activation outlier problem, and a fix that moves difficulty from activations to weights with a single scaling factor. Read it as the reason your INT8 path will lose accuracy in exactly one place.
252. Day 252 (systems): How Amazon Web Services Uses Formal Methods — Newcombe, Rath, Zhang, Munteanu, Brooker, Deardeuff, 2015. Engineers using TLA+ on real systems, with the bugs it found listed and the ones it did not. Read it alongside CSE 331 as the industrial version of the same claim.
253. Day 253 (systems): Soft Updates: A Solution to the Metadata Update Problem in File Systems — Ganger, McKusick, Soules, Patt, 2000. Ordering enforced by dependency tracking rather than by synchronous writes or a journal. The third answer to crash consistency, and the one nobody teaches; read it so your own answer is a choice.
254. Day 254 (AI): Rapid Object Detection using a Boosted Cascade of Simple Features — Viola, Jones, 2001. A cascade is a scheduling decision: spend almost nothing on the windows that are obviously background. That idea outlived the features it was built on and is exactly what early-exit inference is.
255. Day 255 (AI): Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference — Jacob et al., 2018. The affine quantization scheme written out with the integer arithmetic that makes it exact, including the requantization multiplier. This is the arithmetic your kernel is implementing whether you derived it or not.
256. Day 256 (AI): AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration — Lin, Tang, Tang, Yang, Dang, Han, 2024. One percent of the weights matter, and which ones is decided by the activations rather than the weights. Read it against your per-layer sensitivity ranking from two days ago and see whether it predicts yours.
257. Day 257 (AI): Random Sample Consensus: A Paradigm for Model Fitting with Applications to Image Analysis and Automated Cartography — Fischler, Bolles, 1981. Estimation that assumes most of its input is garbage — the opposite assumption to least squares, and the reason vision works outdoors. Derive the iteration count formula from the paper before you use the library default.
258. Day 258 (systems): An Empirical Study of Operating System Errors — Chou, Yang, Chelf, Hallem, Engler, 2001. Where kernel bugs actually live, counted rather than guessed: device drivers, error paths, and code that was copied. Read it alongside CSE 451 and note that the highest-density category is the one nobody tests.
259. Day 259 (systems): Coz: Finding Code that Counts with Causal Profiling — Curtsinger, Berger, 2015. A profiler that answers "if I made this faster, what would happen" instead of "where is the time". Read it before you build yours, because the naive one answers the less useful question.
260. Day 260 (AI): U-Net: Convolutional Networks for Biomedical Image Segmentation — Ronneberger, Fischer, Brox, 2015. Skip connections at every resolution, and a training recipe designed for thirty images. Read the augmentation section: the architecture is famous, the data strategy is what made it work.
261. Day 261 (AI): A Taxonomy and Evaluation of Dense Two-Frame Stereo Correspondence Algorithms — Scharstein, Szeliski, 2002. A whole subfield decomposed into four stages so that algorithms can be compared component by component. This is what a good ablation looks like when it is done to other people's work rather than your own.
262. Day 262 (systems): Demystifying GPU Microarchitecture through Microbenchmarking — Wong, Papadopoulou, Sadooghi-Alvandi, Moshovos, 2010. How to find out what the hardware does when the vendor will not tell you: a microbenchmark per structure. Read it as method, then use the method on whichever number in your profiler you do not believe.
263. Day 263 (systems): Arrakis: The Operating System is the Control Plane — Peter, Li, Zhang, Ports, Woos, Krishnamurthy, Anderson, Roscoe, 2014. Taking the kernel out of the data path entirely, argued with latency numbers — and written in this building. Read it the day you find out what epoll costs per event.
264. Day 264 (systems): Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer — Deutsch, 1985. The paper that defines the universal quantum computer and states the Church-Turing principle physically. This is reading ahead: nothing you build for another year is quantum, and today the point is only to see where the model differs from the machine you have been writing kernels for. (Scanned PDF, no text layer — read it on a screen large enough.)
265. Day 265 (AI): An Iterative Image Registration Technique with an Application to Stereo Vision — Lucas, Kanade, 1981. Registration as Newton's method on an image, in four pages. Everything since is this with a better warp model or a pyramid on top.
266. Day 266 (systems): All File Systems Are Not Created Equal: On the Complexity of Crafting Crash-Consistent Applications — Pillai, Chidambaram, Alagappan, Al-Kiswany, Arpaci-Dusseau, Arpaci-Dusseau, 2014. Applications assume ordering guarantees that filesystems do not provide, and the paper enumerates which. Read it before you write your invariant, because half the invariants people write depend on one of these assumptions.
267. Day 267 (systems): MLPerf Inference Benchmark — Reddi et al., 2019. What it takes to make an inference number comparable across submitters: scenarios, latency bounds, and rules against the shortcuts everyone would otherwise take. Your README is a one-person version of this.
268. Day 268 (AI): Structure-from-Motion Revisited — Schönberger, Frahm, 2016. The incremental SfM pipeline written down with every robustness detail that the textbook version leaves out. Read the failure-mode discussion; that is the part you will need when your own two-view reconstruction collapses.
269. Day 269 (systems): Stabilizer: Statistically Sound Performance Evaluation — Curtsinger, Berger, 2013. Randomising layout so that the measurement is of your change and not of where the linker put things. Read it against your own storage benchmark, which currently has one layout and one story.
270. Day 270 (systems): Scalability! But at what COST? — McSherry, Isard, Murray, 2015. The Configuration that Outperforms a Single Thread: several published systems need hundreds of cores to beat one good laptop implementation. Compute the COST of your own parallel work before someone else does.
271. Day 271 (systems): Efficiently Scaling Transformer Inference — Pope, Douglas, Chowdhery, Devlin, Bradbury, Levskaya, Heek, Xiao, Agrawal, Dean, 2022. Inference cost decomposed into memory bandwidth, memory capacity and communication, with the partitioning strategy chosen from that decomposition. Read it on day one of inferd so the design has a reason.
272. Day 272 (AI): NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis — Mildenhall, Srinivasan, Tancik, Barron, Ramamoorthi, Ng, 2020. A scene stored as network weights and rendered by integrating along rays. Read it as the point where the geometry you spent three weeks on becomes a training objective instead of an algorithm.
273. Day 273 (AI): Segment Anything — Kirillov et al., 2023. The data engine is the contribution: a model and a labelling loop bootstrapping each other over three stages. Read the data section twice and the architecture section once.
274. Day 274 (systems): Finding and Understanding Bugs in C Compilers — Yang, Chen, Eide, Regehr, 2011. Differential testing against a reference, done at industrial scale, plus the discipline of reducing every failure to a minimal case. That is exactly the method your tokenizer needs today.
275. Day 275 (AI): Emerging Properties in Self-Supervised Vision Transformers — Caron, Touvron, Misra, Jégou, Mairal, Bojanowski, Joulin, 2021. Attention maps that segment objects without ever being told what an object is. Read it as evidence about what the supervision signal was doing, not as an architecture.
276. Day 276 (systems): Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer — Shor, 1997. The result that made the field a funded field. Read the period-finding reduction carefully and the quantum Fourier transform lightly; the classical number theory is most of the paper and it is the part you can check yourself. Nothing you write this term will run it.
277. Day 277 (systems): Orca: A Distributed Serving System for Transformer-Based Generative Models — Yu, Jeong, Kim, Kim, Chun, 2022. Iteration-level scheduling: the insight that a batch should be re-formed every token rather than every request. Read it now so that continuous batching later is an implementation rather than an idea.
278. Day 278 (AI): Finite-time Analysis of the Multiarmed Bandit Problem — Auer, Cesa-Bianchi, Fischer, 2002. UCB1 with a regret bound that holds at finite time, not asymptotically. Read the proof sketch: the confidence term you will implement today is a Hoeffding bound wearing a hat.
279. Day 279 (systems): Simultaneous Multithreading: Maximizing On-Chip Parallelism — Tullsen, Eggers, Levy, 1995. Filling issue slots from another thread when one thread cannot fill them — the idea behind every hyperthread you have ever measured, from this department. Read it before §3.11 says it in textbook form.
280. Day 280 (systems): Dynamic Branch Prediction with Perceptrons — Jiménez, Lin, 2001. A linear classifier in the front end of a processor, with the history length it buys you. Read it the same week you start Sutton & Barto and notice that the hardware people got there first.
281. Day 281 (AI): Efficient Processing of Deep Neural Networks: A Tutorial and Survey — Sze, Chen, Yang, Emer, 2017. Dataflow taxonomies and the energy cost of each memory level, in one place. Read the energy-per-access table and then decide whether your cache design was about time or about bytes.
282. Day 282 (systems): Evaluating Fuzz Testing — Klees, Ruef, Cooper, Wei, Hicks, 2018. Thirty-two papers re-examined against a consistent protocol — seeds, timeouts, targets, and the statistics — and most of the claimed improvements stop being visible. You are two weeks from writing a proposal; read this as the standard your evaluation section has to meet.
283. Day 283 (AI): Bandit based Monte-Carlo Planning — Kocsis, Szepesvári, 2006. UCT: what you do when you have a simulator instead of the transition matrix that dynamic programming assumes. Read it beside today's chapter to see exactly which assumption is being traded away.
284. Day 284 (systems): Spectre Attacks: Exploiting Speculative Execution — Kocher et al., 2019. The performance mechanism you read about yesterday, used as a channel. Read it the day after speculation so the exploit is obvious rather than magic — and note that the fix is not a patch, it is a slower machine.
285. Day 285 (AI): The Arcade Learning Environment: An Evaluation Platform for General Agents — Bellemare, Naddaf, Veness, Bowling, 2013. What a benchmark has to specify before results on it mean anything: episode boundaries, action sets, evaluation protocol, and the training-testing split of games. Read it as a template for the evaluation section of your proposal.
286. Day 286 (systems): SARATHI: Efficient LLM Inference by Piggybacking Decodes with Chunked Prefills — Agrawal, Panwar, Mohan, Kwatra, Gulavani, Ramjee, 2023. Prefill and decode have opposite resource profiles, so mixing them in one batch fills the machine. Read it now; it is the scheduling policy you will want two steps from here.
287. Day 287 (AI): Q-learning — Watkins, Dayan, 1992. The convergence proof for the algorithm everyone uses, with its conditions stated. Read the conditions; three of them are routinely violated by every deep RL implementation you will meet.
288. Day 288 (systems): A Fast Quantum Mechanical Algorithm for Database Search — Grover, 1996. Quadratic, not exponential, and the amplitude-amplification geometry is the whole thing. Read it as the algorithm most often overclaimed in press releases, and write down exactly what it does and does not promise. Still reading ahead: nothing here gets implemented before Autumn 2027.
289. Day 289 (systems): DeepSpeed Inference: Enabling Efficient Inference of Transformer Models at Unprecedented Scale — Aminabadi et al., 2022. Kernel fusion, parallelism and offloading treated as one design space with a decision rule. Read the section on when offloading pays; it is the calculation you will need when your model does not fit.
290. Day 290 (AI): Learning to Predict by the Methods of Temporal Differences — Sutton, 1988. The original argument that TD beats supervised prediction on the same data, with the random-walk experiment you are about to reproduce. Reproduce the figure, not the claim.
291. Day 291 (AI): Deep Reinforcement Learning with Double Q-learning — van Hasselt, Guez, Silver, 2016. Maximisation bias, demonstrated as an overestimate that grows with the action count, and a two-estimator fix. Read it the same day the book introduces the bias, and check the fix on your own tabular code.
292. Day 292 (AI): Prioritized Experience Replay — Schaul, Quan, Antonoglou, Silver, 2016. Prioritised sweeping's idea moved to the deep setting, with the importance-sampling correction that stops the prioritisation from biasing the update. Read it beside chapter 8 next week and note that it is the same trick.
293. Day 293 (AI): Temporal Difference Learning and TD-Gammon — Tesauro, 1995. Self-play plus TD, on 1990s hardware, producing opening theory that human players adopted. Read it for the honest discussion of why it worked in backgammon and would not have in chess.
294. Day 294 (systems): QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs — Claessen, Hughes, 2000. Properties and generators instead of examples, plus shrinking, which is the part that makes a random failure debuggable. Read it before the property tests you owe your storage component, not after.
295. Day 295 (systems): Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors — Mellor-Crummey, Scott, 1991. The MCS lock: each waiter spins on its own cache line, so the lock stops generating coherence traffic proportional to the waiter count. Read it the day you measure what a naive spinlock does to a bus.
296. Day 296 (systems): x86-TSO: A Rigorous and Usable Programmer's Model for x86 Multiprocessors — Sewell, Sarkar, Owens, Zappa Nardelli, Myreen, 2010. The memory model you have been programming against without a definition, defined — including the litmus tests that show the informal descriptions were wrong. Read it beside §5.6 and then check your own lock-free code.
297. Day 297 (systems): An Analysis of Linux Scalability to Many Cores — Boyd-Wickizer, Clements, Mao, Pesterev, Kaashoek, Morris, Zeldovich, 2010. Seven applications scaled to 48 cores, with each bottleneck found, fixed and named. Read the method: measure, find the one contended structure, fix it, measure again. That is exactly the loop you run today on your own component.
298. Day 298 (systems): Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking — Jia, Maggioni, Staiger, Scarpazza, 2018. Latencies, cache hierarchy and tensor-core behaviour measured rather than documented. Read it against the mental model PMPP is about to give you and mark where the measurement contradicts the abstraction.
299. Day 299 (systems): Splitwise: Efficient Generative LLM Inference Using Phase Splitting — Patel, Choukse, Zhang, Shah, Goiri, Maleki, Bianchini, 2024. The two phases put on different machines because they want different hardware. Read it the day you measure both phases separately and see how little they have in common.
300. Day 300 (systems): Quantum Cryptography: Public Key Distribution and Coin Tossing — Bennett, Brassard, 1984. BB84: security resting on measurement disturbing state rather than on a hardness assumption. Read it as the cleanest example of a quantum property being used for something, and note that it needs no computer at all. Reading ahead, as with the other four.
301. Day 301 (AI): Implementation Matters in Deep Policy Gradients: A Case Study on PPO and TRPO — Engstrom, Ilyas, Santurkar, Tsipras, Janoos, Rudolph, Madry, 2020. The gains attributed to an algorithm turning out to come from code-level details shared by both algorithms. Read it on the day you write your first claim, and make the claim about a mechanism you can turn off.
302. Day 302 (systems): Halide: A Language and Compiler for Optimizing Parallelism, Locality, and Recomputation in Image Processing Pipelines — Ragan-Kelley, Barnes, Adams, Paris, Durand, Amarasinghe, 2013. Separating the algorithm from the schedule, which is the single most useful idea in performance engineering and the one your kernels currently mix together. Read it and then look at how many of your kernel variants differ only in schedule.
303. Day 303 (AI): Benchmarking Deep Reinforcement Learning for Continuous Control — Duan, Chen, Houthooft, Schulman, Abbeel, 2016. A set of tasks and a set of algorithms run under one protocol so that the numbers can be compared at all. Read it while choosing baselines, because it says precisely what "the same baseline" has to mean.
304. Day 304 (AI): The Curious Case of Neural Text Degeneration — Holtzman, Buys, Du, Forbes, Choi, 2020. Why maximum-likelihood decoding produces repetitive text, and nucleus sampling as the fix — from this department. Read it the day you implement top-p, so the parameter has an argument behind it.
305. Day 305 (systems): TVM: An Automated End-to-End Optimizing Compiler for Deep Learning — Chen et al., 2018. The schedule search that replaces the hand tuning you have been doing for six weeks. Read it and decide honestly which of your optimizations a search would have found faster than you did.
306. Day 306 (systems): An Axiomatic Basis for Computer Programming — Hoare, 1969. Preconditions, postconditions and the loop invariant, introduced. Six pages, and it is the reason CSE 331 and your storage component are using the same word for the same thing. Read it and then re-read your own invariant to see whether it is one.
307. Day 307 (systems): Triton: An Intermediate Language and Compiler for Tiled Neural Network Computations — Tillet, Kung, Cox, 2019. Tiles as the language primitive, so the compiler owns the index arithmetic you have been writing by hand. Read it as the answer to why your kernels are mostly indices.
308. Day 308 (systems): seL4: Formal Verification of an OS Kernel — Klein et al., 2009. What a proof about a kernel actually covers and, more usefully, what it explicitly assumes. Read the assumptions section as a model for the limitations section of your own component.
309. Day 309 (AI): Rainbow: Combining Improvements in Deep Reinforcement Learning — Hessel et al., 2018. Six extensions combined and then removed one at a time. The ablation is the paper; copy its structure directly into the table you write today.
310. Day 310 (systems): Exokernel: An Operating System Architecture for Application-Level Resource Management — Engler, Kaashoek, O'Toole, 1995. A design argument — separate protection from management — carried by measurements against a real system. This is the shape your proposal has to take: one claim, and evidence that is not a preference.
311. Day 311 (AI): Proximal Policy Optimization Algorithms — Schulman, Wolski, Dhariwal, Radford, Klimov, 2017. A method whose contribution is that it is simple enough for other people to reproduce. Read it against TRPO and let it set the bar for how implementable your proposed method has to be.
312. Day 312 (systems): Quantum Computing in the NISQ era and beyond — Preskill, 2018. What the machines can actually do now, from someone with no incentive to overstate it. Read it last of the five: Deutsch said what the model is, Shor and Grover said what it could do, BB84 said what it already does, and this says how far the hardware is from any of it. That gap is the reason quantum is a 2027 reading lane and a 2028 building lane, not a 2027 project.
313. Day 313 (systems): IX: A Protected Dataplane Operating System for High Throughput and Low Latency — Belay, Prekas, Klimovic, Grossman, Kozyrakis, Bugnion, 2014. Latency and throughput reported together, with the protection story kept intact. Read the evaluation section as the template for the one you are writing today.
314. Day 314 (AI): Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor — Haarnoja, Zhou, Abbeel, Levine, 2018. Entropy as a term in the objective rather than a schedule bolted on the side. Read it as an example of moving something from the training loop into the definition of the problem.
315. Day 315 (AI): Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model — Schrittwieser et al., 2020. Read it today as a scope check rather than as a method: this is what a team of that size did in a year, and your proposal has one person and one summer. Adjust the claim, not the ambition.
316. Day 316 (AI): Improving Reproducibility in Machine Learning Research (A Report from the NeurIPS 2019 Reproducibility Program) — Pineau et al., 2021. The checklist you are about to hold yourself to for a hundred days. Fill it in today, for a result you have not got yet — the boxes you cannot tick are the experiments you have not designed.
317. Day 317 (systems): Accelerating Large Language Model Decoding with Speculative Sampling — Chen et al., 2023. The modified rejection sampler, which is what makes speculative decoding exact rather than approximately right. Read it before you write the acceptance test: getting it wrong changes the output distribution and nothing crashes.
318. Day 318 (systems): Quantum Chemistry in the Age of Quantum Computing — Cao et al., 2019. The application quantum computing is most likely to deliver first, with the resource requirements stated rather than implied. Quantum is reading only this summer; start with the one that says what the machine would be for.
319. Day 319 (systems): A Nine Year Study of File System and Storage Benchmarking — Traeger, Zadok, Joukov, Wright, 2008. Four hundred and fifteen published benchmarks surveyed, and almost none of them comparable to each other. Read it before you record your baseline: a number without its full configuration is not a measurement, it is an anecdote.
320. Day 320 (AI): Blockwise Parallel Decoding for Deep Autoregressive Models — Stern, Shazeer, Uszkoreit, 2018. Speculative decoding's ancestor, from before it had the exactness proof. Read it for what it gave up to go fast, and check whether your implementation quietly gave up the same thing.
321. Day 321 (AI): What is dynamic programming? — Eddy, 2004. Two pages, and it is the recurrence you are writing today. Read it before the implementation; it is much less useful afterwards.
322. Day 322 (systems): ProtTrans: Towards Cracking the Language of Life's Code Through Self-Supervised Deep Learning and High Performance Computing — Elnaggar et al., 2022. Protein language models trained at supercomputer scale, evaluated on the tasks the Markov chain you fit today is the classical answer to. Read it as the far end of the same lane, and note how much of the compute went into a model with no interpretable states at all.
323. Day 323 (systems): Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads — Cai et al., 2024. Speculation without a second model, and a tree of candidates instead of a chain. Read it while you are measuring acceptance rate — it tells you which part of your number is the draft model and which is the chain structure.
324. Day 324 (systems): The theory of variational hybrid quantum-classical algorithms — McClean, Romero, Babbush, Aspuru-Guzik, 2016. The framework behind every variational algorithm you will read this summer: a parameterised circuit, a classical optimizer, and a cost function measured rather than computed. Card the assumptions, because they are the ones that fail on hardware.
325. Day 325 (AI): What is a hidden Markov model? — Eddy, 2004. The two-page version, written for biologists who have to use one tomorrow. Read it against Durbin chapter 3 and note which one you would hand to someone else.
326. Day 326 (systems): The case for 4-bit precision: k-bit Inference Scaling Laws — Dettmers, Zettlemoyer, 2023. Bit width traded against parameter count at fixed memory, measured across model families. Read it today, because it is the paper that decides which bit width you should be loading at all.
327. Day 327 (AI): Accounting for Variance in Machine Learning Benchmarks — Bouthillier et al., 2021. Where the variance in a benchmark actually comes from, and how many seeds you need before a difference means anything. Decide your repeat count from this paper today, not from what fits in the afternoon.
328. Day 328 (systems): Roofline: An Insightful Visual Performance Model for Floating-Point Programs and Multicore Architectures — Williams, Waterman, Patterson, 2008. The model that turns "is it slow" into "which ceiling is it under". Draw the roofline for your own GPU today and put every kernel you write this summer on it.
329. Day 329 (systems): SpQR: A Sparse-Quantized Representation for Near-Lossless LLM Weight Compression — Dettmers et al., 2023. Outlier weights kept at full precision and everything else pushed down, with the quality loss measured rather than asserted. Read it while your own quality-versus-throughput table is filling in, and check whether your losses are concentrated the same way.
330. Day 330 (systems): A variational eigenvalue solver on a quantum processor — Peruzzo et al., 2014. VQE, in its first form: the circuit prepares, the classical optimizer decides, and the hard part is measurement. Card what it actually demonstrated against what it is usually cited for.
331. Day 331 (AI): Deep Reinforcement Learning that Matters — Henderson et al., 2018. Seed variance swamping the effect being claimed, demonstrated rather than asserted. Read it and then look at your own day-329 table and ask whether the INT8 gap survives it.
332. Day 332 (systems): Single-pass Parallel Prefix Scan with Decoupled Look-back — Merrill, Garland, 2016. The scan you read about yesterday, from the people who shipped it, including the memory-ordering argument. The block-table allocator in your paged attention is a prefix sum with a nicer name.
333. Day 333 (AI): Accelerated Profile HMM Searches — Eddy, 2011. How HMMER got fast: a filter cascade with a stated false-negative rate at each stage. Read it as a systems paper — it is the same argument as a speculative decoder, made fifteen years earlier.
334. Day 334 (systems): Alpa: Automating Inter- and Intra-Operator Parallelism for Distributed Deep Learning — Zheng et al., 2022. Partitioning treated as a search problem with a cost model rather than as a design decision. Read it while your own two-device layout is still a guess, and steal the cost model even if you never write the search.
335. Day 335 (systems): Reducing Activation Recomputation in Large Transformer Models — Korthikanti et al., 2022. Sequence parallelism and selective recomputation, with the memory arithmetic written out per layer. You are about to write the same arithmetic for inference; steal the form of the accounting.
336. Day 336 (systems): A Quantum Approximate Optimization Algorithm — Farhi, Goldstone, Gutmann, 2014. QAOA as originally stated: a fixed ansatz, a depth parameter, and a performance guarantee that is weaker than most citations of it imply. Card what it actually proves at p = 1.
337. Day 337 (systems): Quantum advantage in learning from experiments — Huang et al., 2022. A separation proved and then demonstrated, with the experimental design doing as much work as the theorem. Read it today for how the comparison was set up so that the result could not be an artifact.
338. Day 338 (systems): DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving — Zhong et al., 2024. Prefill and decode want different parallelism, and the paper takes that seriously enough to put them on different machines. Read it before you fix your own partitioning, because it argues one partition is not enough.
339. Day 339 (AI): Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences — Rives et al., 2021. A language model trained on protein sequences recovering structure and homology without being told about either. Read it against the profile HMM you built on day 333: the same problem, and a very different amount of prior knowledge.
340. Day 340 (systems): Efficient Sparse Matrix-Vector Multiplication on CUDA — Bell, Garland, 2008. Five storage formats measured against the same matrices, with the structure of the matrix deciding the winner every time. This is the clearest example in the summer of a data-structure choice being a performance choice.
341. Day 341 (systems): Clipper: A Low-Latency Online Prediction Serving System — Crankshaw et al., 2017. Serving as a layered system with a latency budget per layer, from before language models made everyone forget the general case. Read it for the batching-under-a-deadline argument; that is the one your scheduler now has to make.
342. Day 342 (systems): Quantum Approximate Optimization Algorithm: Performance, Mechanism, and Implementation on Near-Term Devices — Zhou, Wang, Choi, Pichler, Lukin, 2020. What QAOA is actually doing at moderate depth, and heuristics for finding the angles. Read it after Farhi, as the paper that turns the algorithm into something you could run.
343. Day 343 (AI): Highly accurate protein structure prediction with AlphaFold — Jumper et al., 2021. The paper the AI lane has been walking toward for three weeks. Read the main text today with the profile HMM and the coevolution signal already in your hands; the supplement is the chapter lane for the next two days.
344. Day 344 (systems): Serving DNNs like Clockwork: Performance Predictability from the Bottom Up — Gujarati et al., 2020. Predictability as the design goal instead of average speed, achieved by removing every source of variance rather than by scheduling around it. Read it while you are deciding what your API promises under load.
345. Day 345 (AI): Troubling Trends in Machine Learning Scholarship — Lipton, Steinhardt, 2018. Explanation dressed as speculation, and gains attributed to the wrong component. Read it the day you have a grid of results to write up, because the failure modes it names are the ones available to you today.
346. Day 346 (systems): cuDNN: Efficient Primitives for Deep Learning — Chetlur et al., 2014. Why a library ships several algorithms for one operation and picks between them at run time. That choice is a compiler decision made at the library boundary, which is exactly where the next lane opens.
347. Day 347 (systems): Open Versus Closed: A Cautionary Tale — Schroeder, Wierman, Harchol-Balter, 2006. A closed-loop load generator cannot produce a queue, so it cannot measure overload — and almost every benchmark harness is closed-loop by accident. Read this before you write yours, not after you publish a latency curve from it.
348. Day 348 (systems): Barren plateaus in quantum neural network training landscapes — McClean, Boixo, Smelyanskiy, Babbush, Neven, 2018. Gradients vanishing exponentially in qubit count — an optimization result with a concentration-of-measure proof behind it. This is the paper that says why variational quantum machine learning is hard, and it is the one to have read before you meet anyone who does it.
349. Day 349 (AI): Relational inductive biases, deep learning, and graph networks — Battaglia et al., 2018. Structure put into a model by hand rather than learned, argued generally. You are hard-coding SE(3) today; this is the same decision, and the paper is honest about what it costs.
350. Day 350 (systems): A Practical Automatic Polyhedral Parallelizer and Locality Optimizer — Bondhugula, Hartono, Ramanujam, Sadayappan, 2008. Loop transformation as an optimization problem over an affine space, chosen by a machine rather than by taste. Today you do four of these by hand; this is what it looks like when the choice is made properly.
351. Day 351 (AI): Learning agile and dynamic motor skills for legged robots — Hwangbo et al., 2019. The sim-to-real gap closed by learning the actuator model and keeping the rigid-body model analytic. Read it the day you write the analytic half, and note exactly which part they refused to learn.
352. Day 352 (systems): Scalable GPU Graph Traversal — Merrill, Garland, Grimshaw, 2012. Prefix-sum-based frontier construction and fine-grained load balance, which is scatter-versus-gather taken to its limit. Read it against your day-344 frontier measurements.
353. Day 353 (systems): Llumnix: Dynamic Scheduling for Large Language Model Serving — Sun et al., 2024. Requests migrated between instances at run time specifically to fix head-of-line blocking and tail latency. Read it while you are staring at your own p99, and note that its whole contribution is a scheduling decision made later than yours is.
354. Day 354 (systems): Cost Function Dependent Barren Plateaus in Shallow Parametrized Quantum Circuits — Cerezo, Sone, Volkoff, Cincio, Coles, 2021. The refinement: global cost functions have barren plateaus at any depth, local ones do not until you go deep. A result about how you write the objective, which is a lesson that generalises well outside quantum.
355. Day 355 (AI): Champion-level drone racing using deep reinforcement learning — Kaufmann et al., 2023. A learned policy beating human champions, with a very carefully engineered state estimator underneath it. Read it for the division of labour: what was learned, and what was still solved analytically.
356. Day 356 (systems): MLPerf Training Benchmark — Mattson et al., 2020. What a benchmark suite has to pin down — quality target, timing rules, permitted tuning — before two people's numbers mean the same thing. Your report needs the same list, and today is when it gets written.
357. Day 357 (AI): End-to-End Training of Deep Visuomotor Policies — Levine, Finn, Darrell, Abbeel, 2016. The argument for skipping the pipeline you have spent two weeks building: pixels to torques, with no explicit kinematics anywhere. Read it the day you finish the hand-written version so the comparison is concrete rather than rhetorical.
358. Day 358 (systems): Glow: Graph Lowering Compiler Techniques for Neural Networks — Rotem et al., 2018. Two levels of intermediate representation and an explicit lowering between them, which is exactly the shape of the thing you start building today. Read it on the day the compiler lane opens, so you know what the small language is practice for.
359. Day 359 (systems): FlashAttention-2: Faster Attention with Better Parallelism and Work Partitioning — Dao, 2023. Work partitioning and occupancy in the kernel that dominates decode. When you find the knee today, this paper is the first place to look for what is saturating.
360. Day 360 (systems): Noise-Induced Barren Plateaus in Variational Quantum Algorithms — Wang, Fontana, Cerezo, Sharma, Sone, Cincio, Coles, 2021. A second, independent mechanism producing the same flat landscape, this time from hardware noise rather than from expressiveness. Two different causes with one signature is a diagnosis problem, and you had one of those on day 361.
361. Day 361 (AI): A Metric Learning Reality Check — Musgrave, Belongie, Lim, 2020. A decade of reported improvements that vanish under a fair comparison with a properly tuned baseline. Read it today, on the day your own improvement vanished, and note that the authors did not stop working afterwards.
362. Day 362 (AI): Do ImageNet Classifiers Generalize to ImageNet? — Recht, Roelofs, Schmidt, Shankar, 2019. A result that was real, reproducible, and still did not hold on a new sample from the same process. That is the distinction your post-mortem has to make today: a wrong measurement and a narrow one need different fixes.
363. Day 363 (systems): Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi-Serve — Agrawal et al., 2024. A stall-free scheduler that trades a defined amount of throughput for a bounded tail. You have the knee and now you need the knob; this paper says which one it is and what it costs.
364. Day 364 (systems): Ansor: Generating High-Performance Tensor Programs for Deep Learning — Zheng et al., 2020. A compiler that searches the space of schedules instead of asking you for one. Read it now that you are writing a compiler and have spent a month writing kernels by hand: the decision it takes away from the programmer is the decision you have been making all summer.
365. Day 365 (systems): SGLang: Efficient Execution of Structured Language Model Programs — Zheng et al., 2024. RadixAttention: prefix sharing as a data structure rather than as a special case for system prompts. Read it before you choose your cache key, because the choice decides what can ever be shared.
366. Day 366 (systems): Variational Quantum Algorithms — Cerezo et al., 2021. The review that ties the last four catch-up days together: ansatz design, cost functions, trainability, and the honest list of open problems. Read it last, not first.
367. Day 367 (AI): Diffusion Policy: Visuomotor Policy Learning via Action Diffusion — Chi et al., 2023. A policy that produces a whole action sequence by denoising, which is planning without a planner. Read it against the RRT you write today and say precisely which of the planner's guarantees it drops.
368. Day 368 (systems): MLIR: A Compiler Infrastructure for the End of Moore's Law — Lattner et al., 2020. The argument that a compiler should have many intermediate representations rather than one. Read it the day you add a pass, because a pass is the first moment you want to say something the AST cannot express.
369. Day 369 (AI): Learning Quadrupedal Locomotion over Challenging Terrain — Lee, Hwangbo, Wellhausen, Koltun, Hutter, 2020. Teacher-student with privileged information: a controller trained where the state is known, distilled into one where it is not. The controller you write today is the teacher, in exactly the sense the paper means.
370. Day 370 (AI): Past, Present, and Future of Simultaneous Localization And Mapping: Towards the Robust-Perception Age — Cadena et al., 2016. The field's own account of what state estimation has solved and what it has not. Read it at the start of Thrun rather than at the end, so you know which chapters are still the state of the art and which are history.
371. Day 371 (systems): Prompt Cache: Modular Attention Reuse for Low-Latency Inference — Gim et al., 2024. Reuse of attention state across non-contiguous prompt segments, which is the case your radix tree cannot express. Read it while you are measuring hit rate, because it tells you which misses were avoidable.
372. Day 372 (systems): Hardware-efficient Variational Quantum Eigensolver for Small Molecules and Quantum Magnets — Kandala et al., 2017. VQE on real hardware, with the ansatz chosen for what the machine can execute rather than for what the chemistry wants. That trade — the algorithm bending to the device — is the whole of quantum systems in one paper.
373. Day 373 (AI): ORB-SLAM: a Versatile and Accurate Monocular SLAM System — Mur-Artal, Montiel, Tardós, 2015. A real, working SLAM system that does not use the filter you are writing today, and says why: optimization over a window beats a filter that has already thrown the history away.
374. Day 374 (AI): The Hardware Lottery — Hooker, 2021. Which research ideas win is decided partly by which hardware happens to exist. Read it on the day you write down where every gigabyte goes, because that table is the local version of the same argument.
375. Day 375 (systems): PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and Graph Compilation — Ansel et al., 2024. A compiler whose front end is a bytecode interpreter it does not own, with guards for everything it had to assume. You are writing the honest version of the same machine today.
376. Day 376 (AI): Learning Latent Dynamics for Planning from Pixels — Hafner et al., 2019. A latent state inferred from images and then planned in — the particle filter you write today is the hand-built version of the same object, with a model you wrote instead of one you fit.
377. Day 377 (systems): QLoRA: Efficient Finetuning of Quantized LLMs — Dettmers, Pagnoni, Holtzman, Zettlemoyer, 2023. Paged optimizer state, 4-bit storage with a second-level quantization of the constants themselves — a memory-accounting paper wearing a fine-tuning costume. Read it while writing your own accounting and steal the level of detail.
378. Day 378 (systems): Topological quantum memory — Dennis, Kitaev, Landahl, Preskill, 2002. The surface code as a memory with a threshold, and the mapping of decoding onto a statistical-mechanics model. Long, and worth the whole catch-up day; it is the paper the entire error-correction lane in the autumn descends from.
379. Day 379 (systems): Improved Simulation of Stabilizer Circuits — Aaronson, Gottesman, 2004. The canonical example of representing an object by what you can answer about it rather than by writing it out — which is also what interning and hashing do. Read it as a data-structure paper, because that is what it is.
380. Day 380 (AI): Are We Really Making Much Progress? A Worrying Analysis of Recent Neural Recommendation Approaches — Ferrari Dacrema, Cremonesi, Jannach, 2019. Eighteen methods, seven reproducible, six beaten by a well-tuned trivial baseline. Read it the day you start writing related work, because it is a paper about what related work is for.
381. Day 381 (AI): Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World — Tobin et al., 2017. The sensor model you write today is a fiction, and domain randomization is the argument for never trusting one fiction. Read it against your beam model and ask which of its parameters you have any right to.
382. Day 382 (systems): Quantum supremacy using a programmable superconducting processor — Arute et al., 2019. A benchmark claim whose classical baseline was contested within weeks and revised for years. Read it the day before you compare yourself against vLLM, for how a comparison gets attacked and which parts of it survived.
383. Day 383 (systems): FlashAttention-3: Fast and Accurate Attention with Asynchrony and Low-precision — Shah et al., 2024. The kernel a large part of vLLM's advantage lives in. Before you explain your gap, find out how much of it is one kernel you did not write and could not have written this summer.
384. Day 384 (systems): Surface codes: Towards practical large-scale quantum computation — Fowler, Mariantoni, Martinis, Cleland, 2012. The long, patient tutorial version of the surface code, with the resource estimates that made everyone take it seriously. Read it after Dennis et al.; it is the engineering paper to that physics one.
385. Day 385 (AI): World Models — Ha, Schmidhuber, 2018. A learned latent model of an environment, used to plan inside. MCL is the same architecture with the model written by hand and the state kept honest, and the comparison is exactly what today is for.
386. Day 386 (AI): On the State of the Art of Evaluation in Neural Language Models — Melis, Dyer, Blunsom, 2018. A careful re-evaluation in which the old baseline, properly tuned, wins. Read it while you are writing the sentence where your engine loses, and make that sentence as precise as theirs.
387. Day 387 (AI): Are GANs Created Equal? A Large-Scale Study — Lucic et al., 2018. Give every method the same compute budget for tuning and most of the reported differences disappear. Write your comparison section after reading it, and state the budget you gave vLLM.
388. Day 388 (systems): Almost-linear time decoding algorithm for topological codes — Delfosse, Nickerson, 2021. Union-find as a decoder: a data structure chosen for its complexity class and then defended on accuracy. Today's chapter is closure capture, which is also a lifetime problem solved by choosing the right structure.
389. Day 389 (systems): Sparse Blossom: correcting a million errors per core second with minimum-weight matching — Higgott, Gidney, 2023. A decoder benchmarked in errors per core second against every alternative, with the cases where it loses stated in the abstract. That is the shape of the document you are writing today.
390. Day 390 (systems): Noisy intermediate-scale quantum (NISQ) algorithms — Bharti et al., 2022. The survey of everything people have tried to run on the machines that exist. Read it as a map of a field before you enter it in the autumn, and note how many entries end in "no advantage demonstrated".
391. Day 391 (AI): Learning to Simulate Complex Physics with Graph Networks — Sanchez-Gonzalez et al., 2020. A graph whose edges are physical relations, solved by message passing rather than by an equation. A pose graph is the same object with a known energy, and today is the day to say which one you would rather debug.
392. Day 392 (systems): SpecInfer: Accelerating Large Language Model Serving with Tree-based Speculative Inference and Verification — Miao et al., 2024. Speculation as a tree verified in one pass, which generalises the chain you measured in July. Read it now that you know your acceptance rate, and compute what it would have to be for the tree to pay.
393. Day 393 (systems): Fault Tolerant Quantum Computation with Constant Error — Aharonov, Ben-Or, 1997. A threshold theorem: not "it works if conditions are favourable" but a stated number below which it works and above which it does not. Write your limitations section in that register today.
394. Day 394 (AI): Neural Ordinary Differential Equations — Chen, Rubanova, Bettencourt, Duvenaud, 2018. A model whose forward pass is a solver call, with the gradient obtained by solving a second equation backwards. The scientific-ML lane opens today and almost everything in it is a version of this move.
395. Day 395 (systems): A Quantum Engineer's Guide to Superconducting Qubits — Krantz et al., 2019. A document written to be built on: it assumes competence and explains anyway, and every design choice has its consequence stated. Read it today as a model for the document you are writing, not for the physics.
396. Day 396 (systems): Universal Quantum Computation with ideal Clifford gates and noisy ancillas — Bravyi, Kitaev, 2005. Magic-state distillation: the expensive part of fault tolerance isolated into one resource you can count. Read it as the paper that turns "how much does a quantum computer cost" into an arithmetic problem.
397. Day 397 (AI): Machine learning accelerated computational fluid dynamics — Kochkov, Smith, Alieva, Wang, Brenner, Hoyer, 2021. A learned correction placed inside a solver that is kept, rather than a network asked to replace it. DMD is the linear version of the same bargain, and today is the day to say what each one buys.
398. Day 398 (systems): Quantum Error Correction for Quantum Memories — Terhal, 2015. A whole review organised around failure: what goes wrong, at what rate, and what has to be true for correction to keep up. Read it while writing your own failure-mode section, because it is the same discipline applied to a harder object.
399. Day 399 (AI): Discovering governing equations from data: Sparse identification of nonlinear dynamical systems — Brunton, Proctor, Kutz, 2016. Sparse regression over a library of candidate terms, recovering the equation instead of a black box. Read it before you run it, and pay attention to how badly it degrades with noise.
400. Day 400 (AI): Physics Informed Deep Learning (Part I): Data-driven Solutions of Nonlinear Partial Differential Equations — Raissi, Perdikaris, Karniadakis, 2017. The original PINN paper, before the review that assesses it. Read it today so that the next two days of chapters read as a critique of something you already know rather than as a summary.
401. Day 401 (systems): SEDA: An Architecture for Well-Conditioned, Scalable Internet Services — Welsh, Culler, Brewer, 2001. Bounded queues between stages, with load shedding as an explicit stage-local decision. The point is that a system without backpressure does not degrade, it collapses — which you can now demonstrate on your own engine.
402. Day 402 (systems): Quantum computing and the entanglement frontier — Preskill, 2012. The argument for why quantum computation is interesting even before it is useful, written six years before NISQ. Read it as the framing document for the whole autumn.
403. Day 403 (AI): Characterizing possible failure modes in physics-informed neural networks — Krishnapriyan, Gholami, Zhe, Kirby, Mahoney, 2021. PINNs failing on problems that are easy for a classical solver, with the loss landscape shown rather than blamed. Read it today, while your own is failing, and check which of its named failure modes yours is.
404. Day 404 (AI): Understanding and mitigating gradient pathologies in physics-informed neural networks — Wang, Teng, Perdikaris, 2020. The diagnosis for yesterday: the residual and boundary terms have gradients of wildly different scale, and the fix is an adaptive weighting rather than a bigger network. Try it today, and if it does not work say so.
405. Day 405 (AI): Fourier Neural Operator for Parametric Partial Differential Equations — Li et al., 2021. A learned operator that is resolution-independent because it works in the frequency domain. Read it against the PINN you have just failed to train, and note that it changes the problem rather than the optimizer.
406. Day 406 (systems): Solving the Quantum Many-Body Problem with Artificial Neural Networks — Carleo, Troyer, 2017. A neural network used as a variational wavefunction — a function of exponentially many configurations, represented by a small number of parameters. This is the hinge between the two lanes of the whole plan, and it lands on the day you are using a network as a function-space object.
407. Day 407 (systems): LayerSkip: Enabling Early Exit Inference and Self-Speculative Decoding — Elhoushi et al., 2024. Degrading the computation instead of the queue: exit early and verify with the remaining layers. The other lever available under overload, and the one your admission control cannot reach.
408. Day 408 (systems): How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits — Gidney, Ekerå, 2021. The most careful resource estimate in the field, and the clearest demonstration that the interesting question is engineering rather than asymptotics. Read the assumptions table more carefully than the headline.
409. Day 409 (systems): Assessing requirements to scale to practical quantum advantage — Beverland et al., 2022. A resource estimate written so that it can be argued with: every assumption exposed and every number traceable. Read it the day somebody argues with yours, and note that the arguable version is the useful one.
410. Day 410 (AI): Fast ε-free Inference of Simulation Models with Bayesian Conditional Density Estimation — Papamakarios, Murray, 2016. Replacing rejection-based inference with a density estimator that learns the posterior directly. Read it against ABC, which is today's chapter, and note how much sample efficiency the change buys.
411. Day 411 (AI): Automatic Posterior Transformation for Likelihood-Free Inference — Greenberg, Nonnenmacher, Macke, 2019. Sequential neural posterior estimation done without the importance-weighting correction that made the earlier versions fragile. This is the method you are implementing today; read the failure it fixes.
412. Day 412 (systems): Dissecting Tensor Cores via Microbenchmarks: Latency, Throughput and Numeric Behaviors — Sun et al., 2023. The tensor-core path measured rather than documented, including the numeric behaviour nobody writes down. When your GEMM is 20% off cuBLAS today, this is the paper that tells you which number to go and measure.
413. Day 413 (systems): Quantum Approximate Optimization of Non-Planar Graph Problems on a Planar Superconducting Processor — Harrigan et al., 2021. A hardware experiment reported with the device calibration, the exact circuits and a result that does not beat the classical baseline. That combination — full disclosure plus an unflattering number — is what makes a negative result usable.
414. Day 414 (systems): Suppressing quantum errors by scaling a surface code logical qubit — Google Quantum AI, 2023. The first experiment where making the code bigger made the logical error smaller, by a small and hard-won margin. Read it for the measurement methodology, which is the part a systems person can actually evaluate.
415. Day 415 (systems): Neural-network quantum state tomography — Torlai et al., 2018. Density estimation over measurement outcomes, used to reconstruct a quantum state. The machinery is the one you are training today, pointed at a physical system — which is the second half of the hinge you read on day 406.
416. Day 416 (systems): Quantum advantage with shallow circuits — Bravyi, Gosset, König, 2018. Depth as the resource, and an unconditional separation at constant depth. Today you are shortening a critical path in a scheduler; this is the same quantity treated as the object of a theorem.
417. Day 417 (AI): GraphCast: Learning skillful medium-range global weather forecasting — Lam et al., 2023. A learned model evaluated against the operational numerical baseline on the baseline's own scorecard, at the baseline's own resolution. Read it while packaging yours, and copy the discipline of not choosing your own metric.
418. Day 418 (systems): Machine learning phases of matter — Carrasquilla, Melko, 2017. A classifier trained on raw configurations recovering a phase boundary it was never told about. Read it on the last full week of the flagship, because the sentence your autumn applications need — that the AI work and the quantum work are one line of thought, not two — is the sentence this paper makes true.
419. Day 419 (AI): Discovering Symbolic Models from Deep Learning with Inductive Biases — Cranmer et al., 2020. A fitted model turned into a statement you can write down and argue with. The right last paper of the summer: the work is not finished when it runs, it is finished when it can be stated.
420. Day 420 (systems): Quantum error correction below the surface code threshold — Google Quantum AI, 2024. Below threshold, measured, with a real-time decoder in the loop. Read it as the last day of the ML-systems flagship and the first day of the quantum lane: the decoder is a latency-bound systems problem, and that is the door you walk through in the autumn.
421. Day 421 (systems): Simulating Physics with Computers — Feynman, 1982. The keynote that starts the field, and it starts it with a complaint about simulation cost — which is the thing you are about to measure for yourself. Read the part where he argues nature is not classical before you write a single amplitude.
422. Day 422 (systems): Ten simple rules for structuring papers — Mensh, Kording, 2017. One central claim, and every sentence in service of it. A résumé is the same problem compressed to a page, and today is the day to apply the rule rather than admire it.
423. Day 423 (systems): AlpaServe: Statistical Multiplexing with Model Parallelism for Deep Learning Serving — Li et al., 2023. A paper whose result is a distribution rather than a mean — latency attainment under bursty load, not an average. Read it the day you stop quoting one number for the flagship.
424. Day 424 (systems): Quantum theory, the Church-Turing principle and the universal quantum computer — Deutsch, 1985. You read this in the spring as a definition. Re-read §2 and §3 today with a simulator open: every claim about the universal quantum computer is now a claim about a loop you have written.
425. Day 425 (systems): A single quantum cannot be cloned — Wootters, Zurek, 1982. Half a page, and it removes an entire class of things you might otherwise have tried to implement today. Read it beside N&C's qubit-copying circuit and see that they are the same argument.
426. Day 426 (systems): Toward the first quantum simulation with quantum speedup — Childs, Maslov, Nam, Ross, Su, 2018. Gate counts for a simulation that would actually beat a classical machine, counted rather than estimated. An unhurried hour, and the numbers are the honest frame for everything else this term.
427. Day 427 (systems): Repeatability in Computer Systems Research — Collberg, Proebsting, 2016. They tried to build the code from 601 papers. The numbers are grim and they are the reason "it runs from a clean clone" is a claim worth making. You are about to make it twelve times.
428. Day 428 (systems): A Berkeley View of Systems Challenges for AI — Stoica et al., 2017. A whole department writing down the systems problems it thinks matter for the next decade. Read it in the week you are writing to departments, and mark which of the nine are now solved and which are not.
429. Day 429 (systems): Software Engineering at Google — Henderson, 2017. What engineering practice looks like when the codebase outlives everyone who wrote it. Read the build and testing sections today, and steal exactly the parts that a one-person repository can carry.
430. Day 430 (systems): Reproducible Research in Computational Science — Peng, 2011. The reproducibility spectrum, from a published figure to a runnable pipeline. Everything you write in the physics lane this term is computational science; decide today where on that spectrum your notes sit.
431. Day 431 (AI): An Empirical Model of Large-Batch Training — McCandlish, Kaplan, Amodei et al., 2018. How many samples an estimate needs before it stops improving, derived from the gradient noise scale. You implement sampling today; this is the same question asked in the lane you already know well.
432. Day 432 (systems): The Values Encoded in Machine Learning Research — Birhane, Kalluri, Card, Agnew, Dotan, Bao, 2021. What a field says it values, extracted from a hundred papers by annotation rather than by assertion. Read it in the week you are writing about what you value, in twelve letters.
433. Day 433 (systems): Software Engineering for Machine Learning: A Case Study — Amershi et al., 2019. Nine stages of an ML workflow, observed inside a company rather than proposed. The stage teams under-invest in is the one you are automating today.
434. Day 434 (systems): The Llama 3 Herd of Models — Grattafiori et al., 2024. An enormous engineering report that still says what was done and what was measured. Read the first twenty pages as a lesson in altitude: how to describe a system without either hiding it or drowning the reader.
435. Day 435 (systems): Improved Simulation of Stabilizer Circuits — Aaronson, Gottesman, 2004. A second reading, and a different one: you met it in the summer as a curiosity, and today it is the counterexample to the memory wall you are three days from measuring. Read the tableau update rule properly this time.
436. Day 436 (systems): A Step Toward Quantifying Independently Reproducible Machine Learning Research — Raff, 2019. Which features of a paper predict whether someone else can reimplement it — and code availability is not the strongest one. Your pinned repositories are the claim; this says what makes such a claim survive contact.
437. Day 437 (systems): ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning — Rajbhandari, Ruwase, Rasley, Smith, He, 2021. The classical memory wall, partitioned and offloaded, with the bandwidth arithmetic stated. You measure your own wall tomorrow; read the shape of the argument today, in units you already understand.
438. Day 438 (systems): On the Criteria To Be Used in Decomposing Systems into Modules — Parnas, 1972. Modules hide decisions, not steps. Your simulator is at the size where the wrong split becomes expensive; read this before the amplitude layout leaks into every file.
439. Day 439 (systems): 0.5 Petabyte Simulation of a 45-Qubit Quantum Circuit — Häner, Steiger, 2017. What it takes to push a statevector simulator to 45 qubits: half a petabyte, a supercomputer, and a lot of scheduling. Read it as the upper end of the table you are writing today.
440. Day 440 (systems): On the Einstein Podolsky Rosen Paradox — Bell, 1964. Six pages that turn a philosophical objection into an experiment. Read it beside N&C §2.6 and then compute the CHSH value yourself rather than quoting 2√2.
441. Day 441 (systems): The Complexity of Theorem-Proving Procedures — Cook, 1971. Boolean satisfiability as the problem everything else reduces to, from the author's own page. Read it the day you compile boolean logic into gates by hand, and beside N&C §3.2, which is about where BQP sits in the picture this paper drew.
442. Day 442 (systems): Sparse GPU Kernels for Deep Learning — Gale, Zaharia, Young, Elsen, 2020. Why a theoretically cheaper kernel is often slower, and what has to be true for the saving to arrive. Exactly the argument you are about to have with yourself about gate fusion.
443. Day 443 (systems): The Scientific Method in the Science of Machine Learning — Forde, Paganini, 2019. Short, and it asks what a controlled experiment would even look like in this field. Read it in the physics lane, where the answers are known and you can check whether your method would have found them.
444. Day 444 (systems): Quantum supremacy using a programmable superconducting processor — Arute et al., 2019. A re-read, as an experiment rather than as news. Ask what was measured, what was extrapolated, and where the 10,000-year figure comes from — then read the next two days. It is on Nature rather than arXiv, which a browser handles and a script does not always.
445. Day 445 (AI): Challenges in Deploying Machine Learning: a Survey of Case Studies — Paleyes, Urma, Lawrence, 2020. The failure modes teams have actually lived through, organised by stage. Naming one you hit yourself is what makes a letter specific rather than enthusiastic.
446. Day 446 (systems): QuEST and High Performance Simulation of Quantum Computers — Jones, Brown, Bush, Benjamin, 2019. A production statevector simulator with its threading, distribution and memory decisions written down. Read the sections on data layout the day you reorder your own loop.
447. Day 447 (systems): MegaBlocks: Efficient Sparse Training with Mixture-of-Experts — Gale, Narayanan, Young, Zaharia, 2022. A block-sparse primitive that removes a padding hack rather than optimising around it. Read it as an argument about picking the right primitive — the question your simulator faces every time a gate is not one of the special cases.
448. Day 448 (systems): Efficient Large-Scale Language Model Training on GPU Clusters Using Megatron-LM — Narayanan et al., 2021. Three kinds of parallelism composed, with the scaling measured on three thousand GPUs. Two of the four teams you write to today work at this scale; this is the vocabulary the reply will be in.
449. Day 449 (systems): Elementary gates for quantum computation — Barenco et al., 1995. The paper that proves CNOT plus single-qubit gates is enough, and then does the constructions explicitly. Every decomposition you will write for the next two years is in here somewhere.
450. Day 450 (systems): Leveraging Secondary Storage to Simulate Deep 54-qubit Sycamore Circuits — Pednault et al., 2019. The rebuttal that turned 10,000 years into 2.5 days by using disk. Read it against your own memory table — this is what the wall looks like when someone refuses to accept it.
451. Day 451 (systems): Machine Learning Operations (MLOps): Overview, Definition, and Architecture — Kreuzberger, Kühl, Hirschl, 2023. What has to exist before a model is runnable by someone who did not build it, written as roles and artifacts rather than as tools. Somebody else runs your repository today; this is the vocabulary for what they will find missing.
452. Day 452 (systems): Simulated Quantum Computation of Molecular Energies — Aspuru-Guzik, Dutoi, Love, Head-Gordon, 2005. Phase estimation pointed at a molecular Hamiltonian — the application Feynman was asking for on day 421. Read it as the target that makes the next three weeks of the track worth doing.
453. Day 453 (systems): Quantum Algorithms Revisited — Cleve, Ekert, Macchiavello, Mosca, 1998. Deutsch, Deutsch-Jozsa, Simon and Shor presented as one construction — a phase kickback and a Fourier transform. Read this once and four algorithms stop being four things.
454. Day 454 (AI): On the Opportunities and Risks of Foundation Models — Bommasani et al., 2021. Long, uneven, and read by everyone you are about to ask for a referral. Pick the two sections nearest your work and be able to say which claim in them you think is wrong.
455. Day 455 (systems): Quantum measurements and the Abelian Stabilizer Problem — Kitaev, 1995. Where phase estimation comes from, framed as a stabilizer problem rather than as a subroutine. Read it beside N&C §5.2 and notice that the book has simplified a more general result.
456. Day 456 (systems): Solving the sampling problem of the Sycamore quantum circuits — Pan, Chen, Zhang, 2022. Tensor networks close the gap almost entirely. Write the three-line history of this claim in your card; it is the most useful thing you can say about quantum advantage in an interview.
457. Day 457 (systems): A fast quantum mechanical algorithm for database search — Grover, 1996. You read the four pages in the spring. Re-read them today as a specification: every claim in it is something your implementation either reproduces or does not, and the iteration count is checkable within the hour.
458. Day 458 (systems): Tight bounds on quantum searching — Boyer, Brassard, Høyer, Tapp, 1996. The exact analysis of Grover with multiple marked items, including the over-rotation you will measure in a few days. Read it beside N&C §6.2 and check its formula against your own simulator.
459. Day 459 (AI): Pervasive Label Errors in Test Sets Destabilize Machine Learning Benchmarks — Northcutt, Athalye, Mueller, 2021. The benchmark you cited in four applications this month has errors in it, and the ordering of models changes when they are removed. Know the number before someone asks.
460. Day 460 (systems): Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer — Shor, 1997. Re-read on the day you implement period-finding, which is a different reading from the first one. Notice how much of the paper is classical number theory, and that the part you are building today is the smaller half.
461. Day 461 (systems): How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits — Gidney, Ekerå, 2021. A second reading, prompted by the day: you factored 15 yesterday, and this is the resource estimate for 2048 bits. Put the two numbers next to each other and write the ratio down.
462. Day 462 (systems): Data and its (dis)contents: A survey of dataset development and use in machine learning research — Paullada, Raji, Bender, Denton, Hanna, 2021. Where the data underneath the field came from, and what was not asked when it was collected. An unhurried hour, and a useful check on how confidently you have been citing benchmarks in twelve letters.
463. Day 463 (systems): On the Power of Quantum Computation — Simon, 1997. The oracle separation that pushed Shor toward period-finding. Read it as the first place the hidden-subgroup shape appears, then look at N&C §5.4 and see that it is the same problem over a different group.
464. Day 464 (systems): Quantum Complexity Theory — Bernstein, Vazirani, 1997. The universal quantum Turing machine done properly, and the recursive Fourier sampling separation. Long; read the first third today and the oracle sections when you implement the algorithm in two days.
465. Day 465 (systems): TensorFlow: A system for large-scale machine learning — Abadi et al., 2016. A systems paper about an ML system, which is the genre your one-pagers are trying to be. Read it for the structure — problem, design, alternatives rejected, measurement — and copy the structure, not the content.
466. Day 466 (systems): Rapid solution of problems by quantum computation — Deutsch, Jozsa, 1992. The first exponential separation, in six pages, and the one everyone learns first. It is a scan of the Proceedings on a Princeton course archive rather than an arXiv posting.
467. Day 467 (systems): FlexGen: High-Throughput Generative Inference of Large Language Models with a Single GPU — Sheng et al., 2023. What to do when the state does not fit: schedule it across the memory hierarchy and pay in bandwidth. You are about to square your memory cost by moving to density matrices; read the classical version of the same decision first.
468. Day 468 (systems): Quantum algorithm for solving linear systems of equations — Harrow, Hassidim, Lloyd, 2009. Exponential speedup for Ax = b, subject to four conditions that are easy to skip. Read it today and list the conditions before you read tomorrow's paper.
469. Day 469 (AI): PyTorch: An Imperative Style, High-Performance Deep Learning Library — Paszke et al., 2019. The design decisions behind the autograd you are going to hang parameter-shift gradients on in three weeks. Read the sections on the tape and on memory management against what tensorforge does.
470. Day 470 (AI): What is the State of Neural Network Pruning? — Blalock, Gonzalez Ortiz, Frankle, Guttag, 2020. A meta-analysis of 81 papers that finds almost none of them can be compared to each other, because none of them stated their conditions precisely enough. That is what a missing limitations section costs a field; write yours today so your work is not the eighty-second.
471. Day 471 (systems): Deja Vu: Contextual Sparsity for Efficient LLMs at Inference Time — Liu et al., 2023. Error introduced deliberately — heads and neurons dropped per input — and then bounded by measurement. Today you introduce error you did not choose, and the accounting discipline is identical.
472. Day 472 (systems): Many-body quantum state tomography with neural networks — Torlai, Mazzola, Carrasquilla, Troyer, Melko, Carleo, 2017. A neural network reconstructing a quantum state from measurements. This is one of the papers where the two pillars stop being two things; read it on the day the physics lane reaches spin.
473. Day 473 (systems): Carbon Emissions and Large Neural Network Training — Patterson et al., 2021. An accounting paper: every term named, nothing left in an unlabelled remainder. That is exactly the property you are turning into a unit test today, in a different ledger.
474. Day 474 (systems): Quantum Machine Learning Algorithms: Read the Fine Print — Aaronson, 2015. Four pages that take yesterday's paper apart caveat by caveat. Compare against your own list from yesterday and count how many you found.
475. Day 475 (systems): Quantum Error Correction for Beginners — Devitt, Munro, Nemoto, 2013. The one review that starts from the three-qubit code and builds up without assuming the stabilizer formalism first. Read the first third today; the rest belongs to a later term.
476. Day 476 (AI): Measuring the Effects of Data Parallelism on Neural Network Training — Shallue et al., 2019. An enormous, patient sweep whose result is a curve with a knee in it. That is exactly the measurement you are making today — how many trajectories buy how much agreement — and this is what doing it properly looks like.
477. Day 477 (systems): Ring Attention with Blockwise Transformers for Near-Infinite Context — Liu, Zaharia, Abbeel, 2023. The memory argument extended across devices, so the sequence length stops being bounded by one of them. Two of the four teams you write to today maintain something built on it.
478. Day 478 (systems): A Quantum Engineer's Guide to Superconducting Qubits — Krantz et al., 2019. Re-read the relaxation and dephasing sections specifically. You read the guide in the summer for orientation; today it is a reference, and you are fitting the exact number it names out of your own simulated data.
479. Day 479 (systems): The Heisenberg Representation of Quantum Computers — Gottesman, 1998. Track the operators instead of the state. That is the same move you are making today when you evaluate a Pauli string without materialising it — read the paper that makes it a formalism rather than a trick.
480. Day 480 (systems): Efficient classical simulation of slightly entangled quantum computations — Vidal, 2003. Entanglement, not qubit count, is what makes a circuit hard classically. Four pages, and it reframes the memory table you measured on day 439 as a statement about the wrong variable.
481. Day 481 (systems): Deep Learning Recommendation Model for Personalization and Recommendation Systems — Naumov et al., 2019. A model whose cost is memory access rather than arithmetic, published openly with its layout. The lesson transfers: today you replace a 4x4 matrix with three numbers and an offset, and the representation is the whole performance story.
482. Day 482 (systems): Pathways: Asynchronous Distributed Dataflow for ML — Barham et al., 2022. A report about a scheduler, written for people who did not build it. Read the first four sections for the order they put things in, then write yours in that order.
483. Day 483 (systems): Quantum Circuit Learning — Mitarai, Negoro, Kitagawa, Fujii, 2018. The paper that turns a parameterised circuit into a model you can fit, with the gradient rule stated. Read it the day you add the interface, before you implement the gradient.
484. Day 484 (systems): Randomized Benchmarking of Quantum Gates — Knill et al., 2008. How to measure an error rate without trusting your measurement apparatus, by making the sequence length the variable. Implement it today against noise you chose, where you already know the answer.
485. Day 485 (systems): Evaluating analytic gradients on quantum hardware — Schuld, Bergholm, Gogolin, Izaac, Killoran, 2019. The parameter-shift rule derived properly, including why it is exact rather than a finite difference. Read it the morning you implement it, and check the shift value against your own derivation.
486. Day 486 (systems): Improved classical simulation of quantum circuits dominated by Clifford gates — Bravyi, Gosset, 2016. The runtime cliff is in the T-count, not the qubit count. Read it beside yesterday's paper: two different answers to what actually makes a circuit expensive.
487. Day 487 (systems): Prescription for experimental determination of the dynamics of a quantum black box — Chuang, Nielsen, 1997. Process tomography, from the paper N&C §8.4.2 compresses into four pages. Implement it today against a channel you injected, which is the only setting where you can check the answer.
488. Day 488 (systems): Closing the AI Accountability Gap: Defining an End-to-End Framework for Internal Algorithmic Auditing — Raji et al., 2020. An audit framework meant to be run by the people who built the thing. Run the parts that apply to your own report today, before anyone else has a reason to.
489. Day 489 (systems): A variational eigenvalue solver on a quantum processor — Peruzzo et al., 2014. A re-read with a different question. First time it was the idea; today it is the design of the interface you built on day 483, and whether your optimizer choice matches the one they had to make.
490. Day 490 (systems): The Physical Implementation of Quantum Computation — DiVincenzo, 2000. The five criteria, stated once and quoted ever since. Read them today and keep the list — you will score every platform in chapter 7 against it, ending on day 503.
491. Day 491 (systems): Charge insensitive qubit design derived from the Cooper pair box — Koch et al., 2007. The transmon: buy charge-noise insensitivity and pay in anharmonicity. That trade is exactly the leakage you are about to measure, in the device that most of the industry actually uses.
492. Day 492 (systems): Classical simulation of quantum computation, the Gottesman-Knill theorem, and slightly beyond — Van den Nest, 2010. What "classically simulable" even means — sampling, computing an amplitude, computing a marginal are three different claims. Write the three definitions in your card; most arguments about quantum advantage are people using different ones.
493. Day 493 (systems): Barren plateaus in quantum neural network training landscapes — McClean, Boixo, Smelyanskiy, Babbush, Neven, 2018. Re-read it in order to reproduce it. The plot in this paper is the plot you are producing today, and a citation is not the same as a measurement.
494. Day 494 (systems): The Computational Complexity of Linear Optics — Aaronson, Arkhipov, 2011. BosonSampling: a hardness argument for a machine that cannot even run a general algorithm. Read it against N&C §7.4's honest list of why the optical computer does not scale.
495. Day 495 (AI): Mamba: Linear-Time Sequence Modeling with Selective State Spaces — Gu, Dao, 2023. A recurrence chosen for what the hardware can do with it, with the scan written to fit the memory hierarchy. Be able to derive at a whiteboard why the selective mechanism costs what it does — that is the level the interview will run at.
496. Day 496 (systems): Quantum computing with Qiskit — Javadi-Abhari et al., 2024. The architecture of the stack you are benchmarking against, written by the people who maintain it. Read the simulator and transpiler sections so the comparison is fair and you can say where they made a different choice.
497. Day 497 (systems): Simulating quantum computation by contracting tensor networks — Markov, Shi, 2008. Treewidth, not qubit count, is the cost — the result the 2022 Sycamore rebuttal you read on day 456 rests on. Implement enough of it today to see the crossover for yourself.
498. Day 498 (systems): Towards ML Engineering: A Brief History Of TensorFlow Extended (TFX) — Katsiapis et al., 2020. A history rather than a method: what a production ML platform learned over a decade, told as a sequence of mistakes. Finals week is the right time to read something that is mostly other people's hindsight.
499. Day 499 (systems): The Computational Limits of Deep Learning — Thompson, Greenewald, Lee, Manso, 2020. The extrapolation that says the field is running out of the resource it grew on. Have a view on it: some version of "where do you think this goes" is coming in an interview this month.
500. Day 500 (systems): Qulacs: a fast and versatile quantum circuit simulator for research purpose — Suzuki et al., 2021. A simulator whose paper is mostly about optimisation decisions — SIMD, caching, threading thresholds. Read it while profiling yours, and check each of their claims against your own numbers.
501. Day 501 (systems): Predicting Many Properties of a Quantum System from Very Few Measurements — Huang, Kueng, Preskill, 2020. Classical shadows: randomised measurements that predict many observables at once, with a sample-complexity bound. Read it and then beat your own direct estimator with it.
502. Day 502 (systems): Stim: a fast stabilizer circuit simulator — Gidney, 2021. A tool released well: a paper, a benchmark, a stated scope and a version people can pin. That is the standard for what you are tagging today, and the tool itself is what a later term will benchmark against.
503. Day 503 (systems): Variational Quantum Algorithms — Cerezo et al., 2021. A closing re-read. You met it in the summer as a survey; read the open-problems section now that six of your track steps are inside it, and pick the one you would work on. That choice is what the winter term is for.
504. Day 504 (AI): Deep Learning Scaling is Predictable, Empirically — Hestness et al., 2017. Power-law learning curves measured across four domains, years before the scaling-law papers everyone cites. A good last read for a term spent insisting that things be measured rather than asserted.
505. Day 505 (systems): Stabilizer Codes and Quantum Error Correction — Gottesman, 1997. The source. Read chapters 3 and 4 today for the formalism only — a state named by the operators that fix it — and leave the code constructions for the spring. Everything stab does for the next month is in those two chapters.
506. Day 506 (systems): Terminologies for Reproducible Research — Barba, 2018. Reproducible, replicable and repeatable mean different and incompatible things depending on who is writing. Pick the definitions you will use in the appendix today, and say in the appendix which ones you picked.
507. Day 507 (systems): The Clifford group, stabilizer states, and linear and quadratic operations over GF(2) — Dehaene, De Moor, 2003. The stabilizer formalism written as linear algebra over the two-element field, which is exactly the data structure you are implementing today. Read it and the tableau row operations stop being rules you copied and become the group action they are.
508. Day 508 (systems): Scientific Credibility of Machine Translation Research: A Meta-Evaluation of 769 Papers — Marie, Fujita, Rubino, 2021. Seven hundred papers scored against basic evaluation practice, and the trend over a decade is downward. Read it as a list of the specific omissions an appendix exists to prevent, then check your own against it.
509. Day 509 (systems): Fast simulation of stabilizer circuits using a graph state representation — Anders, Briegel, 2005. A different representation of the same states — a graph plus local Cliffords — with measurement handled by local complementation rather than a rank update. Read it as the alternative you did not choose, so that you can say why the tableau is the right choice for you.
510. Day 510 (systems): Fast simulation of planar Clifford circuits — Gosset, Grier, Kerzner, Schaeffer, 2020. Clifford circuits on a planar geometry simulate faster than the general case, because the geometry itself is structure. A catch-up day is the right amount of time for a result whose proof you will not follow on a Tuesday.
511. Day 511 (systems): On the Difficulty of Evaluating Baselines: A Study on Recommender Systems — Rendle, Zhang, Koren, 2019. Properly tuned, a decade-old baseline beats most of what replaced it. Read it while writing the reject review of your own paper, because "the baseline was undertuned" is the objection you are least equipped to answer and most likely to receive.
512. Day 512 (systems): A simple formula for the average gate fidelity of a quantum dynamical operation — Nielsen, 2002. Three pages, one formula, and it is the formula every benchmarking result you will read for the next month reports. Derive it rather than quoting it — you need the relation between average fidelity and process fidelity for the randomised benchmarking work later this month.
513. Day 513 (systems): With Little Power Comes Great Responsibility — Card et al., 2020. Statistical power in experiments that report a one-point improvement. Before you stand up and claim a difference, compute the power your sample size actually gives you — the answer is often that the experiment could not have detected the effect it reports.
514. Day 514 (systems): On the role of entanglement in quantum computational speed-up — Jozsa, Linden, 2002. Entanglement is necessary for exponential speed-up in pure-state computation, and it is not sufficient. Read it on the day you run a thousand entangled qubits in polynomial time, because that experiment is the cleanest possible counterexample to the folk claim.
515. Day 515 (systems): Multilinear Formulas and Skepticism of Quantum Computing — Aaronson, 2003. The strongest technical form of the skeptical position: if nature has a succinct classical description of every state, quantum computing fails, and here is what that description would have to look like. Read the case against on the day you commit to the field in writing.
516. Day 516 (systems): The garden of forking paths: Why multiple comparisons can be a problem, even when there is no "fishing expedition" — Gelman, Loken, 2013. You do not need to have p-hacked to have a result that is an artefact of the analysis you happened to choose. This is the paper to read the week after you submit, when it is too late to change anything and exactly the right time to know.
517. Day 517 (systems): Estimating outcome probabilities of quantum circuits using quasiprobabilities — Pashayan, Wallman, Bartlett, 2015. Simulation cost scaling with the negativity of a quasiprobability representation — a third currency alongside T-count and entanglement. Read it as the general frame that the Pauli frame you build today is a special case of.
518. Day 518 (AI): How Many Random Seeds? Statistical Power Analysis in Deep Reinforcement Learning Experiments — Colas, Sigaud, Oudeyer, 2018. The number of seeds required to detect an effect of a given size, computed rather than guessed. The design you write today has a metrics section, and this is the arithmetic it will be missing.
519. Day 519 (systems): Scalable Noise Estimation with Random Unitary Operators — Emerson, Alicki, Życzkowski, 2005. The idea before it had a name: twirl the noise with random unitaries and what is left is a single depolarizing parameter you can fit. Everything called randomised benchmarking descends from this.
520. Day 520 (systems): How to efficiently select an arbitrary Clifford group element — Koenig, Smolin, 2014. A canonical form for Clifford elements and an index into the group, so uniform sampling is a random integer rather than a random product of gates. Implement from this paper today; the naive alternative is not uniform and you will not notice.
521. Day 521 (systems): Robust randomized benchmarking of quantum processes — Magesan, Gambetta, Emerson, 2011. The fit model with the state-preparation and measurement errors separated out into the prefactor. Fit the wrong model and you get a plausible number that is not the gate error; this paper is why the fit has three parameters and not one.
522. Day 522 (systems): Characterizing Quantum Gates via Randomized Benchmarking — Magesan, Gambetta, Emerson, 2012. The long version: gate-dependent errors, the interleaved protocol, and the bounds that make the interleaved number honest. Read it slowly; it is the paper that makes yesterday's fit defensible.
523. Day 523 (systems): What randomized benchmarking actually measures — Proctor, Rudinger, Young, Sarovar, Blume-Kohout, 2017. The RB number is not the average gate infidelity in general, and the gap can be an order of magnitude. Read this the day after you got a clean fit, because a clean fit is exactly when you stop checking.
524. Day 524 (AI): Deep Reinforcement Learning at the Edge of the Statistical Precipice — Agarwal, Schwarzer, Castro, Courville, Bellemare, 2021. Point estimates over a handful of runs, and the interval estimates that should replace them. The stratified bootstrap they propose is what your simulator comparison should report today instead of a mean.
525. Day 525 (systems): Error mitigation for short-depth quantum circuits — Temme, Bravyi, Gambetta, 2016. Zero-noise extrapolation and probabilistic error cancellation: buying accuracy with sampling overhead rather than with qubits. Read it alongside twirling as the other thing a compiler can do about noise it cannot remove.
526. Day 526 (AI): Reporting Score Distributions Makes a Difference: Performance Study of LSTM-networks for Sequence Tagging — Reimers, Gurevych, 2017. Report a distribution, not a maximum. The difference between two systems is routinely smaller than the spread of either one across seeds — and the maximum is the statistic that hides that.
527. Day 527 (systems): Quantum Teleportation is a Universal Computational Primitive — Gottesman, Chuang, 1999. Gate teleportation: how a T gate becomes a Clifford circuit plus a prepared resource state and a correction. This is the mechanism behind magic-state injection, which stab implements in four days.
528. Day 528 (systems): Inconsistency in Conference Peer Review: Revisiting the 2014 NeurIPS Experiment — Cortes, Lawrence, 2021. Half the accepted papers would have been rejected by a second committee, measured twice seven years apart. Read it on a catch-up day and let it calibrate how much signal a review actually carries.
529. Day 529 (systems): Improved upper bounds on the stabilizer rank of magic states — Qassim, Pashayan, Gosset, 2021. How many stabilizer states it takes to write down a tensor product of magic states, which is the exponent in the cost of every non-Clifford gate you are about to charge for. The bound has come down over the years and the plot you draw next week moves with it.
530. Day 530 (systems): Application of a resource theory for magic states to fault-tolerant quantum computing — Howard, Campbell, 2016. Magic as a quantity with a monotone attached, so you can say how much of it a state has and prove distillation cannot create it. This is what turns "T gates are expensive" into an accounting system.
531. Day 531 (systems): The Resource Theory of Stabilizer Computation — Veitch, Mousavian, Gottesman, Emerson, 2013. Stabilizer operations as the free operations of a resource theory, with mana as the measure. Read it as the theoretical statement of the curve you are about to plot: what the free part is, and what you have to pay for.
532. Day 532 (systems): Simulation of quantum circuits by low-rank stabilizer decompositions — Bravyi, Browne, Calpin, Campbell, Gosset, Howard, 2018. The best-known base for the exponential in T-count, and the algorithmic tricks that get it there. Put its exponent on your plot as a reference line and say honestly where yours sits relative to it.
533. Day 533 (systems): The Ladder: A Reliable Leaderboard for Machine Learning Competitions — Blum, Hardt, 2015. Repeated querying of a holdout overfits it, and there is a mechanism that stops it. Read it before you build a personal leaderboard out of your own practice problems, because you are about to.
534. Day 534 (systems): Fault-tolerant quantum computation by anyons — Kitaev, 1997. Error correction as a property of the medium rather than a procedure applied on top of it. It is a hard paper and a catch-up day is the only time you will give it the three uninterrupted hours it needs.
535. Day 535 (systems): Hadamard-free circuits expose the structure of the Clifford group — Bravyi, Maslov, 2020. A canonical decomposition of Clifford circuits into a small number of layers, which is what a fast implementation exploits and a naive one does not. Read it before the benchmark so you can tell an algorithmic loss from an unvectorised loop.
536. Day 536 (AI): Preserving Statistical Validity in Adaptive Data Analysis — Dwork, Feldman, Hardt, Pitassi, Reingold, Roth, 2015. The reusable holdout: how differential privacy buys you validity under adaptive reuse of the same test set. This is the formal version of yesterday's worry about your own practice leaderboard.
537. Day 537 (systems): Complexity-Theoretic Foundations of Quantum Supremacy Experiments — Aaronson, Chen, 2016. What a sampling-based advantage claim would actually have to prove, and the conjectures it rests on. Read it as the standard your own "what this cannot represent" note should be held to.
538. Day 538 (systems): Characterizing Quantum Supremacy in Near-Term Devices — Boixo et al., 2016. Where the cross-entropy benchmarking fidelity comes from and why the Porter-Thomas distribution makes it work. Implement the estimator today from this paper rather than from a blog post.
539. Day 539 (systems): Average-case complexity versus approximate simulation of commuting quantum computations — Bremner, Montanaro, Shepherd, 2015. What a hardness claim for approximate sampling actually requires, stated as conjectures rather than assumed. Read it on the day you measure a real success probability and see how much of the theory it takes to justify one number.
540. Day 540 (systems): Classical Simulation of Quantum Supremacy Circuits — Huang et al., 2020. The tensor-network contraction that first narrowed the gap, with the memory-time trade-off spelled out. Read it alongside the paper from day 539 as the two halves of the same argument.
541. Day 541 (systems): Classical simulation of commuting quantum computations implies collapse of the polynomial hierarchy — Bremner, Jozsa, Shepherd, 2010. Commuting circuits are shallow, structured, and almost certainly hard to simulate exactly — and their amplitudes are partition functions, so the contraction you write today is the natural way to attack them. Theory and today's code meet on the same object.
542. Day 542 (systems): Simulation of Qubit Quantum Circuits via Pauli Propagation — Rall, Liang, Cook, Kretschmer, 2019. Propagate Pauli operators rather than amplitudes and the cost tracks the sparsity of the observable, not the size of the state. A fourth efficient regime, orthogonal to the three you already have.
543. Day 543 (systems): Classical simulation of noninteracting-fermion quantum circuits — Terhal, DiVincenzo, 2001. A third efficiently simulable class with no relation to the other two. Three papers in three days, three different reasons a quantum circuit can be classical — this is what "quantum advantage" has to survive.
544. Day 544 (AI): Reproducibility of Benchmarked Deep Reinforcement Learning Tasks for Continuous Control — Islam, Henderson, Gomrokchi, Precup, 2017. Published baselines that do not reproduce from published hyperparameters. Read it on the day you pick a baseline to beat, because the number in the paper is not the number you will get and you need to know that before you build on it.
545. Day 545 (systems): Efficient tensor network simulation of IBM's Eagle kicked Ising experiment — Tindall, Fishman, Stoudenmire, Sels, 2023. A hardware result reproduced classically on a laptop within weeks. Read it for the pattern — a claim, a cheaper classical method, and a revised claim — because this is the pattern your own benchmark section will be judged by.
546. Day 546 (systems): Instantaneous Quantum Computation — Shepherd, Bremner, 2008. The IQP model: commuting gates, no adaptivity, and provably not universal — and still hard to simulate. A catch-up day is the right place for a model that exists to sharpen a question rather than to run anything.
547. Day 547 (systems): Tackling the Qubit Mapping Problem for NISQ-Era Quantum Devices — Li, Ding, Xie, 2019. SABRE: the heuristic you will implement in eight days, and the reverse-traversal trick for the initial layout that is the part people skip. Read it now so the IR you design today can carry what the router will need.
548. Day 548 (systems): Open Quantum Assembly Language — Cross, Bishop, Smolin, Gambetta, 2017. The grammar you are about to implement, with the design reasoning attached. Note what it deliberately does not represent — that omission is the reason OpenQASM 3 exists and you will read that tomorrow.
549. Day 549 (systems): OpenQL : A Portable Quantum Programming Framework for Quantum Accelerators — Khammassi et al., 2020. A compiler framework with the intermediate representations named and the passes between them separated. Read the IR layering on the day you build the DAG, because the DAG is where your own layering stops being implicit.
550. Day 550 (AI): Towards the Systematic Reporting of the Energy and Carbon Footprints of Machine Learning — Henderson, Hu, Romoff, Brunskill, 2020. A framework that turns a training run into an accounted cost. A design answer with no cost model is a wish, and today you are writing one with a budget in it — this is what a real budget looks like.
551. Day 551 (systems): Qiskit Backend Specifications for OpenQASM and OpenPulse Experiments — McKay et al., 2018. The actual schema you are about to parse: coupling map, gate durations, per-edge error rates, and the calibration timestamp. Read it as a data format, and note which fields your router currently throws away.
552. Day 552 (systems): Characterizing large-scale quantum computers via cycle benchmarking — Erhard et al., 2019. Benchmarking whole cycles of parallel gates rather than single gates in isolation, because crosstalk is the error that isolation hides. Read it on a catch-up day as the correction to a month of single-gate thinking.
553. Day 553 (systems): Quantum Lower Bounds by Polynomials — Beals, Buhrman, Cleve, Mosca, de Wolf, 1998. The polynomial method, from the paper that introduced it, which is exactly the KLM section you are reading today. Work the degree argument for OR alongside the chapter and the technique stops being a name.
554. Day 554 (systems): Mapping Quantum Circuits to IBM QX Architectures Using the Minimal Number of SWAP and H Operations — Wille, Burgholzer, Zulehner, 2019. An exact formulation of the mapping problem solved with a satisfiability solver, giving the true optimum on small circuits. That optimum is the yardstick your heuristic should be measured against, not another heuristic.
555. Day 555 (systems): On the qubit routing problem — Cowtan, Dilkes, Duncan, Krajenbrink, Simmons, Sivarajah, 2019. The routing problem stated cleanly, with the solution decomposed into layout, routing and cleanup. Read it for the decomposition — it is what stops your router from becoming one function nobody can modify.
556. Day 556 (AI): What Will it Take to Fix Benchmarking in Natural Language Understanding? — Bowman, Dahl, 2021. Four criteria a benchmark must satisfy to be worth optimizing against. Hold your own router benchmark suite up to all four today, while it is still cheap to change which circuits are in it.
557. Day 557 (systems): t|ket>: A Retargetable Compiler for NISQ Devices — Sivarajah, Dilkes, Cowtan, Simmons, Edgington, Duncan, 2020. A production compiler's architecture: passes, predicates on what a pass requires and guarantees, and retargeting. The predicate system is the idea to steal — it is what makes a pass pipeline debuggable.
558. Day 558 (systems): Compiling quantum circuits to realistic hardware architectures using temporal planners — Venturelli, Do, Rieffel, Frank, 2017. Qubit mapping expressed as a temporal planning problem and handed to an off-the-shelf planner. Read it as the reminder that your routing problem is an instance of something older, with fifty years of solvers behind it.
559. Day 559 (systems): Circuit Transformations for Quantum Architectures — Childs, Schoute, Unsal, 2019. Routing analysed as token swapping on a graph, with bounds rather than benchmarks. Read it for what the theory says the SWAP count must be, so that your reverse pass has a floor to be measured against.
560. Day 560 (AI): Dynabench: Rethinking Benchmarking in NLP — Kiela et al., 2021. A benchmark that moves when models catch up to it. Read it as the argument against your own fixed circuit suite, and decide deliberately whether to accept the argument or reject it in writing.
561. Day 561 (systems): Synthesis of Quantum Logic Circuits — Shende, Bullock, Markov, 2004. The cosine-sine decomposition and the lower bound on CNOT count for a general two-qubit unitary. The bound is three; if your decomposer uses more, you now know it is not optimal and by how much.
562. Day 562 (systems): Fast and efficient exact synthesis of single qubit unitaries generated by Clifford and T gates — Kliuchnikov, Maslov, Mosca, 2012. Exact synthesis over the ring of integers with a square root of two: an algebraic criterion for which unitaries are exactly representable, and an algorithm that finds the optimal sequence. Much better than Solovay-Kitaev, and read on the day you have felt Solovay-Kitaev's constants.
563. Day 563 (systems): Optimal ancilla-free Clifford+T approximation of z-rotations — Ross, Selinger, 2014. Optimal T-count for a z-rotation at a given precision, from a number-theoretic search rather than a recursion. Compare the sequence lengths against yesterday's Solovay-Kitaev output on the same targets; the gap is large and it is the point.
564. Day 564 (systems): A meet-in-the-middle algorithm for fast synthesis of depth-optimal quantum circuits — Amy, Maslov, Mosca, Roetteler, 2012. Optimal synthesis by search, with the memory-time trade-off that makes it tractable. Read it as the exact answer your heuristics are approximating, and note the circuit sizes at which exact stops being possible.
565. Day 565 (AI): Underspecification Presents Challenges for Credibility in Modern Machine Learning — D'Amour et al., 2020. Equally good training runs encode different inductive biases and behave differently off-distribution. Read it the day the reviews arrive, because at least one reviewer is going to ask why your result should hold in a setting you did not test, and this is the honest answer.
566. Day 566 (systems): Optimization of Quantum Circuit Mapping using Gate Transformation and Commutation — Itoko, Raymond, Imamichi, Matsuo, 2019. Commutation rules used inside the mapping pass rather than as a separate cleanup, which is the design decision your pipeline has to make today. Their gate-transformation trick is worth stealing outright.
567. Day 567 (systems): Graph-theoretic Simplification of Quantum Circuits with the ZX-calculus — Duncan, Kissinger, Perdrix, van de Wetering, 2019. Circuit optimization as graph rewriting in a calculus where the rewrite rules are sound by construction. It also produces the best T-count reductions available, which is why it is worth the unfamiliar notation.
568. Day 568 (systems): PyZX: Large Scale Automated Diagrammatic Reasoning — Kissinger, van de Wetering, 2019. The implementation of yesterday's calculus, with the extraction problem — turning a simplified graph back into a circuit — treated as the hard part it is. Read the extraction section; it is where a naive implementation loses everything it gained.
569. Day 569 (AI): Leakage and the Reproducibility Crisis in ML-based Science — Kapoor, Narayanan, 2022. Eight kinds of leakage, and 300-odd papers across 17 fields with one of them. Run the taxonomy over your own pipeline today, while you are already rereading it for the response.
570. Day 570 (systems): Has the Machine Learning Review Process Become More Arbitrary as the Field Has Grown? The NeurIPS 2021 Consistency Experiment — Beygelzimer, Dauphin, Liang, Wortman Vaughan, 2023. Two independent committees, the same papers, and the disagreement rate measured rather than complained about. Read it on the day you most want to take your reviews personally.
571. Day 571 (systems): Automated optimization of large quantum circuits with continuous parameters — Nam, Ross, Su, Childs, Maslov, 2017. A published optimizer with a published benchmark table, which is the second thing to compare against once you have compared against Qiskit. Note how they report: per-circuit, per-metric, with the losses shown.
572. Day 572 (systems): An Efficient Quantum Compiler that reduces T count — Heyfron, Campbell, 2017. T-count reduction as the optimization that matters when the machine is fault-tolerant, because T gates are what a surface code actually charges for. This is the number your estimator should print first.
573. Day 573 (systems): Quipper: A Scalable Quantum Programming Language — Green, Lumsdaine, Ross, Selinger, Valiron, 2013. Circuits as first-class values in a functional host language, with circuit transformers as ordinary functions. Read it as a design alternative to your IR and be able to say, in an interview, why you did not do it that way.
574. Day 574 (systems): Q#: Enabling scalable quantum computing and development with a high-level domain-specific language — Svore et al., 2018. The design decisions of a language built for resource estimation at scale: adjoint and controlled as language features, and the type system that keeps classical and quantum data apart. Compare with Quipper from yesterday.
575. Day 575 (systems): A Practical Quantum Instruction Set Architecture — Smith, Curtis, Zeng, 2016. Quil: a hybrid instruction set with classical memory and control flow in it from the start. Read it for the shared-memory model between the classical and quantum halves, which is the part your IR has been ignoring.
576. Day 576 (systems): Basic circuit compilation techniques for an ion-trap quantum machine — Maslov, 2016. A different machine with all-to-all connectivity, where the routing problem you have spent a month on simply does not exist and a different problem replaces it. Read it as the check on how architecture-specific your assumptions have become.
577. Day 577 (systems): Measurement-based quantum computation with cluster states — Raussendorf, Browne, Briegel, 2003. A universal model with no unitary gates at all: prepare an entangled resource and then only measure. Read it after a month of circuit compilation, as the demonstration that the circuit model is a choice.
578. Day 578 (AI): Shortcut Learning in Deep Neural Networks — Geirhos et al., 2020. Models that solve the benchmark without solving the task, and the diagnostic tests that expose it. Read it while packaging your artifact, because an artifact that only reproduces on your data is the systems version of the same failure.
579. Day 579 (systems): Quantum Computation by Adiabatic Evolution — Farhi, Goldstone, Gutmann, Sipser, 2000. The third model: encode the answer in a ground state and evolve slowly enough to stay there. The whole question is how slowly, and the whole question is the gap.
580. Day 580 (systems): Adiabatic Quantum Computation is Equivalent to Standard Quantum Computation — Aharonov, van Dam, Kempe, Landau, Lloyd, Regev, 2004. The equivalence proof, and the circuit-to-Hamiltonian construction that makes it work. Read it as the answer to "is adiabatic computing a different kind of computing" — it is not, and the proof is constructive.
581. Day 581 (systems): Quantum Computational Complexity — Watrous, 2008. The survey that states the definitions carefully — BQP, QMA, QIP — and the containments that are actually proven. Read it as the reference you check before saying anything about complexity out loud in an interview.
582. Day 582 (systems): BQP and the Polynomial Hierarchy — Aaronson, 2009. The oracle problem that would separate BQP from the polynomial hierarchy, and the conjectures it needed. Read it on a catch-up day for the structure of the argument rather than the details, and note how long the conjectures stayed open.
583. Day 583 (systems): Classical Verification of Quantum Computations — Mahadev, 2018. A classical machine can check a quantum computation, under a cryptographic assumption. Read it on the day you implement an algorithm whose output is a state you cannot read: unusable output and unverifiable output are the same problem wearing different clothes.
584. Day 584 (systems): The Need for Structure in Quantum Speedups — Aaronson, Ambainis, 2009. Speedups need structure in the problem, and the conjecture is that unstructured problems admit at most a polynomial one. This is the fine print underneath every quantum machine learning claim, stated as a theorem rather than as a caveat.
585. Day 585 (systems): Quantum Supremacy through the Quantum Approximate Optimization Algorithm — Farhi, Harrow, 2016. An algorithm shaped around the machine that exists rather than the machine anyone wants — shallow, fixed-depth, and defended on hardness grounds. The hardware lottery has a quantum version and this is what winning it looks like.
586. Day 586 (AI): Deep Learning: A Critical Appraisal — Marcus, 2018. Ten limitations, some of which aged well and some of which did not. Read it as an exercise in scoring a critique after the fact: which objections were about the method and which were about the year.
587. Day 587 (systems): Quantum Computation as Geometry — Nielsen, Dowling, Gu, Doherty, 2006. Circuit cost as distance in a metric on the unitary group, so finding an optimal circuit becomes finding a geodesic. Read it on the day you simulate a gate as a driven Hamiltonian: the continuous picture underneath the discrete one.
588. Day 588 (systems): An Introduction to Quantum Error Correction and Fault-Tolerant Quantum Computation — Gottesman, 2009. The lecture-notes version, written to be read straight through. It is the bridge from the stabilizer formalism you have been implementing all term to the codes the spring is about, and a catch-up day is where it fits.
589. Day 589 (systems): Measuring the Capabilities of Quantum Computers — Proctor, Rudinger, Young, Nielsen, Blume-Kohout, 2020. Volumetric benchmarks: a two-dimensional map of width against depth instead of a single scalar. Read it against quantum volume and decide which one your harness should report, then say why in the README.
590. Day 590 (systems): Demonstration of qubit operations below a rigorous fault tolerance threshold with gate set tomography — Blume-Kohout et al., 2016. Gate set tomography: characterise the gates, the preparation and the measurement together, because you cannot assume any of them. Read it as the rigorous alternative to the benchmarking you implemented in November, and note what the rigour costs in experiments.
591. Day 591 (systems): Utility is in the Eye of the User: A Critique of NLP Leaderboards — Ethayarajh, Jurafsky, 2020. A leaderboard ranks on one axis and hides compute, latency and fairness. Your router table has the same problem — depth and SWAP count are two axes and compile time is a third you are about to lose a comparison on.
592. Day 592 (AI): Fine-Tuning Pretrained Language Models: Weight Initializations, Data Orders, and Early Stopping — Dodge et al., 2020. The spread across seeds is large enough that the best of ten runs beats the mean of ten runs by more than most reported improvements. Apply the same treatment to your own benchmark table before an interviewer does.
593. Day 593 (systems): AI and the Everything in the Whole Wide World Benchmark — Raji, Bender, Paullada, Denton, Hanna, 2021. Benchmarks claiming generality that measure something much narrower, and the construct-validity argument for why. Read it on the last working day of the term as the standard your own four artifacts should be described against — narrowly, and with what they do not show.
594. Day 594 (systems): A Systematic Review of Reproducibility Research in Natural Language Processing — Belz, Agarwal, Shimorina, Reiter, 2021. What happened when people actually tried to reproduce published results at scale, and how rarely the numbers matched exactly. Read it as the closing argument for why the last ninety days were spent this way.
595. Day 595 (systems): Ten Simple Rules for Reproducible Computational Research — Sandve, Nekrutenko, Taylor, Hovig, 2013. Ten rules, and today you find out how many of them last term's repository actually follows. Read it first thing, then run the pipeline and mark each rule pass or fail from evidence.
596. Day 596 (systems): Good Enough Practices in Scientific Computing — Wilson, Bryan, Cranston, Kitzes, Nederbragt, Teal, 2017. The floor, not the ceiling. Every fix you make today should be one of these; if a fix is not on this list, ask whether you are gold-plating instead of repairing.
597. Day 597 (systems): Ten Simple Rules for Better Figures — Rougier, Droettboom, Bourne, 2014. You are about to rebuild every figure in the writeup. Read the rules before you rebuild them, so the rebuild fixes the design and not only the plumbing.
598. Day 598 (systems): Quantum Circuit Placement — Maslov, Falconer, Mosca, 2007. The mapping problem stated cleanly a decade before it was fashionable, as a graph problem with a cost function. Read it the morning you add a second term to that cost function, so you know which part of the formulation you are changing.
599. Day 599 (systems): Fault-Tolerant Operation of a Quantum Error-Correction Code — Egan et al., 2020. A real device's error budget, itemised. Read it for how badly a product of per-gate fidelities predicts what a whole circuit actually does — which is the estimate you are about to publish a number from.
600. Day 600 (systems): Cargo Cult Science — Feynman, 1974. The standard you are about to be held to by nobody except yourself, stated by someone who meant it. Read it the week before you start writing a paper with your name first on it.
601. Day 601 (systems): Surface codes: Towards practical large-scale quantum computation — Fowler, Mariantoni, Martinis, Cleland, 2012. A deliberate re-read: you read it on day 384 as a survey, and you now have a decoder to build against it. Read it cover to cover again and write down the three numbers you will be trying to reproduce by day 661.
602. Day 602 (systems): The Science of Scientific Writing — Gopen, Swan, 1990. Sentence-level structure treated as an engineering problem: where the reader expects the point, and what happens when it is elsewhere. Today you write one sentence that has to survive being read once, quickly, by someone tired.
603. Day 603 (systems): Quantum Low-Density Parity-Check Codes — Breuckmann, Eberhardt, 2021. Codes built from classical parity checks, taken well past the CSS construction you are doing by hand today. Read it for the parameters the surface code gives up, and what the alternatives ask for in exchange.
604. Day 604 (systems): t|ket> : A Retargetable Compiler for NISQ Devices — Sivarajah, Dilkes, Cowtan, Simmons, Edgington, Duncan, 2020. A production compiler with its pass structure written down. Compare its architecture-aware pass ordering against yours and note the two passes you do not have.
605. Day 605 (systems): Realization of real-time fault-tolerant quantum error correction — Ryan-Anderson et al., 2021. Correction applied while the circuit is still running, on trapped ions. Read it for why the classical bookkeeping you are writing today is what makes real-time correction possible at all.
606. Day 606 (systems): Quantum Computing with Very Noisy Devices — Knill, 2005. Postselection and teleported error correction pushing the threshold far above what anyone expected, at an overhead nobody wants to pay. Read it on a slow day as the clearest example of a threshold being a statement about a scheme, not about nature.
607. Day 607 (systems): Ten Simple Rules for Reproducible Research in Jupyter Notebooks — Rule et al., 2019. Rules for the kind of code that runs an experiment rather than ships a product, which is exactly what a benchmark harness is. Read it before the harness exists, so it is built to be re-run rather than retro-fitted.
608. Day 608 (systems): Circuit Transformations for Quantum Architectures — Childs, Schoute, Unsal, 2019. Routing with lower bounds attached, which is the thing a benchmark table cannot give you: a statement about how much room is left. Read it the day you write your ratios, so you know whether losing to Qiskit means losing to the problem.
609. Day 609 (systems): State of the Art: Reproducibility in Artificial Intelligence — Gundersen, Kjensmo, 2018. A survey that counts how many papers document enough to be re-run, with the checklist it used. Score your own qroute benchmark against that checklist today, before you publish the table.
610. Day 610 (systems): Relaxing Hardware Requirements for Surface Code Circuits using Time-dynamics — McEwen, Bacon, Gidney, 2023. What connectivity actually buys, answered by trading it against time. Read it before you sweep degree, so the sweep tests a hypothesis rather than producing a curve.
611. Day 611 (systems): Polynomial-time T-depth Optimization of Clifford+T circuits via Matroid Partitioning — Amy, Maslov, Mosca, 2013. T-depth is the cost that survives error correction, and this is the algorithm that reduced it. Read it as the optimisation your compiler will need once the target is a fault-tolerant machine rather than a NISQ one.
612. Day 612 (systems): Scientific Benchmarking of Parallel Computing Systems — Hoefler, Belli, 2015. Twelve rules for reporting performance measurements, most of which your qroute table currently breaks. Read it and mark which rules you will fix before the design note goes out.
613. Day 613 (systems): Reducing T-count with the ZX-calculus — Kissinger, van de Wetering, 2019. A rewriting system that beats hand-designed passes on the metric that matters. Read it as the answer to "what would a better heuristic need" — it is a different representation, not a better search.
614. Day 614 (systems): Restrictions on Transversal Encoded Quantum Gate Sets — Eastin, Knill, 2009. The no-go theorem that shapes every fault-tolerant architecture: no code gives a universal transversal gate set. Read it before you spend a week looking for the transversal T you will not find.
615. Day 615 (systems): Ten Simple Rules for a Good Poster Presentation — Erren, Bourne, 2007. You will present this work at a poster session before it is a paper. Read the rules while the results are still forming, because the poster is what forces you to decide what the single message is.
616. Day 616 (systems): Magic state distillation with low overhead — Bravyi, Haah, 2012. The triorthogonal code family and the overhead scaling that made distillation affordable. Read it against yesterday's 15-to-1 simulation and compute what your factory would cost at the same target error.
617. Day 617 (systems): Magic State Distillation: Not as Costly as You Think — Litinski, 2019. A careful re-costing that overturns the received number by choosing the protocol per target error rate. Read it as an example of a result that is entirely accounting and is still a result.
618. Day 618 (systems): Ten Simple Rules for Doing Your Best Research, According to Hamming — Erren, Cullen, Erren, Bourne, 2007. Hamming's talk compressed to ten rules, read twelve days after the talk itself. The compression is the exercise: notice which of his points survived and which did not.
619. Day 619 (systems): A Theory of Quantum Error-Correcting Codes — Knill, Laflamme, 1997. The conditions you verified numerically on day 604, in the paper that proved them. Read it now that you have used them, which is the order that makes the algebra mean something.
620. Day 620 (systems): Ten Simple Rules for Getting Published — Bourne, 2005. Rule one is "read many papers, and learn from both the good and the bad ones", which is literally today's task. Read it before the related-work table, not after.
621. Day 621 (systems): Operator Quantum Error Correcting Subsystems for Self-Correcting Quantum Memories — Bacon, 2006. Subsystem codes, where some degrees of freedom are deliberately not protected. Read it for the idea that gauge qubits buy you low-weight measurements — the same trade the rotated surface code makes tomorrow.
622. Day 622 (systems): Dynamically Generated Logical Qubits — Hastings, Haah, 2021. A code whose logical qubits exist only as a sequence of measurements, with no static stabilizer group at all. Read it on the day you fix a layout, as proof that the layout is a choice and not a law.
623. Day 623 (systems): Quantum codes on a lattice with boundary — Bravyi, Kitaev, 1998. The planar version, which is the one anybody builds. Read it for why two kinds of boundary are needed and what the logical operators become — the detail your matching graph will get wrong first.
624. Day 624 (systems): Decoding Across the Quantum LDPC Code Landscape — Roffe, White, Burton, Campbell, 2020. One decoder run across many code families, which is the comparison that shows how much of a decoder's performance is the code and how much is the algorithm. Read it on a day with no build.
625. Day 625 (systems): Towards practical classical processing for the surface code — Fowler, Whiteside, Hollenberg, 2012. The paper that treats decoding as a real-time systems problem with a latency budget. Read it now so that everything you build from today is measured in microseconds as well as in accuracy.
626. Day 626 (systems): Single-shot fault-tolerant quantum error correction — Bombin, 2015. Whether one round of syndrome can ever be enough, and what a code has to look like for that to be true. Read it the day you start sampling rounds, because it tells you what the rounds are buying.
627. Day 627 (systems): Ten Simple Rules for Effective Statistical Practice — Kass, Caffo, Davidian, Meng, Peng, Reid, 2016. Variability, sample size and the difference between an estimate and the thing estimated, in ten rules. Today you build the interval that keeps you honest about the size of your logical error rate.
628. Day 628 (systems): Almost-linear time decoding algorithm for topological codes — Delfosse, Nickerson, 2021. A deliberate re-read of the day-388 paper, this time as an implementation specification rather than an idea. Cluster growth and peeling instead of matching; read it while you are building the graph both decoders will run on, so the graph serves both.
629. Day 629 (systems): Fast Decoders for Topological Quantum Codes — Duclos-Cianci, Poulin, 2010. Renormalisation-group decoding, an approach neither matching nor union-find. Read it as evidence that the decoder design space is larger than the two options you are about to implement.
630. Day 630 (systems): Topological Quantum Distillation — Bombin, Martin-Delgado, 2006. Color codes: transversal Clifford gates, at the cost of a harder decoding problem. Read it as the alternative your surface-code work implicitly rejected, and be able to say why.
631. Day 631 (systems): Fault-tolerant quantum computation with high threshold in two dimensions — Raussendorf, Harrington, 2007. The result that made the surface code the default: a ~1% threshold with nearest-neighbour gates. Read it before you sample, so you know what number the simulation is supposed to approach.
632. Day 632 (systems): Quantum computing with nearest neighbor interactions and error rates over 1% — Wang, Fowler, Hollenberg, 2011. A careful threshold measurement with the simulation methodology stated. Read the methodology section as the template for your own day-655 experiment, including how many shots per point they used.
633. Day 633 (systems): Ten Simple Rules for Writing Research Papers — Zhang, 2014. Read it against the paper skeleton you wrote on day 602 and mark which rules your current draft breaks. This is a checklist day, not a reading day.
634. Day 634 (systems): Fault-tolerant thresholds for quantum error correction with the surface code — Stephens, 2014. Thresholds under circuit-level noise for several extraction schedules, which is the comparison that shows how much the schedule matters. Read it alongside the ordering you chose on day 625.
635. Day 635 (systems): Fault-Tolerant Quantum Computation With Constant Error Rate — Aharonov, Ben-Or, 1999. The threshold theorem in its original form. Read it for what it assumes — independent noise, fresh ancillas, parallel gates — because those assumptions are what a referee will ask you about.
636. Day 636 (systems): Reliable Quantum Computers — Preskill, 1998. The argument for why fault tolerance is possible at all, written when it was still surprising. Read it slowly; it is the clearest statement of what the threshold theorem is actually claiming.
637. Day 637 (systems): Sparse Blossom: correcting a million errors per core second with minimum-weight matching — Higgott, Gidney, 2023. A deliberate re-read of the day-389 paper, now that you are writing the matcher rather than reading about one. The sparsity argument is the whole trick; read it again and mark which parts you are going to skip and pay for later.
638. Day 638 (systems): PyMatching: A Python package for decoding quantum codes with minimum-weight perfect matching — Higgott, 2021. The interface everyone uses, and the local-matching approximation that made it practical. Read it as the API you will be compared against, and note where its assumptions differ from yours.
639. Day 639 (systems): Minimum weight perfect matching of fault-tolerant topological quantum error correction in average $O(1)$ parallel time — Fowler, 2014. The locality argument that makes matching parallelisable, and the reason a decoder can keep up with a machine. Read it against yesterday's single-threaded implementation and note what would have to change.
640. Day 640 (systems): Unreproducible Research is Reproducible — Bouthillier, Laurent, Vincent, 2019. Fixing seeds makes a result re-runnable and can hide that it is not replicable. Read it on the day you wire in a reference decoder, and decide which of your comparisons are seed-matched and which must not be.
641. Day 641 (systems): Toward a Union-Find decoder for quantum LDPC codes — Delfosse, Londe, Beverland, 2022. Union-find generalised past the surface code, which shows which parts of the algorithm were topology-specific. Read it as the answer to "does your decoder only work here".
642. Day 642 (systems): Decoding algorithms for surface codes — deMarti iOlius, Fuentes, Orús, Crespo, Etxezarreta Martinez, 2024. A survey of the whole decoder landscape with the trade-offs tabulated. Read it after you have written two decoders, which is when the table becomes legible rather than intimidating.
643. Day 643 (systems): Stability Experiments: The Overlooked Dual of Memory Experiments — Gidney, 2022. The experiment that tests whether you can measure a stabilizer reliably over time, which is exactly the failure mode you are about to add to the model. Read it as a reminder that memory experiments do not cover everything.
644. Day 644 (systems): Low-distance Surface Codes under Realistic Quantum Noise — Tomita, Svore, 2014. Small-distance behaviour under realistic noise, which is where your d = 3 and d = 5 results live. Read it for the reminder that low-distance codes can behave in ways the asymptotic story does not predict.
645. Day 645 (systems): Ten simple rules for writing a response to reviewers — Noble, 2017. You will write one of these this term, and the temptation will be to argue. Read the rules now, before you have a specific reviewer to be annoyed at.
646. Day 646 (systems): Statistical mechanical models for quantum codes with correlated noise — Chubb, Flammia, 2021. The mapping from decoding to a disordered spin model, which is where the threshold is a phase transition rather than a fitted crossing. Read it as the theory behind the plot you will make on day 661.
647. Day 647 (systems): Analysing correlated noise on the surface code using adaptive decoding algorithms — Nickerson, Brown, 2019. What happens to a decoder when errors are not independent — which is the assumption your edge weights are built on. Read it as the first thing a referee will attack, and note the adaptive fix.
648. Day 648 (systems): A manifesto for reproducible science — Munafò et al., 2017. The systemic version of the argument: incentives, not individual carelessness. Read it as a description of the environment your first paper is entering, and pick the two practices you will actually adopt.
649. Day 649 (systems): Fusion Blossom: Fast MWPM Decoders for QEC — Wu, Zhong, 2023. A parallel matching decoder built for the throughput a machine actually needs. Read it against your own single-threaded matcher and write down the two design decisions you would have to reverse.
650. Day 650 (systems): How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits — Gidney, Ekerå, 2021. A deliberate re-read, and the third: the assumptions about cycle time and decoder throughput mean something different now that you have a decoder to time. Those numbers are the ones your latency budget has to meet today.
651. Day 651 (systems): Ten Simple Rules for Making Good Oral Presentations — Bourne, 2007. Read it in the hour before you give the talk to nobody. The rule about knowing your audience is the one you will break, because your audience is not other decoder people.
652. Day 652 (systems): Real-Time Decoding for Fault-Tolerant Quantum Computing: Progress, Challenges and Outlook — Battistel et al., 2023. The engineering constraints stated as constraints: backlog, bandwidth, and the exponential blow-up when decoding is slower than the machine. Read it the day you measure your own latency curve.
653. Day 653 (systems): A real-time, scalable, fast and highly resource efficient decoder for a quantum computer — Barber et al., 2023. A decoder designed against a hardware budget rather than a paper. Read it for what gets sacrificed to fit — the answer is accuracy in exactly the places you would not expect.
654. Day 654 (systems): Parallel window decoding enables scalable fault tolerant quantum computation — Skoric, Browne, Barnes, Gillespie, Campbell, 2023. Decoding a stream rather than a block, by cutting the problem into overlapping windows. Read it as the structural answer to the backlog problem you measured on day 650.
655. Day 655 (systems): High-threshold and low-overhead fault-tolerant quantum memory — Bravyi, Cross, Gambetta, Maslov, Rall, Yoder, 2024. A code with the surface code's threshold at a fraction of the qubits, and the connectivity bill that pays for it. Read the way they present the threshold sweep; that is the format your own results section should imitate.
656. Day 656 (systems): Quantum error correction below the surface code threshold — Google Quantum AI, 2024. A deliberate re-read of the day-420 result, on the day your own sweep runs. The error suppression factor across distances is the quantity your plot is a small simulated echo of; read the methods again with the sweep in flight.
657. Day 657 (systems): Hardness of decoding quantum stabilizer codes — Iyer, Poulin, 2015. Exact maximum-likelihood decoding is hard, which is why your accuracy is a sampled estimate and why shot count is the real cost of the experiment. Read it the day you decide how many shots each grid point gets.
658. Day 658 (systems): Realizing Repeated Quantum Error Correction in a Distance-Three Surface Code — Krinner et al., 2022. A distance-three code run repeatedly on superconducting hardware, with the leakage and crosstalk that your simulation does not have. Read it as the gap between your noise model and a device.
659. Day 659 (systems): Ten Simple Rules for Reviewers — Bourne, Korngreen, 2006. Read it as the person who is about to be reviewed, then review your own paper by the rules and write what you find in the limitations section today.
660. Day 660 (systems): Improved decoding of circuit noise and fragile boundaries of tailored surface codes — Higgott, Bohdanowicz, Kubica, Flammia, Campbell, 2023. Belief-matching, and the discovery that tailored codes have boundaries that undo their advantage. Read it as a case where a promising number did not survive careful re-measurement.
661. Day 661 (systems): High threshold error correction for the surface code — Wootton, Loss, 2012. A decoder that beats matching by using more of the error distribution, and the threshold that follows. Read it the day you plot your own crossing, so you know your number is decoder-dependent and say so on the figure.
662. Day 662 (systems): Correlated decoding of logical algorithms with transversal gates — Cain, Zhao, Zhou, Meister, Ataides, Jaffe, Bluvstein, Lukin, 2024. An assumption everyone made — that logical blocks decode independently — taken apart and replaced with an experiment. Read it as the shape of what you are doing today: an objection answered by re-running, not by arguing.
663. Day 663 (systems): Assessing requirements to scale to practical quantum advantage — Beverland et al., 2022. A deliberate re-read of the day-409 paper with a decoder in hand. Read the parameter tables specifically: they are the list of everything a noise model must state before an estimate built on it means anything.
664. Day 664 (systems): Statistical Significance Tests for Machine Translation Evaluation — Koehn, 2004. Bootstrap resampling, explained on a problem that looks nothing like yours and is structurally identical. Use it today to say whether your threshold differs from the published one or merely looks different.
665. Day 665 (systems): Ultrahigh Error Threshold for Surface Codes with Biased Noise — Tuckett, Bartlett, Flammia, 2018. The threshold moves a great deal when the noise is biased, which means your single number is a number about your noise model. Read it as the reason the figure caption must state the model.
666. Day 666 (systems): Roads towards fault-tolerant universal quantum computation — Campbell, Terhal, Vuillot, 2017. The survey of routes to universality — magic states, code switching, gauge fixing — read once the surface-code road is familiar enough to compare against.
667. Day 667 (systems): The XZZX Surface Code — Bonilla Ataides, Tuckett, Bartlett, Flammia, Brown, 2021. A one-gate change to the stabilizers that transforms the threshold under biased noise. Read it as the cleanest example of a result that is a change of representation rather than a better algorithm.
668. Day 668 (AI): A Neural Decoder for Topological Codes — Torlai, Melko, 2017. The first serious attempt to learn a decoder, using a Boltzmann machine over syndrome-error pairs. Read it for how they framed the labels, which is the decision you are making today and cannot easily change later.
669. Day 669 (AI): Decoding Small Surface Codes with Feedforward Neural Networks — Varsamopoulos, Criger, Bertels, 2017. A plain feedforward decoder that matches MWPM at small distance, and the scaling wall it hits. Read it for the honest statement of where the approach stops working — that wall is the one you will hit too.
670. Day 670 (AI): Learning high-accuracy error decoding for quantum processors — Bausch et al., 2024. A deliberate re-read of the day-498 paper on the day tensorforge and qdec are finally wired together. AlphaQubit pretrains on simulation and fine-tunes on hardware; read the training recipe again now that you have a dataset of your own and can see what it would cost you.
671. Day 671 (AI): Machine-learning-assisted correction of correlated qubit errors in a topological code — Baireuther, O'Brien, Tarasinski, Beenakker, 2018. A recurrent decoder trained on time-series syndromes, which is the shape your data actually has. Read the section on how they avoided training on the wrong thing; that is today's audit.
672. Day 672 (AI): Deep neural decoders for near term fault-tolerant experiments — Chamberland, Ronagh, 2018. Neural decoders judged against the constraint that matters — decoding faster than the machine produces syndromes. Read it as the specification for the decoder you will train, not as an inspiration.
673. Day 673 (systems): Ten Simple Rules for Taking Advantage of Git and GitHub — Perez-Riverol et al., 2016. Read it as the checklist for the repository you are about to ask a stranger to use — issues, releases, tags, and a history someone can bisect.
674. Day 674 (systems): Best Practices for Scientific Computing — Wilson et al., 2014. The longer, stricter version of the day-596 paper, read at the point where the code stops being yours alone. Automate what is repeated is the rule that today's work implements.
675. Day 675 (systems): The FAIR Guiding Principles for scientific data management and stewardship — Wilkinson et al., 2016. Findable, accessible, interoperable, reusable — applied today to the sweep data behind the threshold plot, not to a hypothetical dataset. Score your archive against all four before you cut the release.
676. Day 676 (systems): Ten Simple Rules for the Open Development of Scientific Software — Prlić, Procter, 2012. The rules for software other people are expected to contribute to rather than merely run. Read it the day someone else uses yours, and write down which rules their friction points map to.
677. Day 677 (systems): Ten Simple Rules for Digital Data Storage — Hart et al., 2016. Formats, naming and raw-data discipline, read at the moment the data stops being yours to interpret. The rule about keeping raw data raw is the one your sweep pipeline is closest to breaking.
678. Day 678 (systems): A Game of Surface Codes: Large-Scale Quantum Computing with Lattice Surgery — Litinski, 2019. The whole fault-tolerant machine drawn as a resource-allocation problem in space and time. Read it last: it is the thing your decoder is a component of, and the frame for the summer.
679. Day 679 (systems): Full-Stack, Real-System Quantum Computer Studies: Architectural Comparisons and Design Insights — Murali, Linke, Martonosi, Javadi-Abhari, Baker, Chong, 2019. Two real machines compared at every layer at once, which is the view you need of the stack you have just joined. Read it on the first day and mark which layer your team owns.
680. Day 680 (AI): Learning to Decode the Surface Code with a Recurrent, Transformer-Based Neural Network — Bausch, Senior, Heras, Edlich et al., 2023. What a serious learned decoder looks like: recurrent over rounds, trained against real device data, and beaten mainly on latency. Read it as the ceiling yours is measured against, not as a template to copy.
681. Day 681 (systems): Charge insensitive qubit design derived from the Cooper pair box — Koch et al., 2007. A deliberate re-read, and the only one this period gets. You met it in Autumn 2027 as a circuit; today you diagonalise its Hamiltonian yourself, and the exponential-versus-polynomial trade in EJ/EC stops being a sentence. This is where the AI lane has been walking since Prince chapter 1 on day 1.
682. Day 682 (AI): Data-driven decoding of quantum error correcting codes using graph neural networks — Lange, Havström, Srivastava, Bengtsson et al., 2023. A learned decoder whose architecture is shaped like the matching graph, evaluated against matching on identical data. Read it before you build the comparison table, so the table ends up with the right columns.
683. Day 683 (systems): Software tools for quantum control: Improving quantum computer performance through noise and error suppression — Ball, Biercuk, Carvalho, Chen et al., 2021. Research techniques — dynamical decoupling, optimised pulses, filter design — turned into software that other people run without reading the derivations. Read it in the week your own work first has to fit inside somebody else’s system.
684. Day 684 (systems): Superconducting Qubits: A Short Review — Devoret, Wallraff, Martinis, 2004. Charge, flux and phase qubits laid out as one design space, before the transmon flattened it. Short, and the right thing to read once you have stood next to a real fridge.
685. Day 685 (systems): Calibrated decoders for experimental quantum error correction — Chen, Yoder, Kim, Sundaresan et al., 2022. What changes when a decoder's error model is fitted to the device instead of assumed. That gap is exactly what today's off-distribution test measures.
686. Day 686 (systems): QDB: From Quantum Algorithms Towards Correct Quantum Programs — Huang, Martonosi, 2018. A taxonomy of the bugs quantum programs actually have, built from real buggy programs rather than from imagination. Read it on the day you are hunting one in conventions you are still learning.
687. Day 687 (systems): 1/f noise: implications for solid-state quantum information — Paladino, Galperin, Falci, Altshuler, 2014. The spectrum that dominates dephasing in every solid-state qubit, and why a 1/f bath is not a Markovian one. Read it with your own T2 simulation running beside you.
688. Day 688 (systems): Removing leakage-induced correlated errors in superconducting quantum error correction — McEwen, Kafri, Chen, Atalaya et al., 2021. Leakage is the error your phenomenological model does not have and your matching graph cannot express. Read it on the day you throw that model away.
689. Day 689 (systems): Realizing Rapid, High-Fidelity, Single-Shot Dispersive Readout of Superconducting Qubits — Walter, Kurpiers, Gasparinetti, Magnard et al., 2017. Where readout time goes, and why resonator ring-down sets a floor the decoder has to live inside. Your measurement error rate is this paper’s trade-off, made once by someone else.
690. Day 690 (systems): Introduction to Quantum Noise, Measurement and Amplification — Clerk, Devoret, Girvin, Marquardt, Schoelkopf, 2010. A hundred pages on what noise is quantum mechanically and why an amplifier is obliged to add some. Read the first three sections; a catch-up day is the only day long enough.
691. Day 691 (systems): Resolving catastrophic error bursts from cosmic rays in large arrays of superconducting qubits — McEwen, Faoro, Arya, Dunsworth et al., 2022. A correlated error across the whole chip every ten seconds, which no independent-error decoder can absorb. Read it as the failure mode your threshold plot quietly assumes away.
692. Day 692 (systems): Hardware for Dynamic Quantum Computing — Ryan, Johnson, Ristè, Donovan, Ohki, 2017. A control system designed around a feedback latency budget, written as an engineering document rather than a physics result. Read it for the form as much as the content — you are writing one today.
693. Day 693 (systems): A simple all-microwave entangling gate for fixed-frequency superconducting qubits — Chow, Corcoles, Gambetta, Rigetti et al., 2011. Cross resonance: an entangling gate with no tunable element, driven at the neighbour’s frequency. Read the Hamiltonian before you simulate it, because the unwanted terms are the entire engineering problem.
694. Day 694 (AI): Deep Neural Network Discrimination of Multiplexed Superconducting Qubit States — Lienhard, Vepsäläinen, Govia, Hoffer et al., 2022. A learned component measured against the standard one on accuracy and on latency, with the cost of the network itself counted rather than waved at. The same comparison you are running today, one layer further down the stack.
695. Day 695 (systems): Scalable mitigation of measurement errors on quantum computers — Nation, Kang, Sundaresan, Gambetta, 2021. Readout mitigation without ever materialising a 2^n calibration matrix. Read it as a sparse linear-algebra paper, because that is what it is.
696. Day 696 (systems): Procedure for systematically tuning up crosstalk in the cross resonance gate — Sheldon, Magesan, Chow, Gambetta, 2016. Four pages that turn a Hamiltonian into a tune-up sequence somebody else can run. Read it for the shape of a good protocol: measure, fit, correct, measure again.
697. Day 697 (systems): How to Build a Quantum Supercomputer: Scaling from Hundreds to Millions of Qubits — Mohseni, Scherer, Johnson, Wertheim et al., 2024. The classical half of a large quantum computer costed out: decoding throughput, control bandwidth, and the data rates nobody budgets for. Read it before you profile, because it says which number actually has to move.
698. Day 698 (systems): Physical qubit calibration on a directed acyclic graph — Kelly, O'Malley, Neeley, Neven, Martinis, 2018. Calibration as a dependency graph with staleness, which is a build system with physics in it. Read it the day you take ownership of something that has to keep working overnight without you.
699. Day 699 (systems): Scalable in-situ qubit calibration during repetitive error detection — Kelly, Barends, Fowler, Megrant et al., 2016. Calibrating from the error-detection data itself rather than stopping the experiment to do it. This is the feedback loop that lets a large device stay usable for a whole day.
700. Day 700 (systems): Quantum Error Correction: An Introductory Guide — Roffe, 2019. An exposition written to be understood rather than to be impressive, by somebody who decided carefully what to leave out. Read it on the day you write your own and steal its ordering.
701. Day 701 (systems): Demonstrating a Continuous Set of Two-qubit Gates for Near-term Quantum Algorithms — Foxen, Neill, Dunsworth, Roushan et al., 2020. A gate family parameterised continuously instead of a fixed basis, calibrated across a whole chip. Read it against the discrete basis every compiler pass you have written assumes.
702. Day 702 (systems): Digital coherent control of a superconducting qubit — Leonard, Beck, Nelson, Christensen et al., 2019. Single-flux-quantum pulses driving a qubit from a chip at 4 K, which removes most of the wiring problem and introduces a new one. Read it as an architecture proposal, not as a demo.
703. Day 703 (systems): Mitiq: A software package for error mitigation on noisy quantum computers — LaRose, Mari, Kaiser, Karalekas et al., 2022. A research package with a test suite, a release process and documentation a stranger can follow — which is what your repository has to become today. Read the software half, not the mitigation theory.
704. Day 704 (systems): Application-Oriented Performance Benchmarks for Quantum Computing — Lubinski, Johri, Varosy, Coleman et al., 2021. Benchmarks defined by what an application needs rather than by what is convenient to measure. Read it before writing the harness your group will still be running after you leave.
705. Day 705 (systems): Coherent control of macroscopic quantum states in a single-Cooper-pair box — Nakamura, Pashkin, Tsai, 1999. The first coherent oscillation in a superconducting circuit, with a coherence time of about a nanosecond. Read it against the hundred microseconds your team measures now and count the orders of magnitude.
706. Day 706 (systems): Quantum Computer Systems for Scientific Discovery — Alexeev, Bacon, Brown, Calderbank et al., 2021. A community statement of which systems problems are genuinely open. Read it on the day you choose what to harden, because it tells you which of your projects somebody else would cite.
707. Day 707 (systems): Nine Best Practices for Research Software Registries and Repositories: A Concise Guide — Task Force on Best Practices for Software Registries, 2020. What a repository has to carry before anyone can find it, cite it or trust it once its author has gone. Read it as the checklist for the four archives you write today, and check each one against it rather than against your memory.
708. Day 708 (systems): Manipulating the Quantum State of an Electrical Circuit — Vion, Aassime, Cottet, Joyez et al., 2002. The quantronium, and the idea that you bias a qubit where its frequency is flat against the noise. One idea, and every superconducting qubit since has used it.
709. Day 709 (systems): Optimized Compilation of Aggregated Instructions for Realistic Quantum Computers — Shi, Leung, Gokhale, Rossi et al., 2019. A compiler contribution you can draw a boundary around: aggregate the instructions, compile the aggregate straight to pulses, measure the gain. Read it on the day you have to say exactly which part of your own work is yours.
710. Day 710 (systems): A Verified Optimizer for Quantum Circuits — Hietala, Rand, Hung, Wu, Hicks, 2021. Circuit optimisations proved correct rather than tested, and the bugs the proofs found in real compilers. Read it on a review day and ask what your own tests would have caught.
711. Day 711 (systems): SupermarQ: A Scalable Quantum Benchmark Suite — Tomesh, Gokhale, Omole, Ravi et al., 2022. A benchmark suite built around feature vectors so it can say what it covers and what it does not. Read it as you rebuild yours: coverage is the claim, not the score.
712. Day 712 (systems): Quantum Volume in Practice: What Users Can Expect from NISQ Devices — Pelofske, Bärtschi, Eidenbenz, 2022. What the single number actually reports when it is measured by users on hardware they do not own, including how far it moves between runs. Read the variance discussion before you quote your own figure.
713. Day 713 (systems): Statistical Assertions for Validating Patterns and Finding Bugs in Quantum Programs — Huang, Martonosi, 2019. Assertions for a program whose intermediate state you cannot print, made statistical because measurement destroys. Exactly the right frame for a test that only fails sometimes.
714. Day 714 (systems): The Flux Qubit Revisited to Enhance Coherence and Reproducibility — Yan, Gustavsson, Kamal, Birenbaum et al., 2016. Reproducibility as a physics result: one qubit, redesigned until it behaved the same way twice. The hardware version of what you are currently doing to a repository.
715. Day 715 (systems): ProjectQ: An Open Source Software Framework for Quantum Computing — Steiger, Häner, Troyer, 2018. A framework built as a compiler with swappable backends and released to strangers. Read it for the layering, and for what a project has to have in place before anybody outside it can contribute.
716. Day 716 (systems): Qiskit Pulse: Programming Quantum Computers Through the Cloud with Pulses — Alexander, Kanazawa, Egger, Capelluto et al., 2020. A user-facing interface in which a program is waveforms, frames and instants rather than gates. Read the scheduling section against the stretch resolution you are about to implement — this is what the timing model is for.
717. Day 717 (systems): Efficient Z-Gates for Quantum Computing — McKay, Wood, Sheldon, Chow, Gambetta, 2017. A whole class of gates removed from the hardware by folding them into the phase of every subsequent pulse. Possibly the best compiler result in the field, and it is four pages long.
718. Day 718 (systems): A large-scale study on research code quality and execution — Trisovic, Lau, Pasquier, Crosas, 2021. Thousands of files of published research code run in a clean container to see how many execute at all. Fewer than half. Read it while you are watching a stranger try to run yours.
719. Day 719 (systems): An Experimental Microarchitecture for a Superconducting Quantum Processor — Fu, Rol, Bultink, van Someren et al., 2017. The first real quantum microarchitecture paper: queues, timing and the feedback path, with the latencies stated. Read it as an architecture paper, because that is what it is.
720. Day 720 (systems): Cryogenic Control Architecture for Large-Scale Quantum Computing — Hornibrook, Colless, Conway Lamb, Pauka et al., 2015. One coaxial line per qubit does not scale, and this is the paper that says so with a heat budget attached. Read it as a constraint on every architecture you have been sketching all year.
721. Day 721 (systems): eQASM: An Executable Quantum Instruction Set Architecture — Fu, Riesebos, Rol, van Straten et al., 2019. An instruction set that is actually executable on control hardware, with the timing model inside the ISA. Read it against OpenQASM 3 and say which one your compiler should target.
722. Day 722 (systems): Software Mitigation of Crosstalk on Noisy Intermediate-Scale Quantum Computers — Murali, McKay, Martonosi, Javadi-Abhari, 2020. Serialising the gates that interfere, and paying decoherence to do it. A scheduling problem with a physical objective, which is the shape of most quantum compiler work.
723. Day 723 (systems): Optimized Quantum Compilation for Near-Term Algorithms with OpenPulse — Gokhale, Javadi-Abhari, Earnest, Shi, Chong, 2020. A compiler that reaches below the gate set into pulses, because the abstraction was costing more than it was buying. Read it with a real calibration snapshot open: both are about compiling against what the device actually is today.
724. Day 724 (systems): Quantum Error Mitigation — Cai, Babbush, Benjamin, Endo, Huggins, Li, McClean, O'Brien, 2023. A review that is explicit about the sampling cost every mitigation technique pays. The right model for a limitations section: state the cost, not the hope.
725. Day 725 (systems): Estimating the Coherence of Noise — Wallman, Granade, Harper, Flammia, 2015. How to measure what fraction of your error is coherent rather than stochastic, from randomised benchmarking data you already have. That number is what decides whether today’s pass is worth its cost.
726. Day 726 (systems): Efficient learning of quantum noise — Harper, Flammia, Wallman, 2020. Reconstructing the Pauli error rates of a whole device from a tractable number of experiments. The measurement that would make your decoder’s edge weights right rather than merely plausible.
727. Day 727 (systems): 3D integrated superconducting qubits — Rosenberg, Kim, Das, Yost et al., 2017. A paper whose figures are the argument — cross-sections and interconnect stacks that no paragraph could replace. Read it on the day you draw yours, and ask which of your claims a picture would carry better than a sentence.
728. Day 728 (systems): The electronic interface for quantum processors — van Dijk, Charbon, Sebastiano, 2019. The classical-to-quantum boundary treated as a hardware engineering problem, with a power budget and a bandwidth budget attached. Read it against the host-accelerator boundary you are drawing today.
729. Day 729 (systems): Transmon qubit with relaxation time exceeding 0.5 milliseconds — Wang, Li, Xu, Li et al., 2022. One claim, stated in the title, with every measurement in the paper existing to support it and nothing else in there at all. That is the structure your skeleton is trying to have.
730. Day 730 (systems): Systems Architecture for Quantum Random Access Memory — Xu, Hann, Foxman, Girvin, Jiang, 2023. A component everybody assumes into their algorithm, costed out properly for the first time — hardware, error rates, and what it does to the speedup that assumed it was free. A paper whose whole contribution is an honest number.
731. Day 731 (systems): Efficient magic state factories with a catalyzed |CCZ> to 2|T> transformation — Gidney, Fowler, 2019. A large reduction in the most expensive part of a fault-tolerant computation, from a construction only a couple of pages long. Read it on related-work day: this is what it looks like when somebody improves a number you were about to cite as fixed.
732. Day 732 (systems): Focus beyond quadratic speedups for error-corrected quantum advantage — Babbush, McClean, Newman, Gidney, Boixo, Neven, 2021. Constant factors and error-correction overhead eat a Grover-shaped speedup entirely. The paper that decides which problems are worth writing an algorithm for at all.
733. Day 733 (systems): Demonstration of the trapped-ion quantum-CCD computer architecture — Pino, Dreiling, Figgatt, Gaebler et al., 2021. An architecture in which qubits physically move, and the compiler problem that creates. Read it against the fixed coupling map every pass you have written quietly assumes.
734. Day 734 (systems): New material platform for superconducting transmon qubits with coherence times exceeding 0.3 milliseconds — Place, Rodgers, Mundada, Smitham et al., 2020. Coherence tripled by changing the metal, after a decade in which everybody optimised the circuit instead. Read it on critique day as what happens when someone takes seriously an assumption nobody was arguing about.
735. Day 735 (systems): Logical quantum processor based on reconfigurable atom arrays — Bluvstein, Evered, Geim, Li et al., 2024. Connectivity rearranged physically between layers, which turns routing from a graph problem into a scheduling problem. The strongest challenge to the assumptions baked into qroute.
736. Day 736 (systems): Interfacing spin qubits in quantum dots and donors — hot, dense and coherent — Vandersypen, Bluhm, Clarke, Dzurak et al., 2017. The argument that the winning platform is the one you can fabricate a million of, whatever its coherence time. A manufacturing argument, which is a kind of systems argument.
737. Day 737 (systems): Fluxonium: single Cooper pair circuit free of charge offsets — Manucharyan, Koch, Glazman, Devoret, 2009. A circuit that solves the charge-noise problem differently from the transmon and pays for it elsewhere. Read it as the counterfactual: this is what the transmon chose against.
738. Day 738 (systems): Microwave photonics with superconducting quantum circuits — Gu, Kockum, Miranowicz, Liu, Nori, 2017. A very long review of superconducting circuits as a photonics platform — resonators, coupling, and every regime of light-matter interaction in one document. Read the sections you spent months deriving and mark the three places it says something you got wrong.
739. Day 739 (systems): Decoherence in Josephson Qubits from Dielectric Loss — Martinis, Cooper, McDermott, Steffen et al., 2005. Coherence traced to two-level defects in the dielectric, which turned qubit design into a materials problem overnight. This is why your team argues about fabrication rather than about circuits.
740. Day 740 (systems): QuTiP: An open-source Python framework for the dynamics of open quantum systems — Johansson, Nation, Nori, 2012. A research tool that outlived its authors, and the design choices that let it. Read it as the question of what makes scientific software survive the person who wrote it.
741. Day 741 (systems): Cavity quantum electrodynamics for superconducting electrical circuits: an architecture for quantum computation — Blais, Huang, Wallraff, Girvin, Schoelkopf, 2004. The architecture proposal that the next twenty years implemented, written before the hardware existed. Read it as a handoff document that worked: it told other people what to build.
742. Day 742 (systems): Impact of ionizing radiation on superconducting qubit coherence — Vepsäläinen, Karamlou, Orrell, Dogra et al., 2020. Environmental radiation setting a ceiling on coherence, demonstrated by shielding a fridge with lead. An experiment that found a cause nobody had thought to put in the model.
743. Day 743 (systems): The impact of classical control electronics on qubit fidelity — van Dijk, Kawakami, Schouten, Veldhorst et al., 2019. Gate error traced to the amplitude resolution, phase noise and timing jitter of the instruments driving the qubit. Read it while your last run is going: part of the noise you are fitting is the room, not the chip.
744. Day 744 (systems): Scaling Superconducting Quantum Computers with Chiplet Architectures — Smith, Ravi, Baker, Chong, 2022. Packaging many small chips rather than fabricating one large one, with the yield argument and the interconnect cost both stated. The systems answer to a fabrication problem, which is what most scaling questions turn out to be.
745. Day 745 (systems): A tunable coupling scheme for implementing high-fidelity two-qubit gates — Yan, Krantz, Sung, Kjaergaard et al., 2018. The coupler that turns the always-on interaction off, which is what made high-fidelity gates routine. An engineering fix that changed what every layer above it was allowed to assume.
746. Day 746 (systems): Elucidating Reaction Mechanisms on Quantum Computers — Reiher, Wiebe, Svore, Wecker, Troyer, 2017. A concrete case for what a fault-tolerant machine would be for, made to a field that is not computer science. Read it before you present — it is the answer to "why does this matter" that does not require the audience to be you.
747. Day 747 (systems): Quantum algorithms: A survey of applications and end-to-end complexities — Dalzell, McArdle, Berta, Bienias et al., 2023. Every major algorithm with its end-to-end cost and its caveats, in one document. Read it as a map of where you could go next, not as a summary of where you have been.
748. Day 748 (systems): Fusion-based quantum computation — Bartolucci, Birchall, Bombin, Cable et al., 2023. Fault tolerance built out of small entangled resources and destructive measurements, with no gates in the usual sense. The last thing to do before a plan ends is read something that makes the plan’s assumptions visible.
749. Day 749 (systems): Building a fault-tolerant quantum computer using concatenated cat codes — Chamberland, Noh, Arrangoiz-Arriola, Campbell et al., 2022. A complete machine argued from the physical qubit up to the compiler, by people who had to make every layer agree with every other. Read it as the thing two years was training you to read in one sitting, and check whether you can.
750. Day 750 (systems): Quantum computing 40 years later — Preskill, 2021. Forty years assessed by somebody who watched all of them, ending in a list of what is still unknown. Read the closing section, then write your own — and make sure the question you take into the next cycle is one this paper does not already answer.

The 750-day calendar

750 days back to back from Aug 17, 2026, one assignment each, grouped below under the period each one falls in. The day is the unit: nothing is scheduled in threes and no day is part of anything smaller than its period. Every day carries five lanes: a paper, a systems chapter, an AI chapter, a system to implement, and an open-source contribution that is logged after the fact rather than scheduled.

Every 6th day is a catch-up day. No new chapter, no new system, no new increment. One paper, and whatever slipped: finish the build that ran long, re-run the experiment that surprised you, or write the note you skipped.

Exit gate, every day: Working artifact plus a 5–10 line note; decide tomorrow from the evidence.

Every one of the 750 days is here. Summer 2026 — days 1–57, the period being worked — is set out in full, five lanes a day. The other 12 periods are one line a day: the day number, its date, whether it is a catch-up day, its theme and the system it builds. That is a choice about weight, not about what has been written — all 750 days are written one at a time, and any of them can be read in full in the terminal with plan 1 for a day number, or in the calendar in Easy Mode.

Workflow changes

• 2026-08-16 — The calendar moves to Aug 17, and the reading starts where it was left The start date moves from Aug 13 to Aug 17 and the whole 750-day window slides with it — the same days, the same slack, four days later. Nothing inside a day changed by moving; day N is still day N. The one content change went with it: the AI lane's first Goodfellow day covered §2.1–2.5, but §2.1–2.3 are already read, so day 1 now opens at §2.4 — linear dependence, span and norms — which is where the book was actually left.
• 2026-08-13 — The block is gone, and the slack is spread The previous change made the content per day and left the three-day block as the container the periods were cut on — so the calendar still read as 250 blocks of three days, which is the thing it was supposed to stop being. There is no block now. Periods are cut in days, `plan 61` means day 61, and the calendar is a list of days grouped by period. The slack moved with it: catch-up was three consecutive days every eighteen, which only made sense as "every sixth block", and is now one day in every six — 125 of the 750 rather than 123, the same proportion without three rest days in a row. The written days were re-flowed onto the new slots in the order they were written; of the twenty-four places where one day referred to another by number, the eleven that moved were rewritten to match.
• 2026-08-12 — The day becomes the unit, and quantum becomes the destination The calendar scheduled a three-day block: one systems topic, one mirror build, one AI topic, one AI build, one anchor paper, and a template that said day 2, read a cited precursor. Two of every three papers were therefore chosen on the morning they were due, and two of every three days had no written assignment at all. Now each of the 750 days carries five lanes — a paper, a systems chapter, an AI chapter, a system implemented, and an open-source contribution — and the block survives only as the container the periods are cut on. Three other things changed with it. The term budget goes back to 40–45 extracurricular hours a week on top of coursework, which is the source document's original figure and not the 45-hours-total revision that replaced it; that revision was the only justification for pausing the independent systems track inside a quarter, so the pause is repealed and all five lanes now run year round. Both reading lanes acquire a destination: systems bends into quantum information, error correction and quantum systems, and AI widens into the fields that consume it before turning into quantum mechanics as physics. And the open-source lane is deliberately unscheduled — it is a form in /Admin, filled in after the fact, gaps and all.
• 2026-08-05 — The calendar starts on the day the work does Block 1 was dated Aug 3, so the plan opened already behind and every block boundary sat ahead of the work. The start date moves and the window moves with it — the same 250 blocks and 750 days, shifted whole. Nothing in a block changed; only the dates the blocks land on.
• 2026-08-03 — Priorities corrected against the source document The two-year execution schedule puts course performance first and research capability second; this file had them inverted, which is not a cosmetic difference — it decides what gives when a CSE deadline and an experiment collide. The five priorities and their operating rules are now the document's, verbatim. /Goals carries the same list.
• 2026-08-03 — Two systems builds a block, real UW dates, and slack that exists Three changes, from an audit of the arithmetic. Every sixth block is now catch-up: the old calendar had 250 consecutive blocks with no buffer, including a work block on December 31, and a plan with no slack fails as silent abandonment rather than loudly. Periods are cut on the real UW academic calendar instead of on season names, and each is marked free or term. And every content block carried two systems builds: the one that replicates whatever the book is explaining, and one increment on a long-running project that has nothing to do with the book.
• 2026-08-03 — One paper a day, named in advance The calendar shipped with one anchor paper per three-day block and a template for the other two days. That names one paper in three and leaves the other two to be picked on the morning they are due, which is the worst moment to pick. Days 1–51 were named first; the rewrite above extends that principle to every lane on every day.
• 2026-08-03 — The plan is a page on this site, not a spreadsheet The calendar and the operating rules now live at /Plans, so the current day is one command away and every change to how the two years get worked is recorded here rather than being remembered.