Computing Foundations › Systems Foundations: Storage, Observability, and Tooling › Day 42

Day 42: Section Review: Your Computing Foundations Toolkit

Day 42 of 365 — 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.

Course
Computing Foundations
Category
Systems Foundations: Storage, Observability, and Tooling
Reading time
≈ 40 min
Practical time
≈ 30 min
Lesson duration
1h 10m
Last verified
2026-07-12

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

  1. 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
  2. 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
  3. 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.
  4. 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:

Prerequisites

Why this matters


The idea in plain language

Diagram: how the six areas of the section relate to each other


Historical background

Diagram: what each layer of abstraction hides and when it leaks


What it is — and what it is not

This foundation is:

It is not:


Why it was created and what problems it solves


How it works

The six areas

Diagram: the six domains of your computing foundations as one connected system

One action, traced

Flowchart: a single action — calling an API and storing the result — traced through every layer you learned

Fetch some data from a public API and save it to a database.

  1. You type a command in the shell (8–14). The shell parses the line, expands variables and globs, and prepares to run it.

  2. 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.

  3. 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.

  4. It sends an HTTP request (22–28). A GET with an Authorization header; the server checks the key, applies rate limits, and returns JSON with a status code you can interpret.

  5. The result is stored (39). You parse the JSON and write it somewhere deliberate, having chosen the store on purpose.

  6. You can see what happened (40). Logs record the request and its status; a failure leaves a trail rather than a shrug.

  7. 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.


An everyday analogy

Diagram: how the foundation supports the work that follows

Learning to read a city.

The cityThe foundation
The buildings and roadsThe machine
Knowing how to get anywhere on footThe command line
The transport networkThe internet
The agreed way businesses tradeAPIs
Public records of who changed whatVersion control
Tools, maps and habitsThe daily craft

Examples in practice

Diagram: the ordered questions for locating a problem by layer

Diagram: the six areas of Computing Foundations as stages of one request


Implications: security, privacy, performance, scalability, and cost

Diagram: the principles that recurred across the whole section


Alternatives: free, open source, and commercial

To go deeper onFree resource
The machineComputer Systems: A Programmer’s Perspective; Nand2Tetris
The command lineThe Linux Command Line, by William Shotts
NetworkingHigh Performance Browser Networking, by Ilya Grigorik
GitPro Git, free online, and its chapter on internals
APIs and HTTPThe MDN HTTP documentation
Observability and reliabilityGoogle’s Site Reliability Engineering, free online

Diagram: how to test your own understanding of the stack

AreaThe question it answers
The machineWhat is actually executing, and with what resources
The command lineHow do I drive it directly and repeatably
The internetHow does my machine reach another one
APIsHow do programs agree to work together
Version controlWhat changed, when, by whom, and how do I undo it
The craftHow do I work well, and how do I know it is working

When to use it — and when not to

Diagram: what a foundation gives you compared with what it does not


The AI connection

Diagram: where AI systems actually fail compared with where people look


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.

AreaWhat you do
Gitgit init, a .gitignore written before the first commit
ShellA script with set -euo pipefail and an argument with a default
Network and APIcurl a public endpoint, checking the status before parsing
DataParse the JSON and store it deliberately — SQLite or a file
ObservabilityA structured log line per run, with a timestamp and an outcome
AutomationA pre-commit hook, and a crontab line to run it nightly
CraftFormat, 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

Troubleshooting

Common mistakes


Practice assignment


Extension challenge


Quiz

Q1. Course 1 taught six connected areas. Which two of them "wrap" the whole stack rather than sitting at a single layer?

  1. Git/GitHub and systems foundations
  2. The internet and public APIs
  3. The machine and the command line
  4. 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?

  1. Network connection, then shell command, then process on the machine, then storage
  2. Shell command, process, network, HTTP request, then storage
  3. HTTP request, then storage, then shell command, then the machine
  4. 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?

  1. Whether the database schema is correct
  2. Whether the git history is clean
  3. Whether the name resolves to an IP address (DNS)
  4. 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?

  1. The server is rate-limiting you; slow down
  2. The resource path is wrong; the endpoint does not exist
  3. The JSON body is malformed
  4. 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?

  1. Because everything later depends on this foundation
  2. Because Python is too hard to learn without a computer science degree
  3. Because the foundations are more important than Python and you will rarely use Python
  4. 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?

  1. Nothing — committed keys are automatically encrypted by git
  2. The key must be treated as compromised and rotated
  3. Delete the whole repository and start over
  4. 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?

  1. Only the choice of programming language matters for speed
  2. Slow runs are always caused by a git merge conflict
  3. Memory and storage — slow systems usually wait on data
  4. 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?

  1. Immediately rewrite the whole program from scratch
  2. Retype the failing command repeatedly until it works
  3. Assume the tool is broken and switch to a different one
  4. 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


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.