Pipeline entry course. No prerequisites beyond basic algebra. ~105 hours total across 12 weeks. Audience: high-school and homeschool students, career changers, curious adults.
Course mission
You start FND-101 not knowing what a byte is. You end it knowing what every byte in a small file means, where it came from, and how to navigate the shell and version-control tools that every computing professional uses every day. The course covers the ideas that sit underneath all of computing: how numbers are represented in hardware, how logic gates do arithmetic, how a CPU fetches and runs instructions, and how the Linux shell and Git work. None of this requires a hardware kit. All of it requires thinking carefully about what a computer is actually doing.
The north star: "A student who finishes FND-101 can look at a number, a character, a color code, or a byte in a file and decode it with understanding. Not by magic, and not by memorization, but by model."
Who this course is for
- High-school students who completed SPK-101 or who have basic computer literacy
- Homeschool students at years 9-12
- Career changers and adults with no formal computing background
- Anyone who can install software, use a file manager, and look things up online
You do NOT need prior programming experience. You do NOT need a hardware kit. You need a laptop (Windows, macOS, or Linux), an internet connection, and roughly 9 hours per week across 12 weeks.
Where FND-101 sits in the pipeline
Prerequisite for this course: SPK-101 (Sparking Curiosity) is the recommended on-ramp, but not required. Basic algebra and comfortable computer literacy (install software, navigate folders, use a browser) are enough.
What FND-101 gates (you should take these next):
- NET-101: Networking I (needs hex literacy + shell fluency from FND-101)
- SEC-101: Cybersecurity Principles (needs hex-dump literacy; the file-structure understanding from FND-101 is the base)
- RE-011: Introduction to Reverse Engineering (needs binary/hex/shell from FND-101)
- CSA-101: Computer Systems Architecture I (needs Boolean logic + adder circuits + FDE cycle from FND-101)
Figure F.1. Where FND-101 (Belt 1) sits in the program. The amber squares are courses you can take today; the outlined squares are planned. The Belt 4 panel is highlighted because that is the academy's largest active investment (CSA-101 mid-build; CSA-201 + RF-201 + AI-201 + CON-101 queued). After FND-101 the natural belt walk is left-to-right; the prereq map handout has the exact edge list.
What you will know at the end
After completing FND-101, you will be able to:
Numbers and encoding:
- Convert numbers fluently between decimal, binary, and hexadecimal without a calculator
- Explain two's complement signed integers and recognize integer overflow
- Decode a hex dump back into ASCII or UTF-8 text, character by character
- Read a file's magic bytes and identify the file format from them
Logic and arithmetic:
- Fill in truth tables for AND, OR, NOT, XOR, NAND, and NOR
- Explain why NAND is universal (any logic function can be built from NAND alone)
- Trace a signal through a half-adder and a 4-bit ripple-carry adder
Computer architecture:
- Draw the CPU-memory-bus block diagram and label each component's role
- Describe the fetch-decode-execute cycle step by step
- Explain the difference between instruction memory and data memory
Linux shell:
- Navigate a Unix filesystem from the command line using cd, ls, pwd, cat, grep, find, and pipes
- Write a short bash script that processes text input
- Use ssh to reach a remote system
Git:
- Initialize a repository, commit files, push to a remote, and resolve a simple merge conflict
Capstone:
- Analyze a real file's byte structure by hand, annotate it against a format reference, and produce a written decoding report committed to a Git repository
Course shape
| Week | Theme | Lab focus |
|---|---|---|
| 1 | Numbers and binary | Binary conversions by hand |
| 2 | Characters and encoding | Hex dumps + UTF-8 decoding |
| 3 | Boolean logic | Truth tables + NAND universality |
| 4 | Logic gates and arithmetic | Half-adder design; ripple-carry adder |
| 5 | Memory and state | Flip-flop trace; 1-bit memory cell |
| 6 | Computer architecture at block level | CPU block diagram |
| 7 | How a program runs | Fetch-decode-execute trace on paper |
| 8 | Linux shell I | Filesystem navigation + text search |
| 9 | Linux shell II | Bash scripting; environment variables |
| 10 | Git fundamentals | First repo + merge conflict |
| 11 | Networking basics | traceroute + curl + packet headers |
| 12 | Capstone + bridge | Documented byte-decoding report |
Per-week time budget
Each week runs approximately 9 hours total:
| Activity | Time per week |
|---|---|
| Lecture (2 x 55 min) | 1 hr 50 min |
| Lab (1 x 90 min) | 1 hr 30 min |
| Independent practice | ~4 hr |
| Reading | ~1 hr |
| Reflection journaling | ~30 min |
| Total per week | ~9 hr |
12 weeks x 9 hr = 108 hr (close to the published ~105 hr; minor variation per cohort pace).
Anchor reading
Primary: Charles Petzold, CODE: The Hidden Language of Computer Hardware and Software (1st ed., Microsoft Press). Chapters 1-12 map directly to weeks 1-7:
| Petzold chapters | FND-101 coverage |
|---|---|
| Ch 1-3 (Morse, Braille, codes) | Week 1 framing: information as patterns |
| Ch 6-9 (Our Ten Digits, Alternatives to Ten, Bit by Bit) | Weeks 1-2: binary, hex, encoding |
| Ch 10-11 (Logic and Switches, Gates) | Week 3: Boolean logic and gates |
| Ch 12-14 (Binary Adding Machine, Subtraction, Flip-Flops) | Weeks 4-5: adders and memory |
| Ch 17-19 (Automation, From Abacuses to Chips) | Weeks 6-7: architecture and FDE cycle |
Petzold is available at most public libraries. The 1st edition is the course anchor; page numbers and chapter titles may differ slightly in later printings.
Supplemental (all free online):
- The Linux command-line tutorial at
https://linuxcommand.org/lc3_learning_the_shell.php(weeks 8-9) - Pro Git by Scott Chacon at
https://git-scm.com/book/en/v2(week 10) - The academy's
cross-chapter-silicon-level-reading-guide.md(forward reading for Ch 5-6 graduates heading toward CSA-101)
Capstone
The FND-101 capstone is a documented "decoded artifact." You select a small real-world file (a PNG, a ZIP, a TLS handshake capture, or a short binary), decode its byte structure by hand against the format's public specification, annotate it, and write a 1-2 page decoding report. You commit the report and the annotated file to a Git repository.
Full specification in CAPSTONE.md.
Labs
Fourteen graded labs (some weeks have two, most have one) plus the capstone. Each lab produces a concrete artifact the student commits to a personal Git repository.
| Lab | Title |
|---|---|
| 1-1 | Binary by Hand |
| 1-2 | Hex Dump a File |
| 2-1 | UTF-8 Encoding + Decoding |
| 3-1 | Truth Tables |
| 3-2 | Logic Puzzle (Knights and Knaves) |
| 4-1 | Half-Adder on Paper |
| 5-1 | Flip-Flop Signal Trace |
| 6-1 | CPU Block Diagram |
| 7-1 | Fetch-Decode-Execute Trace |
| 8-1 | Shell Navigation Scavenger Hunt |
| 8-2 | Text Search with grep and friends |
| 9-1 | Bash Script |
| 10-1 | First Git Repo |
| 10-2 | Merge Conflict |
| 11-1 | Traceroute + curl |
Setup before week 1
See SETUP.md for the full checklist. Plan ~90 minutes before week 1: install Python, a text editor, Git, a terminal, and a hex editor. Windows students need WSL2 for the shell labs; the setup guide walks through it.
Pedagogy
FND-101 is taught concretely. Every abstraction is grounded in something you can touch and verify: a binary number you converted by hand, a truth table you filled in yourself, a hex dump you decoded byte by byte. The course does not ask you to take things on faith. It asks you to work through the evidence and see why the model is correct.
Mistakes are part of the process. Getting an off-by-one in a binary conversion and noticing it from the wrong answer is better learning than getting it right the first time with a calculator.
Course outline v0.1 prepared 2026-05-10. Iteration after first pilot cohort runs.