Foundations of Computing

Months 1-12. Master the layers everything else builds on. Linux as a deep implementation, FreeBSD as the comparison — so the patterns (process, memory, syscall, filesystem) survive the tool. By year-end you can debug any layer above the kernel. Exit ramp: Junior SRE / IT Engineer

Year 1 is the ground floor of ROOT. Everything in Years 2-5 — distributed systems, the data tier, ML platform, agents — assumes you can reason about a process, a packet, a transaction, a container, and a reconciliation loop without looking anything up. This year is where that reasoning gets installed.

The shape of the year is deliberate. Phases 1-3 build the substrate: how the machine works, how machines talk, how state is stored durably. Phases 4-5 add just enough programming fluency to write tools that operate the substrate — not language mastery, fluency. Phase 6 dissolves the container abstraction by building one from unshare and cgroups. Phase 7 — the longest — is where the prior six phases compose into Kubernetes + GitOps, the first encounter with the control-loop pattern that recurs every year afterward.

By the end of Year 1, the basecamp Tier 1 (Foundation) is alive on a homelab mini-PC: K3s + ArgoCD + Postgres + Redis + Prometheus + Grafana, with triage deployed on it as the first real service. That stack is what every later year extends.

Why “fluency, not mastery” for Python and Go

Year 1 is not where you become a senior Python or Go engineer. It is where you ship enough small, reviewed, released code in both languages that you can read any tool’s source, write a useful CLI in an afternoon, and stop fearing the language layer. Mastery comes later, in Years 3-5, when you operate complex systems written in these languages — services/llm-gateway/, services/aiops/, platform-ctl. Year 1 buys the right to learn those without language friction.

---

What you’ll know at the end of Year 1

Concrete, internalized — not “I read about it.” If someone wakes you at 3am, these answers come without notes:

• Operating systems at the principle level — process model, virtual memory, scheduling, filesystems, boot. Linux as canonical implementation; FreeBSD as compare so you don’t confuse “Linux” with “OS.” You can explain what a syscall actually does across the user/kernel boundary.
• Networking from TCP/IP through L4/L7 and into the start of zero-trust mesh thinking. You can read a tcpdump and reason about which layer is misbehaving.
• Databases — SQL fluency, transactions, replication, query optimization, the OLTP/OLAP boundary. You know why WAL exists and what LSM-vs-Btree trade-offs look like in practice.
• Python + Go fluency — three small CLIs shipped publicly. Fluency means: I can write a useful tool in this language tonight. Mastery comes later.
• Containers as a pattern (namespaces + cgroups + UnionFS), built one from scratch with unshare so the Docker magic dissolves into Linux primitives you’ve already met.
• Kubernetes + GitOps — the canonical container orchestrator implementing declarative reconciliation. By phase-end, you can debug a Pod stuck in Pending from first principles, not from a Stack Overflow recipe.

You’ll be able to debug any layer above the kernel and reason about which patterns are at play — which is exactly the bar for the Junior SRE / IT Engineer exit ramp.

---

Phase map

Phase	Title	Approx. weeks	Approx. hours	Pattern depth
1	OS Foundations: Linux as Implementation	8	100	virtualization, privilege separation, mediation, layering
2	Networking: TCP/IP to L7	7	80	routing, layering, defense-in-depth
3	Databases: Postgres + Redis	7-8	90	WAL, LSM-vs-Btree, OLTP-vs-OLAP, replication, idempotency
4	Python: Fluency + ship rxp	5	60	text-processing, schema-validation (touched, not deepened)
5	Go: Fluency + Concurrency + ship pulse	5	60	backpressure, fault-isolation
6	Containers: Namespaces + cgroups + UnionFS	6	70	privilege-separation (revisited), immutable infrastructure
7	Kubernetes + GitOps: ship triage	10	120	control-loops, GitOps, load-balancing, network-policy, service-discovery
	Year 1 Final Exam	2	24	—
Total		~50 weeks	~604 hrs	~15 patterns first-touched

Time budget at 12 hrs/week × 52 weeks = 624 hrs. Year 1 is fully budgeted with ~20 hrs of slack for the inevitable real-life weeks.

Phase 7 is the longest phase in Year 1 — and earns it

Phase 7 (Kubernetes + GitOps) is 10 weeks and ~120 hours, longer than any other Year 1 phase by a meaningful margin. That’s not arbitrary. Phase 7 is where the control-loop pattern gets its first deep encounter, where Tier 1 of basecamp goes live, where the first real service (triage) is deployed, and where the GitOps pattern becomes muscle memory rather than ceremony. Every subsequent year leans on these reflexes — short-changing Phase 7 means paying interest on it for the next four years.

---

What ships publicly during Year 1

Year 1 ships four OSS projects — the fluency artifacts plus the first service-on-platform. The discipline is shipping, not launching: push to GitHub, get a PR review, cut a release, move on. Launch energy is reserved for Years 2-5.

Project	Phase	Role	Launch energy
rxp	Phase 4	Regex CLI in Python — fluency artifact, later integrated as a log-pattern utility inside services/aiops/ (Y5)	Quiet ship — push to GitHub + TestPyPI; no blog post, no LinkedIn announcement
konfig	Phase 4 (stretch)	Config validator — fluency artifact, used in basecamp CI to validate Helm values	Quiet ship — same approach
pulse	Phase 5	Probe scanner in Go — fluency artifact, emits Prometheus metrics scraped by basecamp	Quiet ship — push + GoReleaser binaries
triage	Phase 7	Small on-call dashboard — the first real service-on-K3s	Quiet ship — push + Helm chart in basecamp
ops-handbook	Phase 1 onward	Runbooks, incidents, postmortems, ADRs, weekly logs	Private. Year 1 is private. Sanitized public extract is a Year 5 capstone consideration.
basecamp	Phase 7 onward	The GitOps repo declaring the platform	Private. Year 1 starts private; goes public Year 3.

The three small CLIs each get a real integration role inside basecamp’s tooling so they’re not orphaned demos — rxp feeds aiops log analysis, konfig validates Helm values in CI, pulse emits metrics into Prometheus. They earn their keep.

---

Patterns deepened in Year 1

By Year 1 end, these Pattern Library entries should be OUTLINE, with several pushed to DEEP through operating the platform across Phase 7 and beyond:

Foundations

• foundations/resource-virtualization — Phase 1
• foundations/privilege-separation — Phase 1, reinforced Phase 6
• foundations/mediation — Phase 1, reinforced Phase 7 Service
• foundations/layering-and-abstraction — Phases 1, 2, 7
• foundations/control-loops — Phase 7 (first deep encounter via K8s controllers)

Storage and data (storage-and-data/)

• write-ahead-logging — Phase 3
• lsm-vs-btree — Phase 3
• oltp-vs-olap — Phase 3 (first encounter; deepens Year 3)

Distributed systems (distributed-systems/)

• replication — Phase 3 first touch; deepens Year 2
• idempotency — Phases 3 + 5
• backpressure — Phase 5
• fault-isolation — Phases 5 + 7

Networking (networking/)

• routing-and-addressing — Phase 2
• load-balancing — Phase 7 (K8s Service)
• network-policy — Phase 7
• service-discovery — Phase 7 (K8s DNS + Service)

Infrastructure and platform (infrastructure-and-platform/)

• declarative-vs-imperative-infrastructure — Phase 7
• gitops — Phase 7

That’s ~15 patterns first-touched in Year 1. Read each entry when its phase first hits it; promote STUB → OUTLINE while the phase context is live. The pattern depth ladder is what survives the 60 months.

---

Hardware requirements

Year 1 starts on a 16GB DDR5 mini-PC with 256GB NVMe. Before Month 10 (start of Phase 7 Kubernetes), upgrade to 32GB RAM + add a 1TB external SSD — Kubernetes does not breathe at 16GB. Estimated cost: $120-140.

Full breakdown including SKUs, sourcing tips, Proxmox setup, and the multi-year hardware roadmap: homelab/hardware.

---

Year 1 Final Exam

Time: 6 hours. AI-administered via the root-exam skill (or solo with the final-exam.md scenarios).

Three parts:

1. Build (90 min) — given a fresh K3s cluster, deploy a new app via ArgoCD with all the year’s hygiene (ingress, network policy, sealed secrets, Prometheus rule).
2. Debug (180 min) — three parallel scenarios from the phase exam catalogs (likely one each from Phase 3 / 5 / 7).
3. Articulate (90 min) — ~1500 words: “Trace what happens when a request arrives at my homelab Ingress, end-to-end down to the kernel and back up. Cite the controllers, syscalls, and patterns at each step.”

See the full Year 1 Final Exam spec for the catalog, scoring rubric, and the exact pass bar.

---

Reading order

Actionable path through Year 1, in order:

1. This index — you are here. Skim once so the year’s shape is in your head.
2. The Master Plan — re-read the 5 years at a glance and the pattern-first scaffold sections; everything in Year 1 is one instance of that scaffold.
3. Phase 1: OS Foundations — the longest substrate phase; sets the pattern-first scaffold for the rest of the year.
4. Phases 2 → 7 in order — Networking, Databases, Python + rxp, Go + pulse, Containers from scratch, Kubernetes + GitOps + triage.
5. Patterns — when a phase doc first references a pattern, read its entry under patterns/ and promote STUB → OUTLINE while the phase context is live.
6. Project plans — read each project’s plan when its phase activates: rxp, konfig, pulse, triage.
7. Year 1 Final Exam — open it ~2 weeks out from end of Phase 7, not before. Reading it earlier just creates anxiety; reading it on time creates focus.

For people who already work in infrastructure: jump straight to the Year 1 Final Exam and see what the bar is. If you can already pass it, skip Year 1 and start at Year 2.

---

Year 1 graduation

You can:
- Debug any layer above the kernel from first principles
- Reason about a system in terms of patterns, not commands
- Operate a small K8s cluster with GitOps reconciliation
- Ship code with PR review, CI, releases — across two languages
- Write a runbook another engineer can follow at 3am

Exit ramp: Junior SRE / IT Engineer
Confidence: real, with shipped artifacts and ~15 OUTLINE patterns

→ Continue to Year 2: Distributed Systems & Cloud.