This Teacher's Guide is your day-to-day companion for delivering Unit 3 of the Code Quest curriculum. It picks up after Unit 2 and assumes students are comfortable with everything from Units 1 & 2 — variables, data types, operators, if/else, for loops, while loops, lists (read-only), and the 3-step debugging mindset. It's designed for new and experienced CS teachers alike — no programming background required to use it effectively. Every lesson plan stands on its own; if a substitute teacher takes over for a day, they should be able to pick up the next lesson and run it.

What this guide contains

• A pacing guide showing how Unit 3 maps to roughly 6–8 class periods, with two-day extensions available for the trickier lessons (Bubble Sort and the capstone).
• A standards & exam crosswalk showing exactly which Florida CTE standards and Coding Fundamentals exam objectives each lesson addresses. Unit 3 is the home of standards 07.02 (algorithms) and 07.06 (pseudocode).
• A unit vocabulary glossary with all 14 key terms students will encounter in Unit 3 — most of them brand new conceptual vocabulary (algorithm, flowchart, decision diamond, factorial, etc.).
• Five detailed lesson plans (one per lesson), each using the same 7-section format you saw in Units 1 & 2.
• An appendix with the most common Python errors students will see in Unit 3, focused on the new tools (.append() and sorted()) and lingering Unit 1–2 carryovers.

How each lesson plan is structured

Every lesson plan in this guide uses the same 7-section format so you can find what you need quickly:

• At-a-Glance — objective, time, materials, vocabulary, and a quick-reference standards box
• Lesson Flow — a suggested 45-minute breakdown: warm-up, instruction, guided practice, lab, exit ticket
• Watch For — the 2–4 most common student misconceptions, with how to address each in real time
• Differentiation — what to do for early finishers and what to do for struggling students
• Discussion Prompts — questions to spark whole-class conversation
• Real-World Connections — how to answer the inevitable "why does this matter?" question
• Lesson-Specific Vocabulary — terms introduced or reinforced in that lesson

How to read this in conjunction with the student lessons

Each Code Quest lesson is a self-contained HTML page that students work through at their own pace. This guide doesn't replace those lessons — it equips you to teach alongside them. The expected workflow:

• Before class: read this lesson plan (5–10 min) and skim the student HTML lesson, paying special attention to interactive widgets (the Algorithm Builder, the Path Tracer, the Bubble Sort Visualizer, the Factorial Calculator)
• During class: follow the lesson flow; the student HTML is the textbook + lab
• After class: grade the Knowledge Checks and labs against this guide's expectations

The big picture

Unit 3 introduces the most important shift in students' programming maturity — plan before you code. Students learn what an algorithm is, how to write one in plain English, how to draw one as a flowchart, then trace through Bubble Sort (their first non-trivial algorithm) and explore factorials (their first taste of mathematical algorithm scaling). The capstone upgrades the Mad Libs game with two new Python tools — .append() for list-building and sorted() for ordering — applied through the algorithm-first mindset.

What students learn

• Define an algorithm and apply the three rules every algorithm must follow: precise, ordered, finite
• Write algorithms in plain English (informal pseudocode) before translating to Python
• Read and draw flowcharts using the four standard shapes — oval (terminator), parallelogram (input/output), rectangle (process), diamond (decision)
• Follow flowcharts with loops by tracing the arrow path back to a previous decision
• Trace Bubble Sort step by step — comparing adjacent pairs and swapping until the largest values "bubble" to the end
• Distinguish between writing a sort algorithm and using Python's built-in sorted() — and explain why both matter
• Define a factorial (n!), compute small factorials, and connect factorial growth to nested loops
• Recognize that factorials grow surprisingly fast (10! > 3 million; 20! > 2 quintillion) — the foundation of "Big O" thinking later
• Use Python's list = [], list.append(item), and sorted(list) to collect and order data across loop iterations
• Apply the "plan first, code second" mindset to a complete project (Mad Libs 3.0)

Prerequisites

Units 1 & 2. Students must be comfortable with: variables, data types, operators, if/elif/else, input(), f-strings, for loops with range(), while loops, list iteration (read-only), and the 3-step debugging mindset. Unit 3 doesn't introduce many new Python keywords — its work is conceptual.

What comes next

Unit 4 introduces functions and a deeper formal SDLC (the same SDLC students glimpsed in Lesson 2.5). Functions let students name the algorithms they wrote in Unit 3 and reuse them. The "plan first" mindset students build here becomes the discipline that makes Unit 4's modular code clean rather than spaghetti.

Materials you'll need

• Computers with web browser access (one per student, or pairs)
• Knowledge Pillars CodeSkills Lab access
• Projector or large screen — Unit 3's interactive widgets (Algorithm Builder, Path Tracer, Bubble Sort Visualizer, Factorial Calculator) are designed for whole-class projection
• Whiteboard with multiple colors — used heavily in Lessons 1, 2, and 3 for live algorithm/flowchart drawing and Bubble Sort traces
• Paper and pencils — Unit 3 is the most paper-heavy unit so far. Students draw flowcharts on paper before drawing them digitally.
• Optional: printed flowchart shape reference cards (one per student) — tape to desk for Lessons 2 & 5
• Optional: 5-10 sticky notes per student for the kinesthetic Bubble Sort activity in Lesson 3

Unit 3 is designed to fit in 6–8 class periods of approximately 45 minutes each. Lessons are individually shorter than Unit 2's (no 50-min lesson, no 2-day capstone) — but the conceptual density is higher, especially in Lessons 2 and 3. Adjust based on how comfortably your students handled Unit 2 loops.

Recommended pacing — 7-day plan

Compressed 6-day pacing

If you need to compress: combine Day 3 and Day 4 (cover all of Bubble Sort in one class). This works for stronger groups but rushes Bubble Sort tracing — students who don't trace at least one full pass on paper rarely internalize how the algorithm works. Recommended only if your students breezed through Unit 2 loops + lists.

Extended 8-day pacing

If you have a shorter class period (30 min) or want deeper coverage: split Lesson 2 (flowcharts) across two days. Day 2 covers shapes + reading flowcharts; Day 3 has students draw their own flowcharts on paper for 3–4 different problems. Drawing is what locks the concept in — most teachers wish they'd budgeted more time here.

Suggested grading weights for Unit 3

Note: Participation is weighted heavier in Unit 3 than other units because so much of the unit is collaborative and on-paper. The Mad Libs 3.0 capstone is weighted slightly less than Unit 2's because it's a smaller code lift — the heavy work is in the four conceptual lessons.

This crosswalk shows exactly which Florida CTE standards and Coding Fundamentals exam objectives each lesson addresses. Use this for admin reviews, IEP documentation, or to prove alignment when adopting the curriculum. Unit 3's primary "new" standards are 07.02 (algorithms) and 07.06 (pseudocode). Every lesson in the unit carries the "🎯 Objective 3" tag — algorithm understanding and design — which is the central exam objective.

Florida CTE Standards — Course #9009200

Standards from the Florida Department of Education Coding Fundamentals curriculum framework that Unit 3 addresses:

Coding Fundamentals Exam Objectives

Exam objectives that Unit 3 prepares students for. Objective 3 — algorithm understanding — is the unit's primary objective; every lesson tags it explicitly.

Lesson-by-lesson alignment

All key terms students will encounter in Unit 3. Most are conceptual rather than syntactic — Unit 3 introduces few new Python keywords but many new ideas. The "Intro" column shows the lesson where the term first appears. Each lesson plan also includes its own focused vocabulary list.

This appendix lists the most common Python error messages students will see in Unit 3, focused on the new tools (.append(), sorted()) and the carryover errors from Units 1–2 that resurface in the capstone. Unit 3 introduces relatively few new error types — but the algorithm-first mindset means students should hit fewer errors overall.

— End of Unit 3 Teacher's Guide —

↑ Back to top