For instructors and homeschool parents running FND-101. The course is self-runnable from the student-facing materials; this guide adds pacing context, common stumbling blocks, and grading guidance.
Course shape at a glance
| Item | Value |
|---|---|
| Total time | ~105 hours over 12 weeks |
| Weekly time | ~9 hours student time |
| Lecture per week | 2 x 55 min |
| Lab per week | 1 x 90 min (some weeks have 2 labs) |
| Independent practice | ~4 hr/week |
| Reading + reflection | ~1.5 hr/week |
| Audience | High-school, homeschool, career-changers, adults |
| Prerequisites | Basic computer literacy; basic algebra |
| Hardware | None required |
| Cost | $0 |
| Capstone | Documented byte-decoding report |
Cohort pacing recommendations
- Self-paced (one student): 12 calendar weeks is comfortable. Students who have prior programming or math exposure may move through weeks 1-5 faster.
- Homeschool (1-3 students, parent-led): 12 weeks at 1 module per week. Run lectures as discussions. Labs work well as side-by-side sessions.
- Classroom (10+ students): 12-14 weeks. Add weekly lab sessions where students work together; peer help is especially valuable in weeks 3-5 (logic circuits) and weeks 8-9 (shell scripting).
- Intensive (full-time, ~3 weeks): 105 hours fits in 15 working days at 7 hours/day. Aggressive but achievable. Pair students to reduce isolation during the hardware weeks.
Per-week pacing notes and common stumbling blocks
Week 1: Numbers and binary
Pacing: 2 full lecture slots are needed for two's complement; do not rush it.
Common blocks:
- Students confuse "the column weight" method with memorizing bit patterns. Redirect: the point is understanding WHY the column values are powers of 2, not memorizing the table.
- Two's complement negation (flip + 1) is not intuitive. Walk through two examples: -5 in 8-bit, and then verify by adding +5 + (-5) to confirm you get 0.
What to watch: students who got the right answer on Lab 1.1 without being able to explain the column-weight method have memorized rather than understood. Ask them to explain one conversion verbally.
Week 2: Characters and encoding
Pacing: Joel Spolsky's article is essential prereading; assign it before the lecture, not after.
Common blocks:
- "Code point vs byte" confusion persists. Repeat: Unicode is a catalog of characters with numbers; UTF-8 is the algorithm that turns those numbers into bytes. A code point is an integer; a byte sequence is its UTF-8 representation.
- The 2-byte encoding of é is genuinely confusing the first time. Work through it at the board with the bit layout written out.
Weeks 3-4: Boolean logic and arithmetic
Pacing: week 3 is conceptual and moves quickly; week 4 is construction-heavy and takes the full time.
Common blocks:
- Students writing NAND truth tables incorrectly: they often write the AND result without inverting. Reinforce: NAND = NOT AND. The output is 0 ONLY when both inputs are 1.
- Half-adder vs full adder: students routinely try to chain two half-adders without adding the OR gate for the carry-out. The paper circuit diagram in Lab 4.1 is essential for catching this.
What to watch: if a student cannot trace carry propagation through the 4-bit adder by hand, they will struggle with the FDE trace in week 7 and the CSA-101 ALU lab later. Spend extra time here.
Week 5: Memory and state
Pacing: the SR latch and D latch can be covered quickly; spend the bulk of time on the D flip-flop and timing.
Common blocks:
- Setup time is abstract until you show what metastability looks like on a digital oscilloscope (if one is available). If not, the timing diagram in Lab 5.1 is the substitute.
- Students ask: "why not just use a latch instead of a flip-flop?" The answer is that latches are transparent; they change continuously while enable is high, making timing analysis intractable for large circuits.
Week 6: Computer architecture
Pacing: this week is conceptual; the lab (block diagram) is where the time goes.
Common blocks:
- Students omit the IR from their block diagram. The instruction register is often forgotten because it feels redundant ("isn't it just fetching from memory?"). The IR holds the instruction while it executes across multiple clock cycles; the fetch of the next instruction can begin in parallel.
Week 7: Fetch-decode-execute
Pacing: the trace in Lab 7.1 takes the full 90 minutes for most students. Some will need extra time.
Common blocks:
- Students increment PC for JMP and JEQ before applying the branch: they write PC=1, then PC=3 (from JMP). The correct sequence is: fetch at current PC; PC increments; then execute overwrites PC if it is a jump.
- Students forget that CMP does not write to a register; they mistakenly set r1 to 0 when CMP compares r1 to r3=0.
Weeks 8-9: Shell
Pacing: Lab 8.2 (text search with pipelines) is where students first feel the power of the command line. Encourage experimentation beyond the lab script.
Common blocks:
- Windows students without WSL2 will struggle. If any students arrive at week 8 without WSL2, pause and help them set it up; it takes 30-45 minutes but enables the remaining shell and scripting labs.
- Students frequently forget that
rmis permanent. Mention this at the start of week 8 and again in the lab setup.
What to watch: students who cannot explain what each stage of a pipeline does (week 8 reflection prompt 2) need review before week 9 scripting.
Week 10: Git
Pacing: the merge conflict lab (Lab 10.2) is often where students realize they do not understand branches. Plan extra time for discussion after Lab 10.2.
Common blocks:
- Authentication failures on
git push: GitHub no longer accepts passwords; students need a Personal Access Token or SSH key. This is a setup issue, not a Git issue; resolve it before the lab starts. - "Already up to date" when a conflict was expected: the student edited the same LINE in both branches but the edits happened to produce the same text. Point out that they need to make genuinely different changes to the same line.
Week 11: Networking
Pacing: this week is more observational than constructive; students should spend most of the lab running actual commands and recording what they see.
Common blocks:
- Traceroute stops at
* * *due to firewalls. Teach students to interpret this as "a router declined to respond" rather than "the connection failed." The destination is still reachable even if intermediate hops are silent. - Students confuse DNS with IP routing. DNS translates names to numbers; IP routing moves packets to those numbers. They are separate systems.
Week 12: Capstone
Pacing: capstone week needs all 5 working days. Do not let students procrastinate past day 3.
Common blocks:
- Students underestimate how long it takes to decode all the fields in a header. Encourage them to start with just 4-8 bytes before attempting the full header.
- "The specification is confusing." This is real. Format specifications are written for implementers, not students. Walk students through one field together before expecting them to decode independently.
Grading rubric for the capstone
The capstone is graded on a simple checklist:
| Criterion | Points | Notes |
|---|---|---|
| annotation.txt present and complete | 25 | All header fields covered; byte offsets accurate; values correct per the hex dump |
| Annotation matches the specification | 25 | Each field's meaning matches what the referenced specification says |
| decoding-report.md: correctness | 20 | The explanations are factually accurate |
| decoding-report.md: clarity | 20 | Plain English; a non-specialist can follow the explanation |
| Git repository hygiene | 10 | At least 3 commits; all required files present; meaningful commit messages |
| Total | 100 |
There is no partial credit within each criterion. If annotation.txt is present but missing 3 fields, score the criterion as 15/25. Use judgment.
Forward pointers for instructors
When students ask "what comes next?", here is how FND-101 content connects:
- NET-101 entry: hex literacy (weeks 1-2) and networking basics (week 11) are the direct prerequisites. NET-101 week 1 assumes students can read a packet capture in hex.
- SEC-101 entry: the hex dump literacy from week 2 and the file-format decoding from the capstone are the SEC-101 foundations. Students who struggled with the capstone should revisit weeks 1-2 before starting SEC-101.
- RE-011 entry: the FDE trace from week 7 is the RE-011 on-ramp. Students who cannot trace a program through FDE by hand will find disassembly analysis in RE-011 frustrating.
- CSA-101 entry: weeks 3-7 are the CSA-101 prerequisites. A student who completes FND-101 weeks 1-7 is ready for CSA-101 Ch 1-5 conceptually; the Verilog and HDL will be new, but the underlying logic is not.
What FND-101 does NOT teach
Some topics students may expect but are not in FND-101:
- Programming: no programming language is taught (Python one-liners in week 2 are not programming instruction; they are verification tools). FND-101 graduates who want to program should take FND-102 (Python and Automation).
- Digital circuit simulation: labs 4.1 and 5.1 are paper-based or drawing-tool based. Logisim-evolution (used in the public page's older 15-week shape) is not in v0.1; it may be added in v0.2 after pilot feedback.
- Hardware teardown: the 15-week public-page version included an e-waste teardown capstone. v0.1 replaces this with the byte-decoding capstone. The teardown is moved to a possible standalone lab in a future HW-101 course.
Instructor guide v0.1. Revise after first pilot cohort runs.