Daily tracker · 351 sessions · 3 hrs/day · Aug 2026 → Sept 2027
Click a day to mark it done — progress saves in this browser. Double-click, or press E, to expand a day's full text.
Install clang, gdb, valgrind. Build hello.c with the full warning+sanitizer flag set. Modern C §1–2.
Modern C §3: control flow. Write `true`, `false`, `echo` from scratch.
Modern C §4–5: arithmetic, integer types. Drill integer promotion and conversion rules.
Finish §5. Write `cat` with real error handling on every syscall.
Write `wc`. Handle stdin vs file arguments cleanly.
Write `head` and `tr`. Make all six utilities sanitizer-clean. Weekly review.
Rest. Not optional.
Modern C §6: aggregate types. Arrays and structs, first pass.
Modern C §11: pointers. Addresses, indirection, null.
Pointer arithmetic. Array-to-pointer decay. Why sizeof on a parameter lies.
C strings. Implement strlen, strcpy, strncpy by hand. Off-by-one drills.
Build a growable vector: push, at, reserve, free.
Build a string builder. ASan on both. Weekly review.
Rest. Not optional.
Modern C §12: memory and lifetime. malloc/free/calloc/realloc semantics.
Ownership conventions. Write explicit ownership docs for your vector API.
const correctness. Split every project into header and implementation properly.
Build a chained hash table.
Build an intrusive linked list. Genericity via void* and offsets.
Write a real Makefile. Valgrind clean across all of it. Weekly review.
Rest. Not optional.
Process model. fork, exec, wait. Skim TLPI ch24–26.
Tokenise a command line into argv. Handle quoting.
Execute simple commands. PATH resolution.
Built-ins: cd, exit, jobs. Why they can't be forked.
I/O redirection with dup2.
Pipes. Multi-stage pipelines. Weekly review.
Rest. Not optional.
Signals. Install handlers for SIGINT and SIGTSTP.
Process groups and terminal control. tcsetpgrp.
Background jobs and the job table.
waitpid and SIGCHLD reaping. Zombie avoidance.
Error-handling pass. Hunt edge cases deliberately.
Full ASan and UBSan clean. Weekly review.
Rest. Not optional.
LLVM UB series, part 1. Demonstrate signed overflow to yourself.
UB series part 2. Strict aliasing violations.
UB series part 3. Compare -O0 and -O2 output on Compiler Explorer.
Use-after-free, double-free, out-of-bounds. Learn to read ASan output fast.
gdb properly: breakpoints, watchpoints, backtraces, memory inspection.
Audit the shell for UB and fix everything found. Weekly review.
Rest. Not optional.
Read xv6: kernel/proc.c and kernel/kalloc.c. Take notes on idioms.
Read one curl or SQLite subsystem end to end.
Expert C Programming, ch1–4.
Build an arena allocator.
Build malloc/free with free lists.
Add coalescing and realloc. Benchmark it.
ARTIFACT — allocator shippedRest. Not optional.
CS:APP ch2: information representation. Term starts — settle the routine.
ch2: integer representation, two's complement.
ch2: floating point.
A Tour of C++, ch1–4. Orientation only, don't try to retain it.
Tour ch5–8.
Tour ch9–12. Weekly review.
Rest. Not optional.
Data Lab: bit puzzles, first half.
Data Lab: bit puzzles, second half.
Data Lab: floating point puzzles. Submit against the driver.
Finish A Tour of C++. Write down what surprised you.
LearnCpp ch1–2: statements, variables, functions.
LearnCpp ch3–4: debugging, fundamental types. Weekly review.
Rest. Not optional.
CS:APP ch3: assembly basics, data movement.
ch3: arithmetic and logical operations.
ch3: control flow, conditionals, loops in assembly.
LearnCpp ch5–6: operators, scope, linkage.
The compilation model: translation units, headers, the ODR.
Godbolt session — compile your C utilities and read the output. Weekly review.
Rest. Not optional.
CS:APP ch3: procedures, the stack frame, calling conventions.
ch3: arrays and structs at machine level.
ch3: buffer overflow and stack protection.
LearnCpp ch7–8: control flow, type conversion.
Static and dynamic libraries. Build one of each from your C code.
CMake from scratch — port a project to it. Weekly review.
Rest. Not optional.
Bomb Lab: phases 1–2. Disassembly and gdb.
Bomb Lab: phase 3.
Bomb Lab: phase 4.
LearnCpp ch9–10: error handling, enums, structs.
LearnCpp ch11: function overloading and templates, first look.
Bomb Lab: phases 5–6. Weekly review.
Rest. Not optional.
CS:APP ch5: program optimisation, compiler limits.
ch5: loop unrolling, instruction-level parallelism.
ch5: profiling and Amdahl's law.
LearnCpp ch12: compound types, references.
LearnCpp ch13: pointers, dynamic allocation in C++.
Optimise one of your C utilities, measured. Weekly review.
Rest. Not optional.
CS:APP ch3 attack material reread. Stack layout precision.
Attack Lab: code injection phases.
Attack Lab: return-oriented programming phases.
LearnCpp ch14: classes, encapsulation.
LearnCpp ch15: constructors and destructors.
Finish Attack Lab. Write up what you learned. Weekly review.
Rest. Not optional.
CS:APP ch6: storage technologies, locality.
ch6: cache organisation, direct-mapped and associative.
ch6: writing cache-friendly code.
LearnCpp ch16–17: std::vector, arrays, iterators.
LearnCpp ch18: dynamic arrays and the standard containers.
Measure cache effects on a matrix multiply. Weekly review.
Rest. Not optional.
Cache Lab: cache simulator, part A.
Cache Lab: finish part A.
Cache Lab: transpose optimisation, part B.
LearnCpp ch19–20: inheritance, virtual functions.
LearnCpp ch21: virtual tables, polymorphism costs.
Finish Cache Lab. Weekly review.
Rest. Not optional.
CS:APP ch7: linking, symbol resolution, relocation.
ch9: virtual memory, address translation.
ch9: TLBs, page tables, memory mapping.
Rewrite your C vector as a C++ class with RAII.
Rewrite your C hash table as a C++ class.
Delete both. Use std::vector and std::unordered_map. Write down the differences. Weekly review.
Rest. Not optional.
CS:APP ch9: dynamic allocation, implicit free lists.
Malloc Lab: implicit list implementation.
Malloc Lab: explicit free lists.
Malloc Lab: segregated fits.
Malloc Lab: tune for throughput and utilisation.
Benchmark against your September allocator. Weekly review.
Rest. Not optional.
Finish Malloc Lab. Submit.
CS:APP ch8: exceptional control flow, revisit with your shell in mind.
Consolidation: write a summary of everything CS:APP changed in how you think.
LearnCpp ch22: smart pointers, first look.
Set up your C++ project template — CMake, clang-tidy, sanitizers, tests.
Term review. Plan January.
ARTIFACT — CS:APP labs completeRest. Not optional.
Off, or read CppCon talks: Chandler Carruth on performance.
Off, or Expert C Programming ch5–8.
Off.
Off.
Off.
Optional: tidy repos, write up the year so far.
Rest. Not optional.
Off.
Off.
Off.
New Year's Eve. Off.
New Year's Day. Off.
New Year. Off.
Rest. Not optional.
LearnCpp ch22 properly: unique_ptr, shared_ptr, weak_ptr.
RAII as a concept. Convert a C resource handle to RAII.
The rule of zero, three, five. Effective Modern C++ items 1–4.
xv6 lab: util. Unix utilities in the kernel's userland.
xv6 lab: util, finish.
Approach dissertation supervisors — email three. Weekly review.
Rest. Not optional.
Rvalue references and value categories. EMC++ items 23–25.
Move constructors and move assignment. Write both by hand.
Copy elision and RVO. Verify on Godbolt.
xv6 lab: syscall. Tracing and sysinfo.
xv6 lab: syscall, finish.
Add move support to your C++ vector. Weekly review.
Rest. Not optional.
Forwarding references. EMC++ items 26–30.
std::forward, std::move, and when each is wrong.
Ownership models: unique, shared, borrowed. Design rules for your own APIs.
xv6 lab: pgtbl. Page table printing.
xv6 lab: pgtbl. Per-process kernel page table.
Refactor your container APIs around explicit ownership. Weekly review.
Rest. Not optional.
Exception mechanics. Stack unwinding, what it costs.
The three guarantees: basic, strong, nothrow. EMC++ item 14.
noexcept and move operations. Why vector needs noexcept moves.
xv6 lab: pgtbl, finish.
xv6 lab: traps. Backtrace.
Make your vector strongly exception-safe. Weekly review.
Rest. Not optional.
Design pass. Allocator awareness, growth policy, iterator invalidation rules.
Implement storage and growth. Placement new and manual lifetime.
Implement copy, move, and destruction correctly.
xv6 lab: traps. Alarm and signal return.
xv6 lab: traps, finish.
Test under move, copy and exception. Weekly review.
Rest. Not optional.
Intrusive list design. Why intrusive beats std::list for cache behaviour.
Implement the intrusive list.
Small-buffer-optimised string: design the layout.
xv6 lab: cow. Copy-on-write fork.
xv6 lab: cow, finish. This is the one that changes how you think about fork.
Implement SBO string storage. Weekly review.
Rest. Not optional.
Finish SBO string. Handle the small/large transition correctly.
Iterators for all three containers. Iterator categories.
Exception safety audit across the whole library.
Benchmark against the standard containers. Be honest about the gap.
Fuzz the library. Fix what falls out.
Write the README explaining every design decision.
ARTIFACT — container libraryRest. Not optional.
Function and class templates. Instantiation and the two-phase lookup.
Template argument deduction. The rules that surprise people.
Specialisation, partial and full.
xv6 lab: lock. Memory allocator locking.
xv6 lab: lock. Buffer cache.
Templatise your container library. Weekly review.
Rest. Not optional.
SFINAE and enable_if — understand it, then stop using it.
Concepts (C++20) as the modern replacement. Write your own.
constexpr functions and variables.
consteval and compile-time computation. Where it pays.
xv6 lab: lock, finish.
Add concepts to your container interfaces. Weekly review.
Rest. Not optional.
Pick a target project. Read its contributing guide and build it locally.
Read the codebase. Find three good-first-issues.
Reproduce the bug you're targeting. Write a failing test.
Implement the fix.
Polish: style, tests, commit message.
Submit the patch. Weekly review.
First open-source patch submittedRest. Not optional.
C++ Software Design: the case against classical OO patterns.
Type erasure: the concept. std::function as a case study.
Implement your own std::function.
Finish it. Handle small-object optimisation.
xv6 lab: fs. Large files.
xv6 lab: fs. Symbolic links. Weekly review.
Rest. Not optional.
STL algorithms properly. The ones you actually reach for.
Iterators and ranges. Views and lazy evaluation.
Write a custom range adaptor.
CRTP and policy-based design. When they're right.
xv6 lab: fs, finish.
Refactor something with ranges. Weekly review.
Rest. Not optional.
xv6 lab: mmap.
xv6 lab: mmap, finish.
Consolidation: write up the xv6 sequence and what it taught you.
Respond to open-source review feedback.
Dissertation: proposal and scope agreed with supervisor.
Term review. Plan the summer.
ARTIFACT — xv6 completeRest. Not optional.
C++ Concurrency in Action ch1–2: threads, joining, passing arguments.
ch3: sharing data, mutexes, deadlock avoidance.
ch4: condition variables, futures, packaged tasks.
ch5: the memory model. Atomic types.
ch5: memory orderings. relaxed, acquire-release, seq_cst.
Write a thread-safe queue with mutexes. Weekly review.
Rest. Not optional.
ch7: lock-free data structures, the general problem.
Compare-and-swap. The ABA problem.
False sharing. Measure it — cache line padding experiments.
Design an SPSC ring buffer.
Implement it with relaxed atomics.
Test it under ThreadSanitizer. Weekly review.
Rest. Not optional.
Benchmark the SPSC queue against a mutex-based one.
Tune: cache line alignment, batching.
Prove the memory ordering is correct. Write the argument down.
Dissertation: literature and background reading.
Dissertation: reading continues.
Weekly review and dissertation notes.
Rest. Not optional.
Pikus ch1–3: what performance means, measurement discipline.
perf: profiling, flame graphs, cache miss counters.
Microbenchmarking pitfalls. Google Benchmark.
Pikus ch4–5: memory and cache effects.
Branch prediction and how to be kind to it.
Profile the container library. Fix the worst thing. Weekly review.
Rest. Not optional.
Domain: limit order books, matching, price-time priority.
Data structure survey. Why arrays beat trees at these sizes.
Design the book: levels, orders, intrusive lists.
Design the benchmark harness and latency histogram first.
Implement core structures.
Implement add and cancel. Weekly review.
Rest. Not optional.
Implement matching logic.
Market orders, partial fills, edge cases.
Order modification and cancellation correctness.
Property-based tests against a naive reference implementation.
Dissertation: method and experimental design.
Weekly review.
Rest. Not optional.
Baseline measurement. Latency percentiles, not means.
Profile. Find where the time actually goes.
Cache-conscious layout pass.
Custom allocator — reuse your Phase 0 arena work.
Re-measure. Document every change and its effect.
Weekly review.
Rest. Not optional.
Tail latency work. p99 and p99.9.
Remove allocation from the hot path entirely.
Concurrency: feed handler thread and matching thread.
Final benchmark run. Write up results honestly.
README and design document.
Publish it.
ARTIFACT — order bookRest. Not optional.
Vandevoorde: variadic templates and parameter packs.
Template metaprogramming — and its modern replacements.
Expression templates. When they earn their complexity.
Dissertation: implementation begins.
Dissertation: implementation.
Weekly review.
Rest. Not optional.
Dissertation implementation.
Dissertation implementation.
Dissertation implementation.
Dissertation implementation.
Open source: second contribution.
Weekly review.
Rest. Not optional.
Dissertation implementation.
Dissertation implementation.
Dissertation: first measurements.
Dissertation: measurements.
Open source: respond to review.
Weekly review.
Rest. Not optional.
Dissertation implementation.
Dissertation implementation.
Dissertation: evaluation design.
Dissertation: evaluation runs.
Concurrency in Action ch8–9: designing concurrent code.
Weekly review.
Rest. Not optional.
Dissertation: evaluation.
Dissertation: evaluation.
Dissertation: results analysis.
Storage engine kickoff: read the SQLite file-format spec and the LMDB design paper.
Decide the shape: a single-file, page-based B-tree engine with a WAL. Sketch the on-disk layout.
Weekly review.
Rest. Not optional.
Dissertation: chapter drafting.
Dissertation: chapter drafting.
Dissertation: chapter drafting.
Pager: fixed-size pages, a file abstraction, read/write a page by number.
Pager: a page cache with an eviction policy. Pin and unpin.
Weekly review.
Rest. Not optional.
Dissertation: writing.
Dissertation: writing.
Dissertation: writing.
B-tree: node layout, slotted pages, key/value cells.
B-tree: point lookup down to a leaf. Cursor abstraction.
Weekly review.
Rest. Not optional.
Dissertation: writing.
Dissertation: writing.
Dissertation: supervisor feedback pass.
B-tree: insert with no split. Then leaf split.
B-tree: internal-node split and root growth. This is the hard part — go slow.
Weekly review.
Rest. Not optional.
Dissertation: revision.
Dissertation: revision.
Dissertation: revision.
B-tree: delete and rebalance, or defer with tombstones and document the choice.
CV rebuilt around the year's artifacts — lead with the storage engine and the Postgres 50x work.
Weekly review.
Rest. Not optional.
Dissertation: revision.
Dissertation: revision.
Dissertation: figures and results.
Durability: a write-ahead log. Append records before mutating pages.
Interview prep: algorithms in C++.
Weekly review.
Rest. Not optional.
Dissertation: final edits.
Dissertation: final edits.
Dissertation: proofread.
Crash recovery: replay the WAL on startup. Test it by killing the process mid-write.
Interview prep: systems design.
Weekly review.
Rest. Not optional.
Dissertation: final pass.
Dissertation: formatting and submission checks.
Concurrency: a reader-writer lock over the pager, or MVCC snapshots. Pick one, justify it.
Benchmark harness: random and sequential workloads, latency percentiles.
Interview prep: C++ fundamentals drilling.
Weekly review.
Rest. Not optional.
Dissertation: submit.
Recovery day — genuinely.
Storage engine: profile the read path. Fix the worst bottleneck.
Storage engine: profile the write path. Batch WAL fsyncs.
Applications: first batch out — lead with the engine.
Weekly review.
Dissertation submittedRest. Not optional.
Storage engine: compare against SQLite on your benchmark. Be honest about the gap.
Storage engine: a simple query layer — range scans over the cursor.
Storage engine: secondary index support.
Open source: third contribution.
Applications and interview prep.
Weekly review.
Rest. Not optional.
Storage engine: crash-consistency test suite. Automate the kill-and-recover loop.
Storage engine: fuzz the page layer.
Storage engine: fix everything the fuzzer found.
Open source.
Applications and interviews.
Weekly review.
Rest. Not optional.
Storage engine: final benchmark run. Write up the numbers honestly.
Storage engine: README and an architecture document with diagrams.
Storage engine: a blog post — 'building a storage engine after optimising Postgres in production'.
Open source.
Applications and interviews.
Weekly review.
ARTIFACT — storage engineRest. Not optional.
Graduate visa application — submit before the Student visa expires.
Storage engine: polish and publish the repo.
Storage engine: record a short demo.
Open source.
Applications and interviews.
Year review. Plan the next phase.
Graduate visa applicationRest. Not optional.