Arc 1 of /root. The foundations every later year rests on. ~8 phases that turn “someone who wants to ship software” into “someone who can ship software with confidence.” Exit ramp: Junior Software Engineer

Arc 1 is the ground floor of /root. There’s no basecamp tier alive yet, no Kubernetes, no cloud, just you, your dev environment, two languages, and the engineering judgment that lets you ship working code. Everything in Years 2-5 (backend services, the platform, the data tier, the ML stack, AI infrastructure) assumes you can read code, write code, test code, and reason about why code does what it does without freezing.

The shape of the year is deliberate. Phase 1 makes the developer’s machine itself legible: Linux as your daily substrate, not a mystery. Phases 2-4 install programming fluency: Python first (the lingua franca of glue + ML), data structures and algorithms in the middle (the practical subset, not competitive programming), Go after (the lingua franca of cloud-native infra). Phase 5 is where code stops being syntax and starts being decisions: DDD, clean architecture, hexagonal, repository. Phases 6-7 add the engineering hygiene that separates mid from senior: profiling, memory, testing patterns. Phase 8 closes Arc 1 with Git, CI/CD, and the release-engineering muscle that makes your code shippable.

By end of Arc 1 you’ve shipped two small CLIs publicly: sift (Phase 2 Python) and pulse (Phase 4 Go), both with tests, CI, releases, and the kind of README another engineer can pick up. You’ve internalized at least one of the canonical architecture patterns. You can profile a slow function and explain why it’s slow. You write tests before they hurt. Your Git workflow is something a senior engineer would recognize as professional. The exit is Junior Software Engineer, and the engineer who will operate Arc 3’s platform is already being built.

:::tip[Why “fluency, not mastery” for Python and Go] Arc 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 2-5, when you operate complex systems written in these languages: backend services, ascent, prism, warden. Arc 1 buys the right to learn those without language friction. :::

What you’ll know at the end of Arc 1

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

• Linux as a daily substrate: shell fluency, processes, file system, permissions, package management. You can navigate any Linux box without notes and explain what each layer does.
• Python fluency: basics through OOP through async through packaging. You’ve shipped a real CLI (sift) with tests, CI, and a public release.
• Go fluency + concurrency: basics through goroutines + channels + context. You’ve shipped a real CLI (pulse) with cross-platform binaries.
• Data structures & algorithms at practical depth: arrays, hashmaps, trees, graphs, BFS/DFS, sorting, big-O reasoning applied to real code. Not competitive programming; the subset a backend engineer actually uses.
• Software architecture patterns: DDD, clean architecture, hexagonal, repository. You can argue trade-offs across them and recognize them in any codebase you read.
• Performance, profiling & memory: you can profile a hot path, identify the actual bottleneck, and articulate the fix. You know the difference between heap, stack, and arena allocators.
• Testing patterns: unit, integration, property-based. You’ve written tests that caught real bugs.
• Git + CI/CD + release engineering: feature-branch workflows, conventional commits, semantic versioning, CI pipelines that gate merges, releases that produce versioned artifacts.

You’ll be able to read any backend codebase, write a useful tool in either language in an afternoon, and ship it with the hygiene of a professional engineering team.

Phase map

The total content is the 8 phases. Pace is yours; some phases move quickly, others deepen with operating time.

What ships publicly during Arc 1

Arc 1 ships two OSS CLIs, the fluency artifacts. The discipline is quiet ship: push to GitHub, get a PR review if you can, cut a release, move on. Launch energy is reserved for later years.

The two CLIs each get a real integration role inside basecamp’s tooling later (sift feeds warden log analysis, pulse emits metrics into Prometheus), so they’re not orphaned demos. They earn their keep over the program’s full arc.

Patterns deepened in Arc 1

By Arc 1 end, these Pattern Library entries should be OUTLINE:

Foundations

• shell-fluency: Phase 1
• file-system-as-namespace: Phase 1
• processes-and-permissions: Phase 1

Programming

• interpreted-runtime: Phase 2
• packaging-and-dependency-management: Phase 2
• csp-concurrency: Phase 4 (goroutines + channels)
• errors-as-values: Phase 4 (Go’s approach)
• structural-typing: Phase 4

Algorithms and complexity

• algorithmic-complexity: Phase 3
• hash-tables-as-pattern: Phase 3
• tree-traversals: Phase 3
• graph-search: Phase 3

Architecture

• domain-driven-design: Phase 5
• clean-architecture: Phase 5
• hexagonal-and-ports-and-adapters: Phase 5
• repository-pattern: Phase 5

Engineering hygiene

• profiling-as-practice: Phase 6
• test-pyramid: Phase 7
• property-based-testing: Phase 7
• release-engineering: Phase 8

That’s ~18-20 patterns first-touched in Arc 1. Read each entry when its phase first hits it; promote STUB to OUTLINE while the phase context is live.

Hardware requirements

Arc 1 needs a development machine. Your laptop is fine; a small mini-PC (16GB DDR5 + 256GB NVMe) works too. The homelab proper doesn’t get exercised hard until Arc 3 (Kubernetes), so Arc 1’s hardware budget is minimal: anything that runs a modern Python and Go toolchain comfortably is sufficient.

Full breakdown including hardware roadmap across all 5 years: homelab/hardware.

Arc 1 Final Exam

Scenario-based final exam.

Three parts:

1. Build (120 min): ship a new small CLI from scratch: takes JSON-Lines on stdin, filters by a CEL-like expression, emits to stdout. Tests, type checking, README, semantic versioning, CI workflow.
2. Debug (180 min): three parallel scenarios from the phase exam catalogs (one each from Phase 2 / 4 / 6).
3. Articulate (90 min): ~1500 words: “Walk through what happens when a Python HTTP request executes from requests.get(url) to the bytes on the wire. Cover the TCP socket, the SSL handshake, the HTTP framing, the response parsing. Cite the patterns at each layer.”

See the full Arc 1 Final Exam spec for the scoring rubric and exact pass bar.

Reading order

1. This index: you are here. Skim once.
2. The Master Plan: re-read the 5 years at a glance section so Arc 1’s role in the arc is in your head.
3. The Capstone: re-read so you know what Arc 1 is feeding into.
4. Phase 1: Linux as a Developer: start here.
5. Phases 2 to 8 in order: Python, DSA, Go, Architecture, Performance, Testing, Git/CI/CD.
6. Patterns: as a phase references one, read its entry under patterns/ and promote STUB to OUTLINE while the context is live.
7. Project plans: sift when Phase 2 activates; pulse when Phase 4 activates.
8. Arc 1 Final Exam: open ~2 weeks before end of Phase 8. Earlier creates anxiety; on time creates focus.

For people who already write production code daily in Python or Go: skim Phases 2 and 4 quickly; spend your time on Phase 5 (Architecture) and Phase 6 (Performance) where the senior delta lives.

Arc 1 graduation

You can:
- Operate Linux as your daily substrate without notes
- Read and write Python idiomatically
- Read and write Go idiomatically, including concurrency
- Reason about algorithmic complexity in real code
- Apply software architecture patterns (DDD, clean, hexagonal) deliberately
- Profile a slow function and articulate the fix
- Write tests that catch real bugs (unit, integration, property-based)
- Ship code with proper Git workflows, CI, semantic versioning, releases

Exit ramp: Junior Software Engineer
Confidence: real, with two shipped CLIs and ~18-20 OUTLINE patterns

→ Continue to Arc 2: Backend Engineering.