Current priority — teaching quality, not more coverage (2026-09-05)

The historical phases below track topics written. They do not establish that those topics teach well enough for independent study. This pass changes the priority from adding subjects to improving the path from explanation to implementation.

Standard: From reading to independent work, inspired by the visual, motivation-first lessons in foundations/dsa/02-data-structures/. Preserve that clarity while adding explicit prerequisites, worked traces, complete setup, independent practice, and feedback. Keep reference files and interview banks in their existing formats.

First batch

  • Establish one shared teaching standard; align the root README and personal course template with it.
  • Revise Python iterators and generators — suspended-state trace, runnable pipeline, independent lazy-processing task, checks and hints.
  • Revise storage and page layout — exact byte offsets, runnable page model, independent compaction, and capacity/stable-slot checks.
  • Connect both pilots to their course indexes and existing practice material.
  • Study the pilots closed-book and record where the explanation, setup, or exercise still requires guessing. Editorial completion is not learner validation.

Restructured 2026-10-01: SWE 101 is now the first of three short courses (101 → 102 → 103); the old 30-week scheme is archived. Core lessons are converted one course ahead of study. Progress is generated, not hand-kept: lesson quality (python3 learning/swe-101/scripts/audit-standard.py). The standard now also requires a kid version in every lesson.

  • Software design block, weeks 1–4 — 13 lessons. Every runnable example executed with Node 26 (node --test), or with Django 6.1 / Flask 3.1 / import-linter / ESLint 9 for layer-vs-feature. Fixed on the way: SOLID linked “strategy” to creational patterns; the structural-patterns lesson had no composition-over-inheritance section although week 2.7 pointed to it; behavioural patterns had no State pattern although week 3.3 listed it; layer-vs-feature called Django by-layer (its apps are feature folders); the roles note linked “mobile” to a NestJS backend note.
  • Testing fundamentals (SWE 101 week 2) — converted 2026-10-01: test doubles and flaky-test sections added (neither existed), lab concepts/01-best-practices/03-testing-fundamentals/labs/javascript/.
  • SWE 101 core complete (14/14), 2026-10-01. The last four — backend best practices (added rate limiting and idempotency, which week 6 promised and the lesson lacked), observability, input validation (Python examples replaced with TypeScript, SSRF added), security headers (CORS reflection and “CORS is not access control”) — each with a lab.
  • Layer vs feature: Go, Java, Rust, C and C++ added (2026-10-01), each with a lab proving the compiler or build system refuses a cross-feature import. The lesson is now ~9,600 words; consider splitting the language sections into a companion lesson.
  • SWE 102 core — 11 lessons, the AI-engineering track, before SWE 102 starts.
  • SWE 103 core, then optional lessons.
  • Log closed-book study problems in the review log and adjust the format before converting further.
  • Gaps filled (2026-10-01): coupling and cohesion (week 2.2 now points to it) and transactional outbox (linked from week 8.3, sagas, and behavioural patterns). Both written to the standard with labs.
  • labs/ set up: every verified example now lives in labs/<name>/ with a lab.json; python3 labs/run.py runs them all and fails if a lesson no longer shows the code that runs (--drift-only for a fast offline check).

Companion lessons in other languages (2026-10-01)

Every lesson whose code is in one language gets a companion in TypeScript/JavaScript, Python, Go, Java, Rust, C, C++ and C# — C and C++ only where the idea exists there. Convention: the course standard. Progress: language coverage (python3 labs/language_coverage.py). Every language’s example runs in a lab; C# runs in the .NET SDK container.

  • Pilot: dependency injection — seven labs, each showing what the language does about the scope bug (silent, -race, ValidateScopes, rustc E0524).
  • Layer vs feature split: the compiled languages, plus C#, moved to their own companion.
  • Feedback on the pilot’s format before the rest of SWE 101 core.
  • SWE 101 core, then SWE 102, SWE 103, then everything else — 351 lessons to go.

Flagged while building How Computers Work (2026-09-09)

  • mathematics/ is too thin for the courses that depend on it. (closed 2026-09-10: number bases, the foundations sequence and all of calculus written; logarithms added. Remaining gaps are unstarted topics, listed in the maths index.) Originally: Concretely: core/01-numbers/01-number-bases/ covers binary, decimal and hexadecimal but there is no note on signed representations — two’s complement lives only in computer-architecture/data representation, which is a Part IX course being used as a Part I prerequisite. Also thin: no dedicated logarithms note (only inside 06-exponents), and the calculus tree jumps from limits to multivariable with gaps.
  • No note anywhere on linkers and executable formats. (closed 2026-09-10: written as compilers/09-linking-and-loading, with a lab that inspects real ELF object files.) Originally: Static vs dynamic linking, relocation, ELF layout and the dynamic loader are covered only in passing across compilers/08-code-generation and languages/04-c/01-why-c-and-the-compilation-model. Flagged in the bridge as the weakest link in the source-to-CPU chain.

Next batches — proposed, not completed

  1. Processes/threads and virtual memory: explicit C/Linux prerequisites, parent/child and address-translation traces, bounded local labs, expected observations, and safety boundaries. Retain advanced operational material without making it the entry point.
  2. Finish one pilot course at a time: revise Python or databases in prerequisite order, attaching existing exercises to the appropriate lessons and a cumulative artifact to the course index. Do not rewrite every domain simultaneously.
  3. Apply the standard across other domains: sample each course first; adapt runnable labs to proofs, designs, or hardware experiments as appropriate. Audit course progression as well as individual notes.
  4. Review the DSA exemplars too: keep their teaching strengths, but verify language-specific claims and add independent implementation where self-assessment currently stops at recall.

Batch acceptance: preserve paths and useful depth; verify new links; execute runnable examples and check exercise contracts; label anything untested; then obtain feedback from an actual study attempt before extending the approach. No word-count target and no vault-wide claim of completion.


The working queue for the vault, agreed 2026-08-14. Ordered, sized, and honest about what each batch costs. Tick things off as they land.

Current state: 1,086 notes, ~1,247,000 words (Phase 5k, 2026-08-24). This plan adds roughly 110 notes on the core path, plus ~48 if the CS-theory gaps are folded in.

The standing caveat: almost everything below will be marked [reference] — written from sources, not from having built the thing. That’s the vault’s convention and it should stay visible. Reading is not a rank. The build-your-own-shit/ phase exists specifically to convert some of it into the other kind.


Phase 0 — done

  • languages/02-go/ — README + 13 notes, ~14,400 words
  • Spring Boot moved to backend/frameworks/java/; the languages/ vs backend/frameworks/ rule stated
  • languages/03-rust/ — README + 18 notes, ~22,000 words
  • languages/04-c/ — README + 13 notes, ~19,000 words
  • languages/05-cpp/ — README + 15 notes, ~24,000 words
  • backend/frameworks/ — go (6), rust (6), c (4), cpp (5) + READMEs, ~31,000 words
  • foundations/os/ — 12 notes, ~17,000 words
  • foundations/compilers/ — 11 notes, ~16,500 words
  • build-your-own-shit/ batch 1 — http-server, git, shell + README, ~6,800 words
  • build-your-own-shit/ batch 2 — redis, language, database, ~6,300 words
  • build-your-own-shit/ batch 3 — os, container, ~4,400 words. All 8 guides written; Phase 2 complete
  • engineering/ created (umbrella) + 01-continuum-mechanics/ — 13 notes, ~19,600 words

Phase 1 — the systems languages

The order is deliberate: Rust first (already queued), then C, then C++. C before C++ because C++ is only comprehensible as a reaction to C, and both before build-your-own-shit/, because every build guide there assumes you can read a systems language.

1.1 languages/03-rust/ — ✅ DONE — README + 18 notes, ~22,000 words

Ownership and borrowing · lifetimes · traits and generics · Result/Option and the ? operator · pattern matching · smart pointers (Box/Rc/Arc/RefCell) · interior mutability · unsafe and what it actually permits · async/await and the runtime split · cargo, crates, workspaces · macros · testing · error-handling crates (thiserror/anyhow) · performance and zero-cost abstractions

1.2 languages/04-c/ — ✅ DONE — README + 13 notes, ~19,000 words

Explicitly requested: headers. The translation unit model is the thing nobody explains properly.

Compilation model (preprocess → compile → assemble → link) · headers, include guards, and why .h/.c split the way they do · the preprocessor and macros · types, integer promotion, and size_t · pointers and pointer arithmetic · arrays vs pointers (the decay rule) · manual memory: malloc/free, the heap, and every way to get it wrong · structs, unions, bitfields, padding · strings as char* and why that’s a security story · the standard library · undefined behaviour as its own note · build systems: make, CMake · debugging: gdb, valgrind, sanitizers

1.3 languages/05-cpp/ — ✅ DONE — README + 15 notes, ~24,000 words

RAII (the central idea) · classes, constructors, the rule of 0/3/5 · references vs pointers · templates and generic programming · the STL: containers, iterators, algorithms · smart pointers and ownership · move semantics and rvalue references · operator overloading · inheritance, virtual dispatch, and the vtable · exceptions and exception safety · constexpr and compile-time computation · modern C++ (11→23): what actually changed practice · modules, and why headers are still everywhere · concurrency: std::thread, atomic, the memory model · build and tooling: CMake, package managers

1.4 backend/frameworks/ — ✅ DONE — 21 notes + 4 rewritten READMEs, ~31,000 words

Following the rule: frameworks live here, languages live there.

  • go/ (~6) — net/http in depth, Chi, Gin, middleware as composition, testing handlers, the stdlib-is-enough argument
  • rust/ (~6) — Axum, tower layers, extractors, Actix Web, state and Arc<AppState>, async pitfalls
  • c/ (~4) — libmicrohttpd, Kore, Ulfius, civetweb; when a C web server is a real answer and when it’s a bad idea
  • cpp/ (~5) — Drogon, Crow, Pistache, oat++, Boost.Beast

Phase 2 — build-your-own-shit/

The point of this folder: language-agnostic build guides. Each file is “here is everything you’ll meet building this, and the order to build it in” — not a tutorial in one language. Where a step needs a library, suggest options per language.

The shape every file follows

  1. What you’re actually building — and what you’re deliberately not
  2. What you need to know before starting — with links into the vault, and honest notes on what’s missing
  3. The build order — numbered milestones, each independently testable, each producing something that runs
  4. Per-language toolkit — for each milestone, what the stdlib gives you and what a library would, across C/C++/Rust/Go/Python/JS
  5. The parts that will actually bite you — the hard bits, stated in advance
  6. How to know it works — test strategy and reference implementations to compare against
  7. Where to stop — the difference between a learning artefact and a real one

The files — ~8 guides, longer than normal notes (~2,500 words each)

  • 01-http-server.md ✅ — the one to write first, since it’s the most tractable. Milestones: raw socket accept loop → request-line parser → header parser → response writer → routing → static files → keep-alive → concurrency → chunked encoding. Requested example: “build the parser first, then a route.”
  • 02-your-own-git.md ✅ — content-addressable store → blob/tree/commit objects → refs → index/staging → commit → log → branch → checkout → diff → merge. Pairs with How Git Actually Works, which is already written
  • 03-your-own-redis.md ✅ — RESP protocol parser → in-memory store → GET/SET → event loop → expiry → more data types → persistence (RDB/AOF) → replication
  • 04-your-own-language.md ✅ — lexer → parser/AST → tree-walking interpreter → environments and scope → functions and closures → then either a bytecode VM or a compiler. Blocked on the compilers gap below
  • 05-your-own-os.md ✅ — bootloader → protected/long mode → VGA or serial output → interrupts → memory management → paging → processes → scheduler → syscalls → filesystem. The longest and hardest; blocked on the OS gap below
  • 06-your-own-database.md ✅ — pager → B-tree or LSM → record format → a SQL subset parser → query execution → transactions and a WAL
  • 07-your-own-shell.md ✅ — the best small one. Read-eval loop → tokenising → fork/exec → redirection → pipes → job control → builtins
  • 08-your-own-container.md ✅ — namespaces → cgroups → chroot/pivot_root → a layered filesystem. Ties Docker to what the kernel actually does

Once this folder exists, project-ideas.md’s “build your own shit” tier should link into it rather than duplicating it.


Phase 3 — engineering/

Chosen structure: one umbrella with numbered tracks, room to grow.

  • engineering/01-continuum-mechanics/ — ✅ DONE — 13 notes, ~19,600 words
  • engineering/02-control-theory/ — ✅ DONE — 13 notes, ~21,000 words
  • robotics/ — ✅ DONE — 14 notes, ~22,000 words. Built against the 9-note plan its README proposed, with kinematics expanded to five notes as this plan called for (transforms, forward, inverse, Jacobians, dynamics). Note 09 is the robotics-specific control note; theory stays in engineering/02

robotics/index.md carried the rule that control-theory notes “should only be written after something has actually been made to move.” Honoured, not deleted — it survives in both new tracks’ honest notes, sharpened rather than softened: the robotics README now says outright that its “what actually goes wrong” sections are written from other people’s experience, and project-ideas.md states the debt explicitly. Phase 3 is complete.


The CS-curriculum gaps

Found 2026-08-14 by grep-testing a standard undergraduate syllabus against the vault. Absent entirely (0 hits): complexity theory (P vs NP), automata and formal languages, compilers, computer architecture, discrete mathematics, programming-language theory, computer graphics, information theory. All but the last three are now closed. Thin: operating systems (one note), databases (references only, no course), numerical methods.

The bias is coherent — everything practitioners use, little of what’s proved in a lecture hall — but two of these gaps block Phase 2, so they’re not optional:

  • foundations/compilers/ — ✅ DONE — 11 notes, ~16,500 words
  • foundations/os/ buildout — ✅ DONE — 12 notes, ~17,000 words. fundamentals.md kept (13 inbound links); numbered course built around it

Worth doing, not blocking:

  • foundations/theory-of-computation/ — ✅ DONE — 8 notes, ~11,600 words
  • foundations/computer-architecture/ — ✅ DONE — 12 notes, ~17,400 words (plan said ~10; data representation and performance-method earned their own)
  • foundations/discrete-math/ — ✅ DONE — 8 notes, ~11,300 words. Recurrences and the Master Theorem folded into 05-induction-and-recursion rather than a separate note
  • databases/ → a course — ✅ DONE — 12 notes, ~17,900 words, plus a README. Additive: all four reference files kept (≈40 inbound links) and positioned as the syntax layer; the course is the internals layer they lacked — pages, B-trees, LSM, the query pipeline, MVCC, WAL, replication, operations

Deferred, honestly: computer graphics, information theory, PL theory. Un-deferred 2026-08-16 — and a re-audit of every README’s stated-gaps section found two more load-bearing than any of the three:

Phase 4 — the gaps the vault itself flagged

Ordered by dependency. Chosen 2026-08-16 after grepping every README for its own “known gaps” section.

  • foundations/numerical-methods/ — ✅ DONE — 10 notes, ~14,500 words. Was the biggest structural hole. engineering/index says “not yet written; FEM and CFD both need it”; continuum mechanics lists quadrature/linear solvers/stability as genuine gaps; control theory needs discretisation; ML optimisation leans on conditioning. Floating point → root finding → linear systems → eigenvalues → interpolation → quadrature → ODEs → PDEs → optimisation
  • foundations/information-theory/ — ✅ DONE — 7 notes, ~10,600 words. Connective tissue, not a new silo. Cross-entropy and KL divergence are used throughout ai-ml/ and never explained; key entropy is referenced in discrete-math 06; Shannon capacity belongs under networking; ECC under number theory
  • foundations/gpu-and-parallel-computing/ — ✅ DONE — 7 notes, ~10,800 words. Closes the gap flagged in computer-architecture/index (“a genuine gap given the ML material in this vault”). ai-ml/ is 98 notes with nothing explaining the hardware underneath. SIMT/warps → coalescing → occupancy → the CUDA model → why matmul maps well → tensor cores → transfer cost
  • foundations/computer-graphics/ — ✅ DONE — 9 notes, ~13,000 words. Needed numerical methods and GPU first. The transform pipeline (reuses robotics/04), rasterisation, shading, ray tracing, shaders
  • foundations/programming-language-theory/ — ✅ DONE — 7 notes, ~10,200 words. Lambda calculus, formal type systems, operational semantics, Curry–Howard (already name-dropped in discrete-math/02). Stands on the compilers course

Phase 5 — the gaps two source courses found

Added 2026-08-22. Both from freeCodeCamp transcripts in sources/, gap-analysed against the vault before anything was written — most of what the IT-fundamentals course covers (IP addressing, subnetting, TCP/IP, DNS, firewalls, NAT, Linux, VPC/security groups, CI/CD) was already here and was deliberately not duplicated. Three folders survived the filter.

  • foundations/programming-fundamentals/ — ✅ DONE — README + 12 notes, ~13,700 words. The vault had no way in. 900+ notes assumed you could already read code; using-ai/ was written as the on-ramp for non-programmers into AI, and there was no equivalent into programming. Language-agnostic: what a program is → translation → tooling → syntax → variables/types → control flow → collections → functions → recursion/the call stack → errors/debugging → planning → what to build next
  • devops/00-the-physical-layer/ — ✅ DONE — README + 4 notes, ~5,100 words. The gap was exactly one layer wide: hardware/ covers boards, devops/08-cloud opens with “someone else’s computers” and never mentions the computers. Servers → virtualisation/hypervisors → data centres → the leaf-spine network. hot aisle had 0 hits vault-wide
  • devops/12-sre-and-platform-engineering/ — ✅ DONE — README + 4 notes, ~5,400 words. devops/ had eleven sections of tools and two paragraphs of disciplines. toil had 0 hits; IDPs appeared once; DevSecOps had no note. The evolution spine (waterfall → agile → DevOps → SRE → platform → DevSecOps, each fixing the last one’s bottleneck) → SRE practices → platform engineering → DevSecOps. Deliberately does not restate SLO/error-budget material already in 10-observability/

Total so far: 3 READMEs + 20 notes, ~27,400 words.

Phase 5b — the follow-on gaps (2026-08-22)

Found in the same session, from a third source (sources/100 CS concepts explained.md — mostly redundant; 95% of it was already covered at greater depth) and from a direct audit of languages/ and backend/frameworks/.

  • foundations/programming-fundamentals/ notes 13–14 — ✅ DONE — ~2,200 words. Closes the gap this course’s own README declared. The original call — “OOP belongs in languages/” — was wrong: OOP is language-flavoured, not language-specific, and omitting it stopped the course one concept short of where every real codebase starts. Objects and classes; programming paradigms (with expression-vs-statement, which was absent vault-wide outside compilers/)
  • languages/06-python/ — ✅ DONE — README + 14 notes, ~12,600 words. languages/index had listed “Python at depth” as a track that would slot in if notes got written. They hadn’t been — despite the entire ai-ml/ domain being written in Python and devops/ assuming it for automation. The vault taught Python-the-tool everywhere and Python-the-language nowhere. Deliberately excludes the web frameworks (below) and the numeric stack (ai-ml/00-foundations/04-python-and-data-tools/), per the languages/ rule
  • backend/frameworks/python/ — ✅ DONE — rewritten README + 3 notes, ~2,650 words. Was scaffold-only. Took the folder shape its own index predicted it would, since FastAPI, Django and Flask are genuinely co-equal subjects
  • devops/01-linux/12-bash-scripting — extended with repo-wide scripting technique (fold, assertion-guarded rewrites, verification passes). Not a new note — the heredoc and python3 - material was already there, so this extends rather than restates
  • .obsidian/app.json — userIgnoreFilters for quartz/ and sources/. 487 stray .md files in quartz/node_modules/ were polluting the graph and search. Not committed — .obsidian/ is gitignored

Phase 5 total: 5 READMEs + 39 notes, ~47,000 words, plus ~1,200 words extending 12-bash-scripting.

Phase 5c — the curiosity batch (2026-08-23)

Prompted by a single message naming six directions at once, plus “is the Python course complete” and “borrow from roadmap.sh”. All six became maps, none became an active course — logged in the parking lot, per the one-active-course rule.

  • Python roadmap audit — ✅ notes 15–17 (~2,700 words): files & I/O, regular expressions, asyncio in depth. All three were named as gaps by the course’s own honest note before roadmap.sh confirmed them. README now carries a full three-way roadmap mapping: covered here / covered elsewhere in the vault / deliberately skipped
  • foundations/systems-engineering/ — ✅ README + 8 notes, ~8,200 words. Zero prior hits for INCOSE, MBSE, SysML, requirements engineering or trade studies — in a vault kept by a systems engineering student. Cuts both ways: it connects the degree to the software, and imports FMEA/fault trees/ICDs/traceability, which software genuinely underuses. No roadmap.sh roadmap exists for this; the standards are the syllabus
  • game-development/ — ✅ README + 8 notes, ~7,600 words, cross-referenced against roadmap.sh game-developer. Deliberately thin — the roadmap’s maths, graphics, physics-integration, spatial-structure and ML topics were already written under computer-graphics/, robotics/, numerical-methods/, dsa/ and ai-ml/. The folder points at them rather than restating
  • foundations/software-engineering/04 — ✅ ~1,300 words. The field cut by constraint rather than product area, with embedded at depth (the stated interest) and an honest account of which switches are hard
  • desktop/ — ✅ README + 1 note + frameworks index + 5 scaffolds, ~2,750 words. Copies the backend/frameworks/ convention exactly, as requested. No roadmap.sh coverage exists
  • devops/00-the-physical-layer/05 — ✅ ~1,100 words. The infrastructure career path on top of the physical-layer notes: the roles, hands-on-metal vs infrastructure-as-software, where certs actually help
  • Parking lot + thinking-patterns — six interests dated and captured; the recurrence of the bundled-asks pattern recorded with evidence

Deferred, deliberately: finance / tax / entrepreneurship (deferred by him in the same message — and it isn’t a tech domain, so it needs its own shape rather than a course folder) and manufacturing as a business (under-specified; a business question, not a learning one).

Phase 5c total: 31 files (4 READMEs + 27 notes/scaffolds), ~26,500 words.

Phase 5d — exercises (2026-08-23)

The gap nine separate domain READMEs named independently, and the only one that genuinely required generation rather than reading. Two courses closed; seven still open.

  • foundations/programming-fundamentals/ 15–16 — ✅ ~3,550 words. Sixteen exercises, language-agnostic, ~8–12 hours. The course’s own honest note said “this is a reading course with no problems in it” — that no longer applies to it
  • languages/06-python/ 18–19 — ✅ ~3,500 words. Eighteen exercises that reproduce the gotchas. Every figure in the solutions was measured on Python 3.14, not estimated — including one exercise that had to be rewritten because 3.14’s constant folding defeated the original demonstration

Measured while writing, and worth recording: 4 threads on CPU-bound work ran 2× slower than serial (5.76 s vs 2.81 s) — stronger than note 12’s “no speedup” claim; catastrophic backtracking hit 23 s at n=28, doubling per character; a generator vs list of 5M items differed by 211,287× in getsizeof.

Still open — the same gap, in seven other domains: discrete-math, theory-of-computation, computer-architecture, numerical-methods, GPU/parallel, PL-theory, computer-graphics, information-theory, databases. Each names “exercises” in its own What's missing line.

Phase 5d total: 4 notes, ~7,050 words.

Phase 5e — the remaining nine domains (2026-08-23)

Every domain that named exercises in its own What's missing line now has them. Nine pairs, built from each README’s own “what would close the gap” list rather than invented.

DomainNotesShape
foundations/computer-architecture13–14Measured: cache sizes from timing, matmul, false sharing
foundations/numerical-methods11–12Measured: the U-curve, cancellation, Hilbert, Runge
foundations/discrete-math09–10Proofs on paper; RSA and counterexamples verified
foundations/theory-of-computation09–10Three proofs from scratch + regex engine + SAT solver
foundations/information-theory08–09Measured: entropy vs gzip, Huffman on skewed sources
databases13–14Measured: 9,327× index speedup, N+1, MVCC, WAL
foundations/gpu-and-parallel-computing08–09Honest no-GPU path; figures marked as borrowed
foundations/computer-graphics10–11Shadertoy + a CPU ray tracer
foundations/programming-language-theory08–09Implementations: Algorithm W, progress/preservation

Measured while writing, and it changed the material:

  • The sorted-array branch-prediction result does not reproduce at -O2 — 4.0× at -O0, ~nothing at -O2, because GCC emits branchless code. The exercise now asks you to find the instruction that explains it, which teaches more than the original
  • Matrix multiply: 6.5× at N=1024, only 2.4× at N=512 — the effect appears when the working set exceeds L3, so benchmarking on small inputs misleads
  • gzip beat the order-0 entropy “floor” by ~2× on a real file, which forced the correct statement: entropy is the floor for a given source model
  • A SQLite index gave 9,327× on 200 lookups over 500k rows
  • foundations/information-theory/index claimed Huffman loses “~7× at ” — measured, that’s 2.1×; 7.1× is . Corrected in place

Phase 5e total: 18 notes, ~21,900 words.

Phase 5f — the public-resource pass (2026-08-23)

Reframed by him mid-session: the vault is published, so it serves readers on paths that aren’t his. That changes what “missing” means — a stub that’s a fine personal placeholder is a dead end for a stranger.

  • Interview banks, where the reference material was deepest and the bank thinnest — ✅ 4 notes + a new bank, ~5,000 words. Java (parked) had 3 interview notes; frontend (his actual target) had 1. Now: frontend/interview 1→3 (the JS/TS language round; state/data/a11y/RSC), concepts/interview 1→2 (patterns, code review, testing theatre, when duplication beats abstraction), and a new languages/06-python/interview
  • ai-automation/ — ✅ README + 6 notes, ~5,500 words. The only genuinely empty domain in the vault — a 219-word stub carrying a 6-note plan since July. The plan was good; these are that plan, written

Deliberately not done: interview banks for game-development, desktop, systems-engineering and the CS-theory spine. INTERVIEW.md’s own stated principle is that “an interview bank for a subject you haven’t practised would be memorisation, not preparation” — that reasoning still holds, and silently violating it to make a table look complete would be the wrong kind of completeness.

Phase 5f total: 12 files, ~12,200 words.

Phase 5g — depth on request (2026-08-23)

Two asks: make game development a real track rather than a map, and add astronomy for someone else. The first exposed a dependency the vault didn’t have.

  • game-development/ → a full track — ✅ engines/ (4), interview/ (2), a project-ideas tier, README rewritten. Honest audit first: it had no projects, no interview bank, no per-engine structure — it was a map, and I’d said so. Now ~12,550 words
  • languages/07-csharp/ — ✅ README + 13 notes, ~9,600 words. C# was absent from the vault entirely, so the game track pointed at nothing for Unity, and languages/ had a Java-shaped hole where a reader would compare. Value/reference types, nullable refs, records, LINQ, reified generics, async, GC and Span<T>, pattern matching, DI, tiered JIT/AOT
  • astronomy/ — ✅ README + 10 notes, ~9,300 words. Written for a reader with no physics and no other domain in this vault. Note 09 handles astrology honestly — the two-millennia shared history (Ptolemy and Kepler practised both), what a natal chart actually contains, the Carlson and Dean–Kelly studies, and the six psychological mechanisms that explain why it feels precise anyway. Those mechanisms — Barnum, confirmation bias, subjective validation, cold reading — are useful well beyond astrology

A note on note 09’s framing, since it’s the one editorial judgement here worth recording: the vault is rigorous everywhere else, so presenting astrology as a working predictive system would have been dishonest, and refusing to cover it would have been useless to the person who asked. The treatment is accurate about the evidence, generous about the culture and history, and clear about where the line sits.

Phase 5g total: 32 new files, ~25,800 words (plus a rewritten game-development README and a project-ideas tier).

Phase 5h — the two dependencies (2026-08-23)

Both asked for directly, and both were things the vault had already flagged against itself.

  • backend/frameworks/csharp/ — ✅ README + 4 notes, ~3,500 words. Named in languages/07-csharp/index’s own “what’s missing”, and the frameworks map listed seven languages with C# conspicuously absent right after the language course landed. Flat notes by concern, per the folder’s own folder-vs-flat test: ASP.NET Core is the choice, and Minimal APIs vs MVC are two styles within it. Also updated the cross-stack concept table to seven columns
  • build-your-own-shit/ 10–12 — ✅ ~2,900 words. Chosen against the folder’s stated criterion rather than to pad the list:
    • Neural network — ai-ml/ is ~98 notes, the largest domain in the vault, and had no build guide. The most conspicuous absence
    • Memory allocator — best effort-to-insight after the container guide; makes foundations/os/05 and languages/04-c concrete
    • Physics engine — completes the game-dev track, and it’s the rare project where a wrong integrator is visually wrong

Considered and rejected, recorded so it isn’t re-litigated: a text editor (overlaps the shell guide’s raw-terminal material), a BitTorrent client (protocol plumbing over insight per hour), a browser engine (too large to finish, which violates the folder’s own rule 7 about stopping).

Phase 5h total: 8 files, ~6,400 words.

Phase 5i — the backend depth pass (2026-08-23)

Asked to “fill in the scaffolds — go, rust, c, cpp”. They weren’t scaffolds. The audit is the finding.

  • Corrected a stale index — ✅ go/, rust/, c/ and cpp/ were labelled scaffold in two places while containing 21 notes and ~28,000 words, written back in Phase 1.4. The table was never updated, and I edited it twice (for python/ and csharp/) without noticing. An index that lies about its own contents is worse than one that’s incomplete
  • backend/06-cross-cutting/ — ✅ README + 7 notes, ~5,400 words. This was the actual scaffold — a README that mapped elsewhere, including a row reading “file uploads — not covered anywhere yet — a genuine gap.” Validation & DTOs · config & secrets · error handling · rate limiting · idempotency & retries · security headers & CORS · file uploads. Caching, observability and background jobs deliberately still point elsewhere rather than being duplicated
  • backend/frameworks/cross-language-recipes — ✅ ~1,500 words. The stated ask: “a full backend in all the languages — rate limiting, headers, auth.” Middleware, rate limiting, JWT verification (with algorithm pinning), CORS, graceful shutdown, structured logging, and a what-you-get-free matrix — side by side in Node, Go, Rust, Python, C# and Java

Phase 5i total: 9 files, ~7,400 words, plus three corrected indexes.

Phase 5j — the frontend restructure (2026-08-23)

frontend/ is now a course + frameworks/, mirroring backend/. Both moves were already prescribed by the vault: concepts/index said “02-frontend arguably belongs in frontend/. Not moved yet”, and frontend/index said “distil the recurring material and leave the war stories in projects/, cross-linked — the same split backend uses.”

  • Structure — ✅ concepts/02-frontend/ moved in (3 notes → sections 02, 04, 07); 03-gsap/04-framer-motion/05-threejs/01-react/02-next moved under frameworks/. ~57 inbound links repointed across 39 files
  • Course sections 01–07 — ✅ 7 new notes, ~7,000 words: what a frontend is · the browser and the DOM · hydration and the server boundary · components and composition · data fetching and server state · CSS architecture · accessibility · performance
  • frameworks/react, next, css — ✅ the React model, error boundaries, and css/ with Tailwind and Sass — which appeared nowhere in the vault except one socioboom note
  • projects/ material left in place, deliberately — ~44,000 words of React/Next taught against real code. Moving it would strip the project logs of material that reads as a whole, against the dev-workflow principle that both copies are meant to exist. Indexed from frameworks/react/ and frameworks/next/ instead — the problem was findability, not location

Two bugs I made and caught, worth recording: a blunt string replacement rewrote projects/socioboom/learning/frontend/02-nextjs-app-router into a frameworks/ path (it matched inside a project path — replacements should have been anchored to [[); and sibling short-form links like [[02-state-management]] silently began resolving to a project note rather than the moved course note. The link checker reported “all resolve” for the second one — a link can resolve and still be wrong, which is the limitation of checking existence rather than intent.

  • Testing — ✅ 2 notes, ~2,200 words. @testing-library appeared nowhere in the vault outside my own “what’s missing” line, and Playwright had no note despite being a stated learning goal. 03-testing-a-frontend (query priority, waiting properly, MSW over module mocks) and 04-end-to-end-with-playwright — written to explain why the structure is what it is, not to list APIs

Backend testing was already covered and did not need adding: testing a backend (1,600 words — Testcontainers, test-data isolation, time, per-layer, auth, flakiness), testing fundamentals for the pyramid and TDD, plus per-language notes in Go, Rust, Java, Python and C#.

Phase 5j total: 18 files, ~11,600 words

Phase 5k — React guide, and two renames (2026-08-24)

  • build-your-own-shit/13-your-own-react — ✅ ~1,300 words. createElement → render → a work loop → fibers → the render/commit split → reconciliation and keys → function components → useState via an array and a cursor. The payoff is step 8: put a hook inside an if and watch state attach to the wrong slot — the hook rules stop being style and become the only thing keeping that array aligned. Optional step 10 rebuilds it with signals, which makes the React-vs-Solid comparison in frontend/frameworks/index something you’ve felt
  • build-your-own-x/ → build-your-own-shit/ — ✅ his call, taken with the trade named: the folder is a public Quartz URL (kingsleydaprime.github.io/knowledgebase/build-your-own-shit/) on a site the hire track plans to link from a CV. 107 paths and 7 display names across 41 files. Checked first that the string never appears as a substring of anything else and isn’t in any config
  • “Software Engineering — Orientation” → “Introduction to Software Engineering” — ✅ the domain README title, the root README entry, and SWE 101’s week 1 in the scheme of work. “Orientation” described the note’s role in the vault; “Introduction to Software Engineering” describes what it teaches, which is the right name for the first topic of the course

Phase 5k total: 1 new guide + 2 renames across 45 files.


Phase 6 — the web3 track (2026-08-31)

His observation, and it was correct: the vault had nothing on blockchain — no smart contracts, no Solidity, no crypto, no NFTs, no chain development in any language. A grep for web3|blockchain|solidity|smart contract|ethereum|bitcoin across every note returned six incidental mentions, all of them analogies in dsa/, theory-of-computation/ and architecture/.

  • web3/ — ✅ 71 files. An 8-section numbered course, frameworks/ for five languages, and an interview/ bank. Built to the cybersecurity/ shape: 01-foundations (the double-spend problem as an ordering problem, UTXO vs accounts, consensus read through what does an attack cost) → 02-ethereum-and-the-evm (the four data locations, and the storage-cost ratio that drives everything downstream) → 03-smart-contracts-with-solidity (10 notes) → 04-smart-contract-security (8 notes, and its README says to read it in parallel with 03, not after) → 05-beyond-ethereum (the trilemma, rollups, zk, Solana, Bitcoin, bridges) → 06-building-dapps (the note that saves the most rework is 04: you cannot query a blockchain) → 07-the-application-layer → 08-the-honest-assessment
  • build-your-own-shit/14, 15, 16 — ✅ his call to make it three guides rather than one. 14 blockchain (the payoff is watching two of your own nodes fork and reconverge), 15 smart contract VM (the deepest — gas, reverts and DELEGATECALL become mechanisms you built), 16 token and wallet (the most applied, and the best first one: an ERC-20 on a testnet in MetaMask, and an HD wallet whose addresses match MetaMask’s for the same seed)
  • Integration — ✅ root README structure tree, INTERVIEW.md (fifteen → sixteen banks), build-your-own-shit/index (thirteen → sixteen), and two Quartz symlinks
  • A dangling symlink, found in passing — ✅ quartz/content/build-your-own-x still pointed at the pre-5k name and had been broken since the rename, so the folder was absent from the published site. Repointed to build-your-own-shit

Section 08 is the part that makes this track worth having. Every other web3 resource explains how things work; that section asks whether they should be used — the four-question test that kills most blockchain proposals, where the money actually went (access control and bridges, not the reentrancy the field talks about), regulation as the constraint that has shaped the field more than any technical limit, and energy after the Merge. The course README says to read it early, right after foundations, rather than last.

The standing caveat applies in full: this is [reference]. Nothing here has been deployed, audited, or exploited by its author. The three build guides exist to start closing that, and guide 16 is the cheapest — a free testnet, one evening, and a contract that exists.

Phase 6 total: 74 new files, plus 4 indexes updated and 2 symlinks fixed.


Phase 7 — the reps pass (2026-08-31)

His call, and the right one: the vault had ~1M words of map and one 216-line file of territory. “I want my courses to make me really good” — which is a reps problem, not a notes problem.

  • A projects.md in every course domain — ✅ 15 files. Eight written from scratch for domains that had nothing (backend, frontend, databases, architecture, web3, git, languages, engineering); seven migrated out of the central file and expanded (devops, ai-ml, cybersecurity, hardware, robotics, game-development, foundations)
  • A done when on every project — ✅ the convention borrowed from build-your-own-shit’s “works when”. A project without a finish line gets abandoned or gold-plated, and the old list had neither
  • project-ideas.md rewritten as an index — ✅ 216 → 94 lines. A one-per-domain table naming the one to do first, the “if you only do five”, and the two sections that are career-target rather than domain-scoped (Java/systems, build-your-own)
  • Linked from every domain README — ✅ 14 of 15; foundations/ has no README to link from (see below)

Queued — the gap audit (2026-08-31)

Found by auditing coverage rather than by asking what’s missing. In priority order.

Missing domains

  • mobile/ — the biggest structural hole. No Swift, Kotlin, Dart, iOS, Android, Flutter or React Native anywhere; every grep hit is incidental. frontend/, backend/, desktop/ and game-development/ all exist — mobile is the missing sibling, and it’s the platform most people actually use. Needs languages/08-swift, 09-kotlin, 10-dart plus mobile/ with frameworks/{ios,android,flutter,react-native} and interview/. Note: Android is Kotlin, not Java — Google went Kotlin-first in 2019
  • Data engineering — Kafka, Spark, Airflow, dbt, warehouses, streaming, CDC. databases/ is OLTP internals only. The missing bridge between databases/ and ai-ml/
  • DSP / signal processing — Fourier, filters, sampling, modulation. The missing link between hardware/’s RF material and foundations/information-theory/; would also serve robotics/
  • XR, quantum computing, search/IR, product & design — real but narrower

Note gaps inside cybersecurity/

34,822 words total — smaller than the web3 track, for a much bigger subject. shellcode, kerberos, pivoting, mimikatz and fuzzing return zero files.

  • Binary exploitation — currently one bullet and one heading. No shellcode, ROP, heap, ASLR/canary bypass. This is what OSCP and most CTFs test
  • Active Directory / Windows attack paths — currently one table row (Kerberoasting). No Kerberos, pass-the-hash depth, lateral movement, BloodHound. AD is what the large majority of real corporate pentests are
  • 10-protecting-yourself/ — personal security for a non-technical reader, in the shape using-ai/ was written for. Password managers, passkeys, SIM-swap, device encryption, backups, a personal threat model, what to do in the first hour after a breach. The one thing in the vault you could send to family — and 90% of real compromise is what it would cover
  • Malware analysis & reverse engineering — 2 passing mentions
  • API security — no dedicated coverage
  • Thicken 09-cloud-security (758 words, thinnest folder in the vault), 08-governance-risk-and-compliance (1,225), 01-fundamentals (1,540)

Structural

  • foundations/ has no README — the vault’s largest section (~312,000 words, 16 sub-courses) has no entry point. Every other domain has one. Found while linking projects.md files in Phase 7
  • Practice exercises exist in 12 domains, absent in 10 (backend, frontend, architecture, git, web3, engineering, robotics, hardware, game-dev, concepts). Lower priority than the above — projects.md now covers the reps gap for those

Phase 7 total: 15 new files, 1 rewritten index, 14 READMEs updated.


Phase 8 — protecting-yourself, then mobile (2026-08-31)

Both from his ask, in his order.

  • cybersecurity/10-protecting-yourself/ — ✅ 9 files, ~8,600 words. The odd one out in that domain and deliberately so: sections 01–09 are written for someone defending an organisation, this one for the reader themselves and the people who ring them. Written in the using-ai shape — no code, no jargon, honest about what’s oversold. Your actual threat model (you are almost certainly not being targeted) → passwords, where reuse not strength is the problem → why SMS 2FA is the weak kind → the phishing tells that still work now AI has killed the old two → devices, and an honest VPN answer → backups, and why sync is not backup → your privacy footprint as an attacker’s research budget → an ordered checklist for when it’s already happened
  • mobile/ — ✅ 23 files, ~18,000 words. The gap Phase 6’s audit named first. A 14-note platform-agnostic course (that’s the point — it holds whichever stack you pick), frameworks/{ios,android,flutter,react-native}, interview/, projects.md
  • languages/08-swift/, 09-kotlin/, 10-dart/ — ✅ 29 files, ~19,600 words. Kotlin is deliberately the shortest of the three because the Java course already covers the JVM underneath it; Dart is shortest overall because it holds few surprises for anyone who knows Java or TypeScript
  • A correction carried into the build — ✅ he said the mobile languages were “swift, dart, java, js”. Android is Kotlin, not Java — Google went Kotlin-first in 2019 — so the track is Swift/Kotlin/Dart, with TypeScript already covered by React
  • Integration — ✅ languages/index (the stale “Kotlin would slot in if notes get written” line is now redundant and removed), root README tree, INTERVIEW.md (sixteen → seventeen), project-ideas.md, the Quartz landing page (six → seven columns), and a mobile symlink

The load-bearing note in the mobile track is 03, the lifecycle. Everything else — view models, saved-state handles, offline-first databases, resumable navigation — is a response to the OS can destroy your process at any moment with no reliable warning. Its testing section is the part most developers never do, and the interview bank says plainly that the process-death questions are what separate people who’ve shipped from people who’ve followed tutorials.

And the honest labelling holds: both tracks are [reference]. Nothing in mobile/ has been shipped to a store by its author, and mobile/projects.md says so in its first line. The cheapest fix is its first rung — survive process death — which is an afternoon.

Phase 8 total: 61 new files, ~46,200 words, plus 6 indexes updated and 1 symlink added.


Phase 9 — the two offensive gaps (2026-08-31)

From the queue, in priority order. These were the two things I’d flagged as standing between him and getting stuck on his third HackTheBox box.

  • cybersecurity/11-binary-exploitation/ — ✅ 7 notes. Built as its own numbered section (parallel to 06-attacks-and-threats, 07-security-operations) rather than crammed into 02-ethical-hacking, because it’s a whole discipline. The load-bearing framing: an exploit is a chain of primitives, and modern defences shifted the era from injecting code to reusing the target’s own — so the notes are ordered as base case → each mitigation → its bypass. checksec as a recipe is the recurring practical anchor
  • cybersecurity/12-active-directory/ — ✅ 6 notes. The bigger of the two in real-world terms: internal pentesting IS AD pentesting, and it’s the CTF-learner’s blind spot. Framing: graph traversal with stolen credentials, not vulnerability exploitation. Kerberos gets its own note early because nearly every named attack abuses “every ticket is encrypted with an account’s hash”; BloodHound is named as the single highest-leverage skill; the defence note is the mirror of the attack notes
  • Both assume the authorization from note 01 — stated in every README and most notes. Dual-use material framed for lab, CTF (ROP Emporium, pwn.college, GOAD, HackTheBox), and authorised engagements, which is exactly the context ethical-hacking already establishes
  • Integration — ✅ cybersecurity/index (two new sections), root README tree, and cybersecurity/projects.md — whose stale “expect to learn these elsewhere until those notes exist” caveat is now three real reps pointing at GOAD, ROP Emporium and pwn.college
  • A self-inflicted cleanup — ✅ ln -s into the quartz/content/cybersecurity dir-symlink created two recursive symlinks inside the real folders; removed. (cybersecurity is a directory symlink, so its subdirs are auto-exposed to Quartz — no per-section symlink needed)

Phase 9 total: 15 new files, ~12,900 words, plus 3 indexes updated.

Phase 10 — data engineering (2026-08-31)

From the queue. Built as its own top-level domain (not folded into databases/ or ai-ml/), because it’s a distinct discipline and a distinct career track — the plumbing between the systems that run a business and the systems that analyse it.

  • data-engineering/ — ✅ 10 notes + README + projects + interview. The gap the audit named: databases/ is single-DB internals, architecture/04 has the log/partitioning theory, ai-ml/10-mlops touches serving — but the discipline that assembles pipelines had no home
  • Framing decisions that shaped it: the operational/analytical split as the root of everything (note 01), ELT over ETL as the change that defines the modern field, idempotency as the load-bearing operational discipline (note 08), and — deliberately, against the tooling hype — “most data fits on one machine, measure before you distribute” (note 06) and “the modern data stack is frequently over-engineered” (note 10). The vault’s house style is honest assessment, and this field needed it more than most
  • Cross-linked into databases/ (the layer below), ai-ml/ (the layer above — MLOps is largely data engineering), architecture/04-distributed-systems (the log, partitioning), and the four indexes (root README tree, INTERVIEW 17→18, project-ideas, Quartz Infrastructure column + symlink)

Phase 10 total: 14 new files, ~9,700 words, plus 6 indexes updated and 1 symlink.

Phase 11 — digital signal processing (2026-09-01)

From the queue. Placed under foundations/ (not hardware/ or its own top-level domain), because it’s foundational maths-and-engineering alongside numerical-methods and information-theory, and it bridges three existing areas.

  • foundations/digital-signal-processing/ — ✅ 9 notes + README + projects. The gap the audit named: hardware/ had RF, information-theory/ had entropy and channels, numerical-methods/ had interpolation — but sampling, Fourier, convolution, filters and modulation had no home
  • Framing that shaped it: the two load-bearing ideas are the frequency domain (any signal is a sum of sinusoids) and convolution (which is multiplication in that domain) — the notes are ordered so 01–05 build to those, and 06–09 apply them. The convolution theorem (note 05) is the hinge, and it’s deliberately connected to CNNs — a conv layer is DSP convolution with learned kernels — which makes this folder upstream of computer vision, not just radio
  • No interview bank — correct and deliberate: it’s [reference] tier, and INTERVIEW.md’s stated principle is that reference tracks with no reps don’t get banks (matching numerical-methods, information-theory et al.)
  • The reps are unusually fun and cheap — NumPy on a laptop, then a ~$30 RTL-SDR dongle that decodes real aircraft (ADS-B). Legal because it’s receive-only; the projects file says so
  • Cross-linked into information-theory (applied sibling), hardware/06-radio-frequency (the analog side of modulation), ai-ml/computer-vision (convolution), plus foundations/index (theory spine + reference list), foundations/projects, and the root README tree. No Quartz symlink needed — foundations/ is a directory symlink, so the new folder is auto-exposed
  • No INTERVIEW.md change (no bank), and the theory spine is now nine reference courses

Phase 11 total: 11 new files, ~11,000 words, plus 5 indexes/neighbours updated.

Phase 12 — malware analysis & reverse engineering (2026-09-01)

From the queue. Built as cybersecurity/13-..., the defensive twin of binary exploitation — understanding programs rather than breaking them — completing the offensive-technical trio (11 exploitation, 12 AD, 13 RE/malware).

  • cybersecurity/13-malware-and-reverse-engineering/ — ✅ 6 notes + README. RE (static vs dynamic, formats, the legal line) → static analysis (the cheap tells — hash/strings/imports — before reading code) → dynamic analysis (the safe lab, unpacking in memory) → how malware works (one lifecycle, recurring techniques) → evasion (why signature detection is losing, and defence moved to behaviour) → the workflow (triage-to-deep-dive, IOCs, YARA)
  • Framing: deliberately defensive and research — malware analysis to build detection, CTF rev, vulnerability research, interoperability. The dual-use line is stated in every note; isolation is framed as a safety requirement (you run live hostile code), and the practice ladder starts at zero-infection-risk crackmes/CTF before live samples. No “how to write malware” content — the focus is understanding, analysing, detecting
  • No new interview folder — consistent with 11 and 12; cybersecurity has one bank at interview/
  • Integration — cybersecurity/index (new section), root README tree, cybersecurity/projects.md (two reps: a crackme, then a lab-isolated sample + YARA rule). No Quartz symlink (cybersecurity is a directory symlink)

Phase 12 total: 7 new files, ~9,700 words, plus 3 indexes updated.

Phase 13 — API security (2026-09-01)

From the queue. Built as cybersecurity/14-..., positioned as “web security minus the browser” and structured around the OWASP API Security Top 10 (2023) as its backbone.

  • cybersecurity/14-api-security/ — ✅ 6 notes + README. What makes APIs different (authorization dominates, not injection — 3 of OWASP’s top 5) → authentication (API keys, the JWT pitfalls checklist, OAuth, token storage) → BOLA/IDOR and the authZ family (BFLA, mass assignment, excessive exposure) → input validation, injection on an API surface, and SSRF (Capital One) → rate limiting and business-flow abuse a rate limit can’t catch → the lifecycle (shadow/zombie APIs, misconfiguration, unsafe consumption, gateways, testing)
  • Deliberately non-duplicative — it overlaps web-security and backend/auth, so it covers only what’s API-specific and cross-links the general treatment for injection, OAuth and TLS. Positioned as the attacking-and-defending twin of API design
  • Integration — cybersecurity/index (new section), root README tree, cybersecurity/projects.md (a BOLA/BFLA rep on crAPI), and cross-links added into web-security, backend/api-design and backend/auth (so the building-side notes point at the security-side). No Quartz symlink (cybersecurity is a directory symlink)

Phase 13 total: 7 new files, ~9,500 words, plus 6 files updated (3 indexes + 3 cross-links).

Phase 14 — thicken cloud security (2026-09-01)

From the queue — the last substantive gap. 09-cloud-security was the vault’s thinnest folder (one 637-word note for a whole domain).

  • cybersecurity/09-cloud-security/ — 1 note → 5. The old single note was genuinely good but undersold the topic, so I split-and-deepened rather than rewrote: shared responsibility model → identity-is-the-perimeter (IAM depth, least privilege, and the privilege-escalation paths over-permissioning enables — the same “permissions that reach permissions” idea as API BOLA) → the attack surface ranked (public buckets #1, then the metadata-service-via-SSRF path, tied explicitly to Capital One and my new API-security SSRF note) → container/k8s (the three layers, every default insecure) → cloud-native defence (shift-left, CSPM/CIEM/CNAPP, CloudTrail→SIEM, DevSecOps)
  • Migration handled cleanly — old note removed, its content preserved and expanded across the five, and the 2 external inbound links (from devops/12-sre.../04-devsecops and devops/00-physical.../02-virtualisation) repointed to the new note 01
  • Cross-linked the new SSRF/metadata material to API security’s SSRF note — the two now reinforce each other on the Capital One attack path
  • Integration — 09 README rewritten, root README tree updated. No Quartz symlink (cybersecurity is a directory symlink)

Phase 14 total: 4 new notes + 1 rewritten README (net +4 files, ~4,800 net new words), 2 inbound links repointed.

Phase 15 — thicken GRC and fundamentals (2026-09-01)

From the queue — the last items. Both folders were coherent and well-written but brief; the right fix was adding the missing foundational concepts, not padding the good notes.

  • 01-fundamentals/ 3 notes → 5 + README. The three existing notes (what cybersecurity is, CIA triad, attacker types) are good and untouched. Added the two concepts they reference as important but never teach: 04-security-principles (the durable Saltzer-Schroeder principles — defence in depth, least privilege, fail-safe, zero trust, minimise-surface, no-obscurity — framed as a reasoning tool you derive rules from) and 05-threat-modeling (Shostack’s four questions, STRIDE, trust boundaries — the bridge from the attacker taxonomy to a plan). Plus a README the folder lacked
  • 08-GRC/ 2 notes → 4. The folder was heavy on R (risk) and C (compliance), light on G (governance). Added 03-governance-and-the-human-layer (running security as a program — policy→standard→procedure hierarchy, the CISO/roles, and the human layer: awareness and a blameless reporting culture) and 04-third-party-and-supply-chain-risk (the dominant modern breach vector — SolarWinds, Log4Shell, Target; SBOMs, vendor vetting — entirely absent before, and increasingly the risk)
  • Cross-linked into the newer sections (security-principles ↔ cloud IAM/AD tiering/API BOLA; supply-chain ↔ cloud container supply chain and shift-left scanning; human-layer ↔ social engineering and protecting-yourself), so the fundamentals and GRC now tie the whole cybersecurity track together rather than sitting apart
  • Integration — both folder READMEs, the main cybersecurity README’s Fundamentals list, and the root README tree. No Quartz symlink (cybersecurity is a directory symlink)

Phase 15 total: 5 new files (4 notes + 1 README), ~6,500 words, plus 3 READMEs updated.

Also (Sep 2026): refreshed the root README’s narrative intro — it had drifted while the structure tree below it was kept current. Updated the built-out domains list, the build-your-own-shit count (13→16, +blockchain/VM/token guides), the cybersecurity one-liner (now 14 sections), and added start-here entries for mobile, data-engineering, web3 and DSP; noted that every domain now ships a projects.md.

Phase 16 — data analysis (2026-09-01)

His probe — “no more content gaps? data analysis?” — and he was right. An honest audit found a genuine hole: the vault had data engineering (build the warehouse) and data science (models/inference), but the enormous middle — the analyst discipline, the most common data job — was missing. The data-scientist track even distinguished the analyst without covering it. This also swept up the time-series gap (nothing on trend/seasonality/forecasting anywhere).

  • data-analysis/ — ✅ 12 files (8 notes + README + projects + 2-file interview bank). The analyst role vs engineer vs scientist → SQL for analysis (window functions & CTEs — the primary skill) → metrics & KPIs (vanity vs actionable, Goodhart) → exploratory & diagnostic analysis (why did it change? as a method) → product analytics (funnels, cohorts, retention, LTV:CAC) → time series (decomposition, seasonality, forecasting — fills that gap too) → dashboards & the semantic layer → communicating (the deliverable is a decision)
  • Positioned as the third data domain so the stack reads engineering → analysis → science. Borrows the rigorous stats (A/B testing, causal inference) from the data-scientist track rather than duplicating; consumes the data-engineering warehouse. Heavily cross-linked to both
  • Integration — root README (tree + start-here), INTERVIEW (18→19), project-ideas, the Quartz ML & Data landing-page column + symlink

Phase 16 total: 12 new files, ~13,000 words, plus 5 indexes updated.

Queued (not yet done)

  • Distilled sources/Developer habits.md — ✅ → concepts/01-best-practices/07, the 7 habits under one through-line (make the next change easier), cross-linked to clean-code, SOLID, type-driven design and the anti-corruption-layer pattern
  • Practice-exercise files where they genuinely fit — ✅ added drill+solution files to DSP (10/11 — the one foundations theory course that lacked them, now consistent with all its siblings) and data-analysis (09/10 — SQL is inherently drillable). Deliberately NOT added to the applied build-domains (backend, frontend, architecture, devops, mobile, etc.) — those use projects.md as their rep mechanism by design, and drill files there would be forced padding

Queue after Phase 8

Closed: mobile/ ✅ · cybersecurity/10-protecting-yourself/ ✅

Still open, in priority order:

  • Binary exploitation — ✅ cybersecurity/11-binary-exploitation/, 7 notes, ~6,900 words. Process memory → stack overflows and ret2win → shellcode → the mitigations (checksec as a recipe) → ret2libc/ROP → format strings and the heap → pwntools/pwndbg/practice

  • Active Directory — ✅ cybersecurity/12-active-directory/, 6 notes, ~6,000 words. What AD is (the graph model) → Kerberos → enumeration/BloodHound → credential attacks → lateral movement/escalation → defending. Its projects entry points at GOAD

  • foundations/ README — ✅ written 2026-08-31. The vault’s largest section (15 courses, ~371 notes, ~312k words) had no entry point while every sub-course had one. Also fixed a wikilink broken by a line wrap in devops/01-linux/12-bash-scripting, found by scanning for unclosed [[ — a check the earlier link validator structurally could not catch, since its regex required a closing ]]

  • Data engineering — ✅ data-engineering/, 14 files (10 notes + README + projects + a 2-file interview bank), ~9,700 words + banks. The operational/analytical split → warehouses/lakes/lakehouses → batch/streaming → ingestion & CDC → Kafka → Spark (and when not to) → dbt → orchestration/idempotency → dimensional modelling → data quality. Cross-linked from databases/ and ai-ml/ READMEs

  • DSP / signal processing — ✅ foundations/digital-signal-processing/, 11 files (9 notes + README + projects), ~11,000 words. Signals & LTI → sampling/Nyquist → the frequency domain → FFT → convolution → filters → spectral analysis → modulation & SDR → practice. Cross-linked to hardware/RF, information-theory, and — the non-obvious one — computer-vision (a CNN’s convolution is DSP convolution)

  • Malware analysis & reverse engineering — ✅ cybersecurity/13-malware-and-reverse-engineering/, 7 files (6 notes + README), ~9,700 words. RE and the legal line → static (the cheap tells) → dynamic (safe lab, unpack in memory) → how malware works → evasion → the workflow (IOCs, YARA). The defensive twin of 11, completing the offensive-technical trio (11/12/13)

  • API security — ✅ cybersecurity/14-api-security/, 7 files (6 notes + README), ~9,500 words. Built around the OWASP API Security Top 10: what makes APIs different (authZ dominates) → authentication (JWT pitfalls) → BOLA/BFLA/mass-assignment → injection & SSRF → rate limiting & business-flow abuse → the lifecycle (shadow APIs, gateways, testing). Cross-linked to web-security, backend/api-design and backend/auth

  • Thicken 09-cloud-security — ✅ expanded from 1 note (758 words) to 5 notes (~5,600 words). Shared responsibility → identity-is-the-perimeter (IAM + escalation paths) → the attack surface (public storage, exposed secrets, metadata/SSRF = Capital One) → container/k8s security → cloud-native defence (CSPM/CIEM/CNAPP, shift-left, CloudTrail→SIEM). Old single note’s content preserved and redistributed; 2 external inbound links repointed

  • Thicken 08-GRC and 01-fundamentals — ✅ both expanded by adding the missing foundational concepts rather than padding the (good) existing notes. Fundamentals 3→5 + README: added 04-security-principles (defence in depth, least privilege, fail-safe, zero trust — a reasoning tool) and 05-threat-modeling (the four questions, STRIDE, trust boundaries) — both were repeatedly mentioned as important but never taught. GRC 2→4: added 03-governance-and-the-human-layer (the underweighted ‘G’ — policy hierarchy, the security program, and security awareness/blameless culture) and 04-third-party-and-supply-chain-risk (SolarWinds/Log4Shell/Target, SBOMs — the dominant modern vector, absent before)

  • Practice exercises for domains still lacking them (lower priority — projects.md files now cover the reps gap)

  • Practice exercises for the 10 domains without them (lower priority — projects.md now covers the reps gap)

  • A table of contents for the scheme of work — ✅ his observation, and the justification turned out to be structural rather than cosmetic: the file summarised 153 topics with a 12-row block table and nothing in between, so “where is X taught / when do I hit it” meant scrolling 624 lines. And the file’s own header says “week number = notebook section number” and “index on pages 1–4” — so the notebook needs an index the source document never produced. **Generated by ** between HTML markers, so it is regenerated rather than hand-maintained and cannot drift from the weeks below it., plus 39 files repointed and 3 indexes rewritten.

Still open: — a course (01–07) plus frontend/frameworks/{react,next,css}, mirroring backend/. The bigger half of that is a move, not new writing: ~44,000 words of React/Next material currently sit in projects/, indexed only by frontend/index. That’s a findability problem, and it’s the next batch. Combined 5d+5e: 22 notes, ~29,000 words, and no domain README now names exercises as missing. The standing caveat applies harder than usual to the last one — three of its four notes are organisational disciplines, and a solo project has no dev/ops wall, no ticket queue and no on-call rotation to validate them against.


Phase 17 — six more build guides (2026-09-11)

His question, and it was the right one to ask: from this knowledgebase and from the build-your-own-x repo, are there projects I haven’t added yet? Two audits answered it. Eleven vault domains had zero links into build-your-own-shit/ — networking/, architecture/, computer-graphics/, information-theory/, data-engineering/, gpu-and-parallel-computing/, digital-signal-processing/, dsa/, mobile/, robotics/ and desktop/ — against web3/, which links out from eleven files. And the build-your-own-x README has 31 categories, eight of them unanswered here after removing the three already declined.

  • build-your-own-shit/ 19–24 — ✅ ~10,100 words, Sep 2026. Chosen by intersecting two lists: eleven vault domains had no link into the build folder at all, and the build-your-own-x README has categories this folder never answered. 19 TCP/IP stack — the only one that closes a hole inside the folder: guide 01 starts at accept(), and this builds what it was standing on, ending with 01 running on top of it. 20 Raft key-value store — project-ideas had called this the best distributed-systems project there is since the file was written, and architecture/ had no guide. 21 compressor — the best ratio of ending to effort here: a weekend, and gunzip reads your output. 22 ray tracer — the shortest path to something worth looking at, and computer-graphics/ was eleven notes of pure theory. 23 debugger — sits on top of more of the vault than any other guide, and gdb is an oracle at every milestone. 24 LLM — guide 10 stopped at a multilayer perceptron, leaving the largest domain in the vault ending two decades early
  • Wiring, which was the point — ✅ networking/, architecture/04-distributed-systems/, information-theory/ and computer-graphics/ gained a Build it section or a Related entry pointing at their first guide; plus the four matching topic notes, cybersecurity/11-binary-exploitation, compilers/09-linking-and-loading, ai-ml/projects, architecture/projects, project-ideas and HOME. Declined explicitly in the index rather than silently: bots, augmented reality, voxel engines, template engines, command-line tools, and a CHIP-8 emulator (guide 17 already covers it)

The filter matters as much as the additions. byox’s bots, augmented reality, voxel engines, template engines and command-line tools were declined on the folder’s own stated criterion — build a toy version of something you rely on — and that reasoning is now written into the index rather than left implicit. A CHIP-8 emulator was declined separately: guide 17’s Python emulator already covers it.

Still unwritten and defensible: a DNS server, an append-only log in the shape of Kafka, a search engine (inverted index, TF-IDF, BM25), a reverse proxy and load balancer, a module bundler, and an actual game — the physics guide built the hard half and stopped.


Suggested order

Each line is roughly one working session.

#BatchNotes
1languages/03-rust/ ✅18
2languages/04-c/ ✅13
3languages/05-cpp/ ✅15
4backend/frameworks/ ✅21
5foundations/os/ ✅12
6foundations/compilers/ ✅11
7build-your-own-shit/ — 01, 02, 07 ✅3
8build-your-own-shit/ — 03, 04, 06 ✅3
9build-your-own-shit/ — 05, 08 ✅2
10engineering/01-continuum-mechanics/ ✅13
11engineering/02-control-theory/ ✅13
12robotics/ buildout ✅14
13optional — theory of computation, computer architecture, discrete math ✅28

Batches 5 and 6 are inserted before build-your-own-shit/ because the OS and compilers guides are blocked without them. Everything else follows the order requested.

PHASES 0–4 COMPLETE (2026-08-16); Phase 5 added and completed 2026-08-22. Phase 4 was added from a re-audit of every README’s own stated-gaps section — the three long-deferred subjects, plus numerical methods and GPU/parallel computing, which turned out to be more load-bearing than any of them. All five were built in dependency order in one session: 40 notes, ~59,000 words.

Phase 5 (2026-08-22) added three more, found by gap-analysing two source courses rather than a syllabus — see above. Nothing is queued. The remaining gaps each README names are now within domains rather than whole missing subjects — and the vault-wide debt is reps, not notes. Fourteen domains are [reference]; every one names its own remedy, and project-ideas carries the consolidated list.

The standing debt is reps, not notes. engineering/, robotics/ and all three CS-theory domains are [reference]: read and assembled, never validated by building. Each one’s README names what would close its own gap, and project-ideas carries the list.


↑ Back to Kingsley's Knowledge Base