VCA-FND-102: Python and Automation, Course Outline (v0.1)

Foundation Stream, Belt 1. Sequel to FND-101. No hardware kit required. ~125 hours total across 14 weeks plus a presentation week. Audience: students who have a model of the machine and are ready to give it instructions.

Course mission

FND-101 gave you a model of the machine. FND-102 gives you a language to command it.

The course teaches Python 3 as a professional tool. Specifically, as an automation language: a way to make the computer do repetitive or tedious work that would otherwise cost the student hours. By the end of week 14, every student has built at least six working command-line tools, debugged them, written tests for them, documented them in READMEs, and submitted them through pull requests on Git. Each student also chooses one automation problem from their own life and ships it as a capstone.

The north star: "A student who finishes FND-102 reaches for Python the way a carpenter reaches for a tape measure. Not as a project, but as the default tool for any task that involves repeated, structured work."

The course is not a survey of the Python language. It is a workshop in the discipline of building, testing, and shipping small CLI tools. The language is the medium; the discipline is the point.

Who this course is for

• Students who completed FND-101 and want a language to drive the model they just built
• Career changers who learned a little Python from a tutorial and want a deliberate, project-by-project course
• Homeschool students at years 10-12 with comfortable computer literacy
• Anyone preparing for SEC-101, NET-101, PEN-101, CSA-101, or any later academy course (Python is the academy's lingua franca)

You DO need FND-101 or equivalent: comfortable shell use, Git basics, hex-dump literacy, and the patience to work through problems by hand before reaching for tools.

You do NOT need prior Python experience. The course starts from print('hello, world') and reaches pytest + argparse + requests in 14 weeks. Students with prior Python may move through weeks 1-3 faster; the lab work still rewards careful attention.

Where FND-102 sits in the pipeline

Prerequisite for this course: FND-101 (Digital Foundations).

What FND-102 gates (you should take these next, in any order or in parallel):

• SEC-101 (Cybersecurity Principles). The argparse + logging discipline from Labs 6 and 9 is what SEC-101 expects when students compose forensic-analysis pipelines and incident-response automations.
• NET-101 (Networks and Packet Analysis). The HTTP + JSON work in Lab 12 anticipates NET-101's Wireshark and scapy work; the regex skills from Lab 7 return for log-pattern analysis.
• PEN-101 (Intro to Penetration Testing). The CLI-tool-building discipline from the capstone is the practitioner habit PEN-101 builds on; many of PEN-101's offensive scripts begin life as FND-102-style tools.
• CSA-101 (Computer Systems Architecture I). CSA-101's entire toolchain (assembler, linker, VM translator, compiler) is written in Python. Students who internalised Lab 13's pytest discipline ship higher-quality CSA-101 toolchain code; the pdb debugging from Lab 9 returns at scale in CSA-101 Ch 9 (compiler frontend) where parser recursion makes print-debugging impractical.
• HW-101 (Electronics and Microcontrollers). The subprocess + serial-port automation from Lab 9 is structurally similar to the MCU-flashing workflows in HW-101; same Linux and Git habits.
• AI-101 (Intro to AI for Security). Python is the default language for AI work; the standard-library fluency from weeks 5-7 is the floor.

This is the single highest-impact course in the academy's foundation stream. Six downstream courses assume FND-102 fluency.

What you will know at the end

After completing FND-102, you will be able to:

Python language (Bloom: Remember / Understand / Apply):

• State Python 3's seven primitive types, the mutability rules for the four standard collection types, the difference between == and is, and the exit-status convention (0 success, nonzero failure)
• Explain why Python is dynamically typed, why list and dict mutation is a different operation from rebinding, why try / except exists as a control-flow primitive, and why --help is part of a tool's user experience rather than a comment
• Read and write Python 3 syntax fluently: variables, types, control flow, functions, modules, list / dict / tuple / set comprehensions

Structured data (Apply):

• Use lists, dictionaries, tuples, and sets confidently for the data shapes they fit
• Serialize and deserialize JSON and CSV with encoding and line-ending awareness

Standard library for automation (Apply):

• Use os, pathlib, subprocess, argparse, json, csv, re, datetime, hashlib, logging
• Use requests to read public HTTP APIs

Version control (Apply):

• Use git daily: clone, branch, stage, commit, push, pull, merge, resolve a simple conflict
• Open pull requests against the instructor as reviewer

Debugging (Analyze):

• Read a Python traceback root-up
• Add targeted print-debugging; use pdb; isolate a minimal reproducer; explain the bug in one paragraph before fixing it

Testing and documentation (Apply / Synthesize):

• Write pytest tests for the happy path, the obvious edge cases, and one regression test for a bug you found
• Write a README that lets a stranger run your tool without asking you a question

Capstone (Synthesize / Create):

• Compose an automation tool of your own design with an argparse interface, README, three or more unit tests, a multi-commit Git history, and a five-minute demo plus Q&A

Course shape

The course is fourteen working weeks plus a presentation block; the public catalog cites "P14W" for that reason. Students typically run the presentation block in the same week as their final scope-check meeting.

Per-week time budget

The course averages ~9 hours per week across 14 weeks. Most weeks use this shape:

14 weeks at ~9 hr = ~126 hr (close to the published ~125 hr; minor variation per cohort pace). Per the academy session-table framework, each session is independently schedulable: cohorts may do two short lectures on different days, or one 100-minute lecture with a break.

Weeks that vary from the standard shape:

• Week 8 (midterm) replaces lab with a 2-hour proctored practical exam. Independent practice halves; reading is exam preparation.
• Week 14 (capstone workshop) weights lab time toward 1-on-1 scope-check meetings. Independent practice rises to ~6 hr for capstone work.
• Capstone presentation block is a single ~3-hour session outside the per-week budget. Students present in 5-minute slots plus Q&A.

Anchor reading

The academy's foundational-anchor convention is track-specific: CSA tracks weave Petzold CODE; FND-102's track is Python pedagogy. The course uses three primary anchors, all freely available or stocked in the academy library, plus targeted peer-curriculum cross-references.

Primary (track-foundational)

1. Eric Matthes, Python Crash Course, 2nd edition (No Starch Press, 2019). ISBN 978-1-59327-928-8. The most widely-adopted general-purpose Python introduction; cited as a primary text by community colleges, bootcamps, and self-taught learners. Available in the academy library; consult incoming_files/master-library-anchors.md for the read-in-place path. FND-102 maps lecture weeks to Matthes chapters in the per-week reading lists; chapter-topic cross-references only (no direct verbatim quotations, since this edition's text extraction in our library copy is unreliable for verbatim grep-verification).

2. Al Sweigart, Automate the Boring Stuff with Python, 2nd edition (No Starch Press, 2019). Free online at https://automatetheboringstuff.com/2e/chapter0/ (chapter-by-chapter HTML). The canonical book-length argument that Python is an automation language for everyone, not just programmers. FND-102 cites Sweigart for the "why automate?" framing in week 1, the file-I/O patterns in week 5, the regex-as-text-tool framing in week 7, and the os + pathlib examples throughout. Direct quotations to Sweigart are pulled from his companion book Cracking Codes with Python (in the academy library, fully grep-verified) where the same author's voice is reproducible.

3. Allen B. Downey, Think Python: How to Think Like a Computer Scientist, 2nd edition (Green Tea Press / O'Reilly, 2015). Free online at https://greenteapress.com/wp/think-python-2e/. The cleanest small-form Python textbook; ~24 chapters of progressive language coverage. FND-102 uses Downey selectively when his explanation of a concept (recursion, mutability, exceptions) is the cleanest in print.

Secondary (academy-library, fully grep-verifiable)

4. Al Sweigart, Cracking Codes with Python (No Starch Press, 2018). ISBN 978-1-59327-822-9. In the academy library (calibre id 243). Used for week 11 (hashing + cryptographic primitives framing) and for verifiable Sweigart quotations on programming pedagogy. Companion text to Automate the Boring Stuff; same author voice, same beginner-friendly register.

Peer-curriculum reference (for instructors and self-checking students)

5. Harvard CS50P (CS50's Introduction to Programming with Python); https://cs50.harvard.edu/python/2024/. Free; lecture videos, problem sets, certificate. The most popular MOOC-format Python intro. FND-102 cross-references the CS50P sequence in the instructor guide to validate week-by-week ordering.

6. MIT 6.0001 (Introduction to Computer Science and Programming in Python); https://ocw.mit.edu/courses/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/. Free; OpenCourseWare. The most academically rigorous undergraduate-level intro. FND-102 borrows MIT 6.0001's decomposition-by-functions emphasis for week 3.

7. Real Python learning paths; https://realpython.com/learning-paths/. Modular tutorial series with quality control; cited for specific topic-deepening (e.g., https://realpython.com/python-pathlib/ for pathlib, https://realpython.com/python-requests/ for requests).

A complete peer-course reference table for FND-102 lives in curriculum-research/peer-course-references-2026-04-25.md.

Capstone

The FND-102 capstone is "Automate something in your actual life." You choose a real, repeated, tedious task that you face, then ship the tool that automates it.

A "tool" means: a Python CLI program with an argparse interface, a README that lets a stranger run it, three or more pytest tests, and a Git history with at least five commits.

A "real task" means: something you genuinely repeat. Renaming photo files after a trip. Scraping a sports stats page into a CSV for analysis. Generating a weekly chore schedule. Backing up a directory to cloud storage with hash verification. The constraint is that it must be something you would actually use after the course ends.

Full specification, rubric, and three-to-five worked exemplar project specs in CAPSTONE.md.

Labs

Twelve graded labs plus the capstone. The numbering follows the week:

The "six CLI tools" referenced on the public page are Labs 6, 7, 9, 11, 12, and 13's enhanced prior tool. Each is a real argparse + tests + README artifact in your Git repository by the end of the course.

Setup before week 1

See SETUP.md for the full checklist. Plan ~60 minutes before week 1: install Python 3.11+, a code editor (VS Code recommended), Git, and confirm you can run a pytest command. WSL2 students from FND-101 are already set up; macOS and Linux students need only confirm Python 3.11+ is available.

Pedagogy

FND-102 is taught by building. Every week the student writes code that runs, breaks, and gets fixed. The course rejects the syntax-survey style of teaching (where students learn dozens of language features in lectures and then write trivial exercises). Instead, each week introduces the minimum syntax needed for that week's lab, and the lab does the teaching by producing a real tool the student can run and verify.

Two cross-cutting voice patterns run through the course:

1. Tool Journal. Each week names the practitioner tools introduced that week (the Python module, the CLI utility, the editor command, the Git workflow). The tool journal is a running list the student updates; by week 14 it is a personal reference of every tool the course covered.

2. "What's the failure mode?" callout. Each lab includes a paragraph on what tends to go wrong with this kind of tool and how a practitioner would notice. The discipline of asking "what would I do if this is broken at 2 a.m.?" is the difference between a student who can write code and a practitioner who can ship code.

Petzold weaves do NOT run through this course. The CSA-track pedagogy uses Petzold CODE as a hardware foundation; FND-102's track uses Python-pedagogy anchors (Matthes, Sweigart, Downey) instead, per the academy's track-specific-foundational-anchors convention.

Tool journal: FND-102 additions

By week 14 the student's tool journal carries these new entries (each cross-referenced to the academy's cross-chapter-tool-journal.md master list):

• Python 3.11+, the language and its standard library
• pdb, the source-level debugger (Lab 9)
• argparse, the standard CLI parsing module (Lab 6)
• pytest, the standard testing framework (Lab 13)
• requests, the de facto HTTP client (Lab 12)
• hashlib, cryptographic hashing in the standard library (Lab 11)
• Git intermediate (branches, remotes, pull requests; Lab 10)
• VS Code as Python editor (linting, run-in-terminal, integrated debugger; week 1 setup)

Course outline v0.1 prepared 2026-05-28. Iteration after first pilot cohort runs.