Computing Foundations › Systems Foundations: Storage, Observability, and Tooling › Day 42
Day 42: Section Review: Your Computing Foundations Toolkit
After this lesson you will be able to see the six areas of Course 1 as one connected stack, trace a real action through every layer, honestly assess your own strengths and gaps, and know exactly which earlier day to revisit for each weakness — a solid foundation to build Python and everything after on.
Hands-on lab for this lesson
Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/computing-foundations/day-042-section-review-your-computing-foundations-toolkit
- Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git cd ai-roadmap-365.github.io - Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path — section / subsection / week / day:
cd labs/sections/computing-foundations/day-042-section-review-your-computing-foundations-toolkit - Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work — read it before running anything.
- Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
bash tests/run_tests.sh # or the test command named in the lab README
You can also open the lab as a local page (works offline, shows the file tree and expected output).
Learning objectives
By the end of this lesson you will be able to:
- Consolidate the six areas of Course 1 (the machine, the command line, the internet, APIs, git and GitHub, and systems foundations) into a single mental model of the computing stack
- Trace one concrete action — calling an API and storing the result — through every layer you learned, naming what happens at each step
- Explain how the two wrapping domains, version control and systems tooling, apply at every layer rather than at one
- Self-assess your confidence across all six areas and identify the specific earlier day to revisit for each weakness
- Diagnose a failed request by naming the layer it lives in, using the right Course 1 concept at each step
- Explain how this foundation makes Python and everything after (data, machine learning, deployment) comprehensible rather than magical
- Run a toolkit check on your own machine that confirms the core Course 1 tools and cross-section skills are present and ready
Prerequisites
- Days 1-41 of this section — this review consolidates all of them
- A computer running macOS, Linux, or Windows with a terminal, git, and python3 available
Why this matters
-
Six weeks of separate topics are one system, and today is where that becomes visible.
-
You can now trace any action through the stack and know, at each step, what is happening and how to look inside it.
-
That is the difference between a foundation and a pile of facts.
-
Everything after this course assumes all of it — the next courses will not re-explain a process, a request or a commit.
-
The gaps you find today are cheap to close now and expensive to discover later.
The idea in plain language
-
Six areas, one system. The machine, the command line, the internet, APIs, version control, and the daily craft.
-
The first four stack on each other. Each one runs on the layer below.
-
The last two wrap the whole thing, because you version, observe and automate at every layer.
-
One ordinary command touches nearly all of them in the space of a heartbeat.
-
Understanding means being able to look inside each step, not being able to recite it.
Historical background
-
Each layer was invented to hide the one below it, and each took decades.
-
The stored-program machine, the operating system, the shell, the network, the protocol, the API — every one of them exists because the layer beneath was too hard to use directly.
-
That is the through-line of the whole course. Abstraction is not a programming technique; it is how the entire field made progress.
-
The layers leak, which is why you learned them. A slow query, a certificate error, an out-of-memory kill — each is a lower layer becoming visible.
-
Nothing here is new. The oldest ideas in this course are from the 1960s and 70s, and you will use them unchanged for your whole career.
-
What changes is the top. Frameworks and models turn over constantly; the foundation does not.
What it is — and what it is not
This foundation is:
- A model of how computation, communication and collaboration actually work.
- Durable. Almost none of it will be obsolete in ten years.
- The thing that makes debugging possible, because you know where to look.
It is not:
-
Not complete. It is a foundation, and the point of a foundation is what gets built on it.
-
Not memorised. You will look things up forever, and that is correct. What you have is the map, not the contents.
-
Not the interesting part. It is what makes the interesting part possible.
-
Not a substitute for building things. Six weeks of understanding needs a project to become skill.
Why it was created and what problems it solves
-
Debugging requires a model. Without one, every problem is equally mysterious and you change things at random.
-
AI work sits on all of it. A training job is a process, reading files, over a network, from an API, versioned in Git, watched by logs.
-
The failures are almost never in the model. They are in the data path, the environment, the permissions, the version, the network.
-
Reading other people’s work requires the vocabulary. Every README assumes this course.
-
Judgement needs foundations. Knowing which store, which workflow, which retry policy is not a lookup; it follows from understanding the trade-offs.
How it works
The six areas
-
The machine (days 1–7) is at the centre: transistors, fetch-decode-execute, the memory hierarchy, binary, and the operating system scheduling it all. Everything else runs on this.
-
The command line (days 8–14) wraps it: navigating the filesystem, transforming text with pipes, environment variables, scripting. The shell is the hinge between you and everything else.
-
The internet (days 15–21) is how your machine talks to other machines: DNS to find them, TCP and ports to connect, HTTP and TLS to exchange,
curlto inspect. -
APIs (days 22–28) are how programs talk to each other: REST, JSON, authentication, and the realities of rate limits, pagination and errors.
-
Git (days 29–35) tracks every change: commits, branches, merges, remotes, review, and the ability to undo almost anything.
-
The daily craft (days 36–41): an editor, debuggers and linters, regular expressions, storage choices, observability, and automation.
-
The last two are not on top of the stack. They wrap the whole thing, because you version and observe and automate at every layer.
One action, traced
Fetch some data from a public API and save it to a database.
-
You type a command in the shell (8–14). The shell parses the line, expands variables and globs, and prepares to run it.
-
It runs as a process (1–7). The kernel loads it, gives it memory and a slice of CPU, and it executes — Day 1’s cycle, now running your program.
-
It opens a network connection (15–21). DNS resolves the name, TCP opens a connection, TLS encrypts it. All of Week 3 fires here, in a fraction of a second.
-
It sends an HTTP request (22–28). A
GETwith anAuthorizationheader; the server checks the key, applies rate limits, and returns JSON with a status code you can interpret. -
The result is stored (39). You parse the JSON and write it somewhere deliberate, having chosen the store on purpose.
-
You can see what happened (40). Logs record the request and its status; a failure leaves a trail rather than a shrug.
-
All of it is versioned and automated (29–35, 41). The script is in a repository, a commit records the change, and a hook or pipeline could run it on a schedule.
- One command. Seven lessons, five of the six areas, in a heartbeat.
- Before this course that was one opaque event — “the program got the data”. Now it is a sequence of layers you can look inside.
An everyday analogy
Learning to read a city.
| The city | The foundation |
|---|---|
| The buildings and roads | The machine |
| Knowing how to get anywhere on foot | The command line |
| The transport network | The internet |
| The agreed way businesses trade | APIs |
| Public records of who changed what | Version control |
| Tools, maps and habits | The daily craft |
-
A tourist follows directions. A resident understands the layout and can find a way when the directions are wrong.
-
You are not expected to know every street. You are expected to know how streets work, so an unfamiliar one is navigable.
-
The city keeps changing at street level and almost never at the level of how a city works.
Examples in practice
-
“The training job died.” Exit code 137 — the kernel killed it for memory (Day 7).
-
“The API is slow.” Time the four phases and find out whether it is DNS, TLS or the server (Days 15, 21).
-
“It works on my machine.” Compare
PATH, the environment and the versions (Days 11, 13). -
“Permission denied.” Read the ownership and the mode bits (Day 9).
-
“Nobody can reproduce the result.” No commit hash was recorded with it (Days 29, 35).
Implications: security, privacy, performance, scalability, and cost
-
Security ran through every week, and the same rule kept appearing: a secret that reaches a permanent place is compromised, and revocation is the only real remedy.
-
The layers where secrets leak — the environment, a URL, a commit, a log, a metric label, a copied command — are each a lesson you have now had.
-
Privacy: your data path is now visible to you. You know where personal data can land, which is what makes retention a decision rather than an accident.
-
Performance: almost every “slow” has a layer. Compute, memory, disk, network, or waiting. Naming the layer is most of the fix.
-
Cost: the recurring shape is that the expensive mistake is silent. A failed cron job, an unpinned dependency, a cache with no expiry, a retry with no cap.
-
The cheapest control is always the earliest one, which is the argument the whole final week was making.
Alternatives: free, open source, and commercial
| To go deeper on | Free resource |
|---|---|
| The machine | Computer Systems: A Programmer’s Perspective; Nand2Tetris |
| The command line | The Linux Command Line, by William Shotts |
| Networking | High Performance Browser Networking, by Ilya Grigorik |
| Git | Pro Git, free online, and its chapter on internals |
| APIs and HTTP | The MDN HTTP documentation |
| Observability and reliability | Google’s Site Reliability Engineering, free online |
-
Every one of these is free and excellent, and each goes a layer deeper than this course could.
-
Read one, not six. Depth in one area teaches the habit of depth, which transfers.
Comparison with related concepts
| Area | The question it answers |
|---|---|
| The machine | What is actually executing, and with what resources |
| The command line | How do I drive it directly and repeatably |
| The internet | How does my machine reach another one |
| APIs | How do programs agree to work together |
| Version control | What changed, when, by whom, and how do I undo it |
| The craft | How do I work well, and how do I know it is working |
When to use it — and when not to
-
Use the layer model whenever something is wrong. Name the layer before changing anything.
-
Use the cheapest diagnostic first.
dig,curl -v,git status,ls -l— all read-only, all instant. -
Reach for a lower layer only when the one above does not explain it. Most problems are one layer down, not five.
-
Do not try to hold it all in your head. Hold the map; look up the contents.
-
Do not stop here. A foundation with nothing built on it decays quickly, and the next course starts immediately.
-
Do not skip the review. The gaps you find today cost minutes; the same gaps found during a deadline cost days.
The AI connection
-
A training run is every layer at once: a process, with memory limits, reading files over a network, from an API, in a versioned repository, watched by logs.
-
AI failures are rarely in the model. They are in the data path, the environment, the permissions, the version, or the network — every one of which you now understand.
-
Reproducibility is a foundations problem, not a modelling one. Commit, config, data version, and a recorded hash.
-
Cost control is a foundations problem too: caching, batching, retry caps and spend limits, all of which you met before any model did.
-
The next courses build on this without re-explaining it. That is the point of a foundation, and it is why the gaps matter now.
Knowledge check
quiz:
question: "A training job runs fine locally and is killed on a server with no traceback, logging only exit code 137. Which layer should you examine first?"
options:
- "Memory — 137 is 128 + 9, meaning the kernel sent SIGKILL, typically for exceeding a memory limit"
- "The network, since the job may have lost its connection to the data source"
- "Permissions, since the server user may lack access to the output directory"
- "The Python environment, since a missing dependency would terminate the process"
answer_index: 0
explanation: "SIGKILL cannot be caught, so no cleanup runs and no traceback is written — which is exactly why the log simply ends. The number itself names the layer: this is the operating system reclaiming memory, not anything about the model or the code."
Hands-on exercise
Build one small thing that uses every area. Worked through fully in the Day 42 lab directory.
| Area | What you do |
|---|---|
| Git | git init, a .gitignore written before the first commit |
| Shell | A script with set -euo pipefail and an argument with a default |
| Network and API | curl a public endpoint, checking the status before parsing |
| Data | Parse the JSON and store it deliberately — SQLite or a file |
| Observability | A structured log line per run, with a timestamp and an outcome |
| Automation | A pre-commit hook, and a crontab line to run it nightly |
| Craft | Format, lint, and a commit message that says why |
Expected output
{"ts":"2026-08-31T09:00:04Z","event":"fetch_ok","records":142,"ms":318}
$ sqlite3 data.db "SELECT COUNT(*) FROM records;"
142
$ git log --oneline
7c3d9a1 feat: store fetched records in sqlite
9f1b2e8 chore: add pre-commit hook and gitignore
Validate your work
- The script exits non-zero when the request fails, and you tested that path
- No credential appears anywhere in the repository
- Each run appends one structured, queryable log line
- The hook rejects a commit it should reject
- You can trace your own command through all seven steps of the journey above
-
bash tests/run_tests.shreports 0 failures
Troubleshooting
- Anything that goes wrong here is a lesson from this course. Name the layer first.
command not foundunder cron — Day 14. A parse error on an error page — Day 28.Permission denied— Day 9.- The hook does not fire. Day 35: name, location, execute bit.
- The log is unqueryable. Day 40: fields, not sentences.
Common mistakes
-
Skipping the review because it feels like repetition. It is the pass where gaps surface.
-
Building nothing. Understanding without a project does not become skill.
-
Assuming the next course will re-explain this. It will not.
Practice assignment
-
Rate yourself on each of the six areas, honestly, and pick the two weakest.
-
Re-do one lab from each weak area without looking at the solution.
-
Trace a real action you perform daily through all seven steps, and note every step you could not explain.
-
Write the whole section’s map from memory, then compare it with the diagram. What is missing is what to revisit.
Extension challenge
-
Build something small and complete that uses all six areas and runs unattended: fetch, store, log, version, schedule, and alert on failure. That project is the real exit exam for this course.
-
Explain the request journey to someone else without notes. Teaching it is the fastest way to find the steps you only half know.
-
Go one layer deeper in your weakest area, using one of the free resources above, for a week.
-
Come back to your Day 1 notes and read them now. The distance is the measure of the six weeks.
Quiz
Q1. Course 1 taught six connected areas. Which two of them "wrap" the whole stack rather than sitting at a single layer?
- Git/GitHub and systems foundations
- The internet and public APIs
- The machine and the command line
- The command line and the internet
Show answer
Answer: A. Git/GitHub and systems foundations
You version, observe, and automate at every layer, so git/GitHub (days 29-35) and the systems foundations (days 36-41) wrap the entire stack instead of occupying one layer of it.
Q2. When you trace "fetch data from an API and save it to a database" through the stack, in which order do the layers engage?
- Network connection, then shell command, then process on the machine, then storage
- Shell command, process, network, HTTP request, then storage
- HTTP request, then storage, then shell command, then the machine
- Storage, then the API, then the network, then the shell
Show answer
Answer: B. Shell command, process, network, HTTP request, then storage
You type a command in the shell (8-14); it runs as a process on the machine (1-7); the process opens a network connection (15-21); it sends an HTTP request to the API (22-28); then the result is stored (39). The action moves from your keyboard down and out through the layers.
Q3. A script reports it cannot connect to a host. Following the Course 1 foundation, what is the first layer to check?
- Whether the database schema is correct
- Whether the git history is clean
- Whether the name resolves to an IP address (DNS)
- Whether the code has a linter warning
Show answer
Answer: C. Whether the name resolves to an IP address (DNS)
Cannot-connect problems are networking problems first. You check name resolution (DNS, Day 16), then the connection and port (Day 17), then the HTTP status (Day 18) — naming the layer before touching the code.
Q4. An HTTP response comes back with status 401 when your script calls an API. What does the foundation tell you it most likely means?
- The server is rate-limiting you; slow down
- The resource path is wrong; the endpoint does not exist
- The JSON body is malformed
- Your API key is missing or invalid
Show answer
Answer: D. Your API key is missing or invalid
A 401 is an authentication failure (Day 25): the key or token is wrong or missing. A 429 would be a rate limit (Day 27) and a 404 a wrong resource path (Day 23) — knowing the status codes turns a vague failure into a precise fix.
Q5. Why does this course teach six weeks of foundations before you write a single line of Python?
- Because everything later depends on this foundation
- Because Python is too hard to learn without a computer science degree
- Because the foundations are more important than Python and you will rarely use Python
- Because employers require a certificate in each area before hiring
Show answer
Answer: A. Because everything later depends on this foundation
The foundation is a dependency for everything ahead: learn the shell, HTTP, git, and debugging first and their Python equivalents become obvious rather than magical. The ordering removes magic from the rest of the course.
Q6. A teammate accidentally committed an API key to a shared repository. Drawing on the git and API weeks, what must happen?
- Nothing — committed keys are automatically encrypted by git
- The key must be treated as compromised and rotated
- Delete the whole repository and start over
- Only make the repository private; the key is then safe
Show answer
Answer: B. The key must be treated as compromised and rotated
A secret in version control should be assumed exposed (Days 25, 30): rotate/revoke the key with the provider and remove it from the tracked files. Making a repo private later does not undo the exposure — the key must be rotated.
Q7. Your program runs slowly even though the CPU is barely busy. Which Course 1 ideas best explain where to look?
- Only the choice of programming language matters for speed
- Slow runs are always caused by a git merge conflict
- Memory and storage — slow systems usually wait on data
- The regular-expression engine is the only possible bottleneck
Show answer
Answer: C. Memory and storage — slow systems usually wait on data
Slow-but-idle usually means waiting, not computing: the memory hierarchy (Day 3), storage choices (Day 39), and network round trips (Days 15-17) are the usual culprits, and observability (Day 40) is how you find the actual slow layer instead of guessing.
Q8. What is the single most valuable habit to carry out of Course 1 when something breaks?
- Immediately rewrite the whole program from scratch
- Retype the failing command repeatedly until it works
- Assume the tool is broken and switch to a different one
- Name the layer the problem lives in before touching anything
Show answer
Answer: D. Name the layer the problem lives in before touching anything
The foundation turns confusion into a plan: asking "which layer is this?" narrows a vague failure to a specific area with its own tools and concepts, which is the fastest route to a real fix.
Glossary
- computing foundation
- The durable, portable body of knowledge about how software systems work — the machine, the network, and the workflow — that sits beneath any specific language or framework and changes only slowly.
- the stack
- The layered set of technologies an action passes through, from your keyboard down through the machine, out across the network, into an API, and back — understood here as one connected whole rather than separate topics.
- command line
- The shell and terminal you use to drive the machine directly, composing small tools with pipes; the hinge between you and every other tool in the section (days 8-14).
- memory hierarchy
- The layered arrangement of storage from fast, small registers and cache through RAM to slow, large disk, which explains why systems that outgrow fast memory slow down (day 3).
- DNS
- The Domain Name System, which resolves a human-readable host name to an IP address — the first layer to check when a program cannot connect (day 16).
- HTTP status code
- The number a server returns with a response that tells you what happened: for example 401 (authentication failed), 404 (resource not found), or 429 (rate limited) — days 18, 23, 25, 27.
- REST API
- A style of interface where programs exchange data over HTTP using resources and verbs, most often carrying JSON; how programs talk to each other over the internet (days 22-24).
- version control
- Tracking every change to your work with git so you can commit, branch, merge, share, and undo almost anything — a domain that wraps the whole stack (days 29-35).
- observability
- The practice of seeing what a running system is doing through logs, metrics, and traces, so you can find the layer where a problem lives instead of guessing (day 40).
- automation
- Making repeatable work run itself with scripts, hooks, and pipelines, so tasks like formatting, linting, testing, and scheduled jobs happen without manual effort (days 12, 14, 41).
- self-assessment
- An honest rating of your own confidence across the six areas, used to find your weakest area and the specific earlier day to revisit — a repair map rather than a grade.
- readiness report
- The output of the toolkit-check lab: a summary of which core Course 1 tools and cross-section skills are present on your machine, mapping each to the day that taught it.
Sources and further reading
- The Missing Semester of Your CS Education — MIT (accessed 2026-07-12) — The closest companion to this section: shell, editors, git, debugging, and automation taught as one practical toolkit.
- Pro Git — Chacon & Straub (accessed 2026-07-12) — The definitive free reference for consolidating the git week (days 29-35).
- The Linux Command Line — William Shotts (accessed 2026-07-12) — A thorough, beginner-friendly deep dive to firm up the command-line weeks.
- MDN Web Docs — Learn web development — MDN Web Docs (accessed 2026-07-12) — Authoritative, current material to deepen the internet and API weeks (days 15-28).
- Crash Course Computer Science — PBS Digital Studios (accessed 2026-07-12) — A fast visual re-run of the machine layer (days 1-7) if that is your soft spot.
Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.