Web and Internet Foundations

• Internet - how local networks, routers, ISPs, and addresses form the infrastructure that carries Internet services.
• Domain names and DNS - how human-readable names are connected to machine-routable addresses.
• HTTP - how browsers and servers exchange requests and responses on the Web.
• Cross-Origin Resource Sharing - how browsers decide whether script from one origin may read a response from another origin.

Programming and Software Design

• Maintainable code principles - how visible intent, local dependencies, proportional abstraction, and verification make code easier to change.
• System design review - how to trace requirements through architecture, data, quality attributes, operations, cost, and migration.
• Algorithmic problem-solving practice - how reusable problem shapes, progressive exercises, explanation, and deliberate review build algorithmic skill.
• Rust language basics - how Rust uses typed expressions, immutable bindings, control flow, structs, and enums.
• Rust ownership and borrowing - how moves and references make responsibility for values explicit.
• Rust project workflow - how rustup and Cargo support the project feedback loop.
• Functional programming core - how pure transformations, immutable data, composition, and explicit effects fit together.
• Functional programming learning map - how to progress from foundational transformations to types, effects, and production systems.

Distributed Systems

• Distributed systems - when a program stops being a single application and starts depending on communication between machines.
• Distributed systems learning map - how small services, injected failures, queues, replication, and design reading form a practical learning sequence.
• Unreliable networks - why a remote call can fail after the caller has already lost the ability to know what happened.
• Latency-aware remote calls - why replacing local calls with remote calls changes the shape of a design.

Complex Systems

• Complex systems learning map - how dynamical change, chaos, emergence, and simulation fit into an experimental learning path.

Cloud Infrastructure

• Cloud computing - how on-demand resources and service models move the infrastructure responsibility boundary.
• Cloud regions and zones - how geographic placement affects latency, failure isolation, and data residency.
• Cloud resource hierarchy and IAM - how principals, roles, hierarchy, and inheritance combine into access policy.
• Virtual private clouds - how address ranges, routes, subnets, and firewall rules form an isolated cloud network.
• Choosing cloud data storage - how data shape, queries, transactions, scale, and access frequency guide storage choice.
• Kubernetes desired state - how Pods, Deployments, Services, and reconciliation keep container workloads running.
• Serverless compute - how requests and events trigger managed, automatically scaled application code.

Containers and Local Environments

• Containerized local tools - how to run a development tool from a container while exposing ports and preserving file ownership.
• Docker volumes and bind mounts - how to choose between Docker-managed storage and a host directory exposed inside a container.
• Nix package manager - how Nix use grows from installing packages into reproducible shells, profiles, flakes, and machine configuration.
• Nix language basics - the small expression language underneath Nix packages, shells, and derivations.
• Nix flakes - how flake-based projects expose reproducible outputs for builds, installs, and configuration.

Security

• Security testing practice platforms - where to find controlled environments for practicing security testing under explicit platform rules.

Generative AI

• Prompt engineering - how explicit goals, context, constraints, examples, and verification make model-assisted work more inspectable.

Development Workflow

• Terminal multiplexers - how pane splitting and copy mode change the relationship between a terminal, shell, and long-running work.
• Git interactive rebase - how to squash local commits before sharing history.
• Release automation checklist - how tags, signing secrets, SBOM generation, and verification fit together in a release.
• Programming font ligatures - what editor ligatures change and how font choice differs from the ligature toggle.

Reading, Learning, and Writing

• Iterative study cycles - how focused cycles, practical evidence, reflection, and replanning make a long learning roadmap adjustable.
• Clear writing structure - how document organization, paragraph roles, and meaningful transitions help a reader follow an explanation.
• St. John’s Great Books curriculum - how an interdisciplinary reading list becomes a four-year sequence rather than a pile of independent recommendations.

New sources may create several pages or improve existing pages. Organize this index around durable questions and concepts rather than around source titles.