VCA-FND-102: Python and Automation

Course Overview

The course is not structured around toy examples (print "hello world"; compute prime numbers; make a calculator). It is structured around tools. Things the student builds that the student, or someone the student knows, will actually run. Students who experience programming as automation-of-the-annoying develop a fundamentally different relationship with code than students who experience it as disconnected exercises.

Position relative to peer curricula. FND-102 sits between AP Computer Science Principles (vendor-neutral, language-agnostic, more concept-than-tool oriented) and Sweigart's Automate the Boring Stuff with Python (the canonical self-directed automation reader). AP CSP teaches programming-as-vocabulary; Sweigart teaches automation-as-self-directed-hobby; FND-102 teaches programming-as-craft, in a cohort, with PR review and Git-history-as-grading-evidence and a peer-presented capstone. The Python Institute PCEP cert serves as the multiple-choice baseline; FND-102 exceeds PCEP's scope and adds the practitioner's discipline (testing, debugging, README writing) PCEP does not measure.

Pipeline role: FND-102 is the working Python environment every later academy course assumes. PEN-101 lives in Python; SEC-101's incident-response and forensics workflows compose Python tools; CSA-101's entire toolchain (assembler, linker, VM translator, compiler) is written in Python. The student who leaves FND-102 with a personal Git repository of six working CLI tools and a capstone they actually use has the working substrate the academy assumes.

Learning Objectives

From basics to mastery. Each is measurable against a specific lab or deliverable.

1. Remember. 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). (Assessed: Week-7 short quiz; oral check-ins during Labs 1-4.)
2. Understand. Explain why Python is dynamically typed, why list/dict mutation is a different operation from rebinding, why try/except exists as a control-flow primitive, and why a CLI tool's --help is part of its UX rather than a comment. (Assessed: Lab 6 reflection; midterm question set.)
3. Apply. Read and write Python 3 syntax fluently: variables, types, control flow, functions, modules, list / dict / tuple / set comprehensions. (Assessed: Labs 1-7; midterm practical.)
4. Apply. Use structured data confidently: lists, dictionaries, tuples, sets; JSON / CSV serialization with encoding and line-ending awareness. (Assessed: Lab 4 + Lab 5 deliverables.)
5. Apply. Use the standard library for common automation needs: os, pathlib, subprocess, argparse, json, csv, re, datetime, hashlib, logging. (Assessed: Labs 5-13.)
6. Apply. Use git daily: clone, branch, stage, commit, push, pull, merge, resolve a simple conflict; open pull requests against the instructor as reviewer. (Assessed: Lab 10 PR submission; capstone Git history.)
7. Analyze. Debug systematically: 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. (Assessed: Lab 9 debugging exercise; capstone bug-discussion section.)
8. Synthesize / Create. Compose an automation tool of the student's own design (the capstone) with argparse interface, README, ≥3 unit tests, multi-commit Git history, and a 5-minute demo plus Q&A. (Assessed: Capstone, the student's automation-something-in-your-actual-life project.)

Week-by-Week Topic Flow

Lab Manifest

Thirteen graded labs plus the capstone, each producing a runnable Python tool committed to the student's personal Git repository.

Bridge to Downstream Courses

FND-102's Python fluency is the working substrate every subsequent academy course assumes. Explicit cross-course threads:

• → 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 & 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 Pentest). 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 untenable.
• → HW-101 (Electronics + MCUs). The subprocess + serial-port automation from Lab 9 is structurally similar to the MCU-flashing workflows in HW-101; same Linux + Git habits.

Tool Journal: FND-102 Additions

FND-102 extends the Tool Journal thread that FND-101 originated. Tools introduced here, with one paragraph each in the student's personal toolchain-diary.md:

• Python 3.11+, the language and its standard library. Every later academy course composes Python tools.
• pdb, Python source-level debugger. Lab 9 introduces conditional breakpoints; CSA-101 Ch 9 promotes pdb to mandatory tooling for parser recursion.
• argparse, CLI parsing module. Every CLI tool in the academy uses it.
• pytest, Python testing framework. Lab 13 introduces; CSA-101 Ch 6 + 9 build complete test suites with it; @pytest.mark.parametrize arrives in CSA-101 Ch 9 lecture notes.
• requests, HTTP client library. Returns in NET-101 + PEN-101 + advanced security work.
• hashlib. Cryptographic hashing. Lab 11 introduces SHA-256; SEC-101 deepens.
• Git intermediate (branches + PRs), Lab 10 introduces; every later course assumes PR-style review.

Prerequisite Map

Depends on: VCA-FND-101 (Linux/SSH/git fluency from Labs 12-13; ASCII/UTF-8 understanding from Lab 5).

Feeds into:

• SEC-101 (direct sequel; security tooling lives in Python)
• NET-101 (concurrent-eligible; deepens when the Python automation lands on packet captures)
• PEN-101 (sequel after SEC-101; offensive Python scripts)
• CSA-101 (concurrent-eligible with HW-101 prereq; the entire toolchain is written in Python)

See the course prerequisite map for the academy-wide map and named track sequences.

Capstone: Automate Something in Your Actual Life

Each student chooses a real repetitive task from their own life. A homework-reminder tracker, a music-library duplicate-finder, a bus-schedule checker, a daily-chore rotator, a text-adventure game they wanted to make, and builds it as a Python CLI tool. Students may not choose a capstone that has a library doing 90% of the work for them, the tool's value must come from the student's code, not just glue.

Two-tier grading rubric

First, your project must work. The tool runs without error from a fresh clone of the student's repository; the --help output is comprehensible to a peer who has not seen the code; the README is present and accurate; at least three pytest tests exist and pass; the 5-minute demo is delivered; two peer questions are answered substantively.

Then we score the report.

• Code quality + craft (40%). Functions are well-named and have docstrings; code is structured (no 200-line main); error handling is appropriate; the standard-library tour from Weeks 5-13 is exercised purposefully; commit history shows real iteration, not a single "initial commit" dump.
• Tests + docs (30%), pytest tests cover the tool's core logic (not just trivial smoke tests); README explains setup, usage, and one example; --help reads as user-facing documentation, not a comment dump.
• Reflective depth (30%), the demo includes one paragraph on the bug the student hit and fixed that they want to remember, and one on the design choice they made and would (or would not) make again. Peer questions are engaged with substantively, not deflected.

Submitted artifacts: the Git repository (with multi-commit history); the README; the test suite; a 90-second screen-capture of the tool running; the 5-minute demo slides (3-5 slides); a one-paragraph self-assessment.

Technical-Typing Integration

Terminal typing speed is the unspoken bottleneck for every student who writes code. The course integrates cyberseals.net technical-typing as a running-in-the-background requirement:

• Benchmark by Week 6: 35 WPM with 95% accuracy on technical text
• Benchmark by Week 14: 50 WPM with 95% accuracy

Required Hardware & Software

• Linux environment. Same setup as FND-101 (bench Pi or remote SSH)
• Python 3.11+, Git, pytest
• Code editor (VS Code recommended)

No textbook required. Supplementary: Sweigart, Automate the Boring Stuff with Python (free at automatetheboringstuff.com); Downey, Think Python 3rd ed. (free at greenteapress.com).

Certification Alignment

Python Institute PCEP PCAP (next-step)

Primary alignment, Python Institute PCEP ($69 exam). Covers the course's syllabus in full. Students who complete FND-102 can sit PCEP within one month with no additional study; the FND-102 capstone's argparse + pytest + README discipline exceeds PCEP's multiple-choice scope.

Next-step alignment, PCAP (intermediate Python). Ideal target after FND-102 + SEC-101 + one of the lab-heavy follow-ons (HW-101 or NET-101) is complete. PCAP's OOP and module-system depth lines up with the work students do in their PEN-101 + RE-011 year.

Pedagogical-vs-vocational stance. FND-102's capstone. A working CLI tool the student actually uses, with tests, README, multi-commit Git history, and oral defense - exceeds what any multiple-choice cert measures. Employers evaluating Virtus Academy graduates should weight the capstone artifact and the personal Git repository alongside (or above) the cert. The cert is earned as a side effect by students who choose to sit it.

Certs are never required to complete a Virtus Academy course. The course transcript and the committed lab repository are the academy's primary credentials.

Format Prescriptions

Hour budget: ~26 lec hr + ~28 lab hr + ~71 indep hr (= ~125 hr total).

Live (standard cadence)

2 sessions/wk × 90 min each (45 min lecture + 45 min hands-on per session) + 30 min stay-after office time. 14 weeks total. Best for college-elective + adult-learning + homeschool-co-op cadence.

Night class (working-adult cadence)

1-2 sessions/wk in evenings; spread over ~28 weeks. Best for community-college + vocational-tech students with day jobs.

Bootcamp

8 hr/day × 5 days/wk = 40 hr/wk; total ~4 weeks. Foundationals (≤ 80 hr) fit in 2 weeks; FND-102's 125 hr lands at ~3-4 weeks. Best for adults / age-irrelevant students with prereq comfort + dedicated learning time.

Async self-paced

Lecture hours via recorded video; lab hours via monthly-block billing with remote-hardware access; indep hours = student pace. Includes Discord-group access (1-2 days/wk instructor-advertised availability). AI-assistant tier add-on. Live 1:1 tutoring premium tier add-on.

High school / homeschool co-op

Adapted live cadence over a school year (~18 weeks at typical school cadence) OR semester (14 weeks at college cadence). Detailed per-syllabus planning available on request.

Interested in VCA-FND-102?

Email interested@virtuscyberacademy.org with your background and interest.

Email interested@virtuscyberacademy.org