CA ICT & Anchor Standards Reference

#1.0 Academics

Successfully finishing an ICT pathway means meeting the academic standards tied to it, on the way to further education or a job.

Unassigned

#2.0 Communications

Working in ICT means using the sector's own vocabulary and communicating clearly, in writing, speech, and multimedia, at a career-ready level.

Unassigned

• #2.1 Communication follows a basic model: someone sends a message, someone else receives it.
  • Kagan Cooperative Learning — Classbuilding: Unit Find Someone Who (Find Someone Who), Unit Inside-Outside Circle (Inside-Outside Circle), Unit Mix-N-Match (Mix-N-Match), Unit Stir-the-Class (Stir-the-Class) (related)
    Each of these rotates students through a repeated asker/answerer exchange with a new partner every round -- Inside-Outside Circle's two concentric circles trade questions and switch, Mix-N-Match has partners quiz and trade cards, Stir-the-Class rotates who answers within a huddle. Students get heavy repetition of the sender/receiver exchange itself, but it's never named or taught as a concept, which keeps this at related rather than a taught match.
  • Kagan Cooperative Learning — Teambuilding: Unit Fan-N-Pick (Fan-N-Pick), Unit Three-Step Interview (Three-Step Interview), Unit RoundRobin (RoundRobin), Unit Pairs Compare (Pairs Compare) (related)
    Fan-N-Pick, Three-Step Interview, RoundRobin, and Pairs Compare all put students through an explicit asker/answerer or speaker/listener turn each round, which is the shape of the sender/receiver model this standard describes. Nothing in the structure names or teaches that model, though -- it's practiced by doing the activity, never instructed -- so this is support for the standard, not direct coverage.
• #2.2 Communication can break down, and recognizing what gets in the way of a message landing correctly is its own skill.

  Unassigned

• #2.3 Reading both what's said and what's implied, then responding appropriately, is part of communicating well.
  • Kagan Cooperative Learning — Classbuilding: Unit Inside-Outside Circle (Inside-Outside Circle), Unit Who Am I? (Who Am I?) (related)
    Both require actually responding to what a rotating partner just said rather than a scripted line, and Who Am I? in particular is a guessing game built on picking up on clues from a partner's answers -- closer to a game mechanic that touches responsive listening than direct instruction in reading implied meaning, so it's surfaced rather than counted as real coverage.
  • Kagan Cooperative Learning — Teambuilding: Unit Team Interview (Team Interview), Unit Three-Step Interview (Three-Step Interview), Unit Find-the-Fiction (Find-the-Fiction) (related)
    Find-the-Fiction has teammates weigh what's said against what's plausible to guess which statement is false, and the interview structures require a real response to what a partner just said, not a scripted one -- but this is closer to a game mechanic than direct instruction in reading implied meaning, so it's worth surfacing rather than counted as real coverage.
• #2.4 Clean spelling, grammar, and formatting show up in both written and electronic communication.

  Unassigned

• #2.5 The same information often needs to reach different audiences, which means adapting the medium and format each time.

  Unassigned

• #2.6 Using digital media and communication tools safely, legally, and responsibly is expected, not optional.
  • Little Brother (a book by Cory Doctorow): Chapter 6 (Building Xnet, Learning Crypto), Chapter 7 (Hiding in Plain Ciphertext), Chapter 8 (The Paradox of the False Positive), Chapter 9 (Suspicion Spreads, Even to Dad), Chapter 10 (A Beach Key-Signing Party)
    Xnet's whole operational-security culture -- encrypting, staying anonymous, vetting who to trust -- is using digital communication tools safely, legally, and responsibly under real pressure, not as a classroom exercise.
• #2.7 Writing clearly and communicating well, especially with people outside your own background, is its own working skill.

  Unassigned

• #2.8 Serving a customer well starts from understanding what a customer-oriented approach actually looks like.

  Unassigned

#3.0 Career Planning and Management

Making good career decisions means pulling together career information from many different kinds of sources.

Unassigned

• #3.1 Knowing your own interests, aptitudes, and skills is the starting point for any real career decision.
  • porttack.com: SEL: Words That Built Our Classroom Community (partial)
    The source doc (written from the teacher's CTE-instructor role) frames the self-reflection as career-readiness groundwork -- knowing your own interests, aptitudes, and traits. Honest caveat: that's the doc's own career-pathway framing applied to a 6th-grade icebreaker, not something the lesson teaches on its own terms; keep this one at partial rather than strong.
• #3.2 Traits like trustworthiness, respect, and responsibility carry real weight in how a career turns out.

  Unassigned

• #3.3 Information and communication technologies themselves are tools people use to plan and decide on a career.

  Unassigned

• #3.4 Different careers demand different levels of education, training, certification, or licensing, and that's worth researching directly.

  Unassigned

• #3.5 A career plan has to account for shifting job trends, social needs, and the economy, not just personal preference.

  Unassigned

• #3.6 Professional organizations, industry groups, and labor unions all play a role in how a working society functions.

  Unassigned

• #3.7 Small businesses matter to both the California and the global economy.

  Unassigned

• #3.8 Employers and colleges increasingly look at a candidate's digital footprint when evaluating them.

  Unassigned

• #3.9 A career plan should reflect a person's actual interests, potential pathways, and options after high school.

  Unassigned

#4.0 Technology

Both existing and brand-new technology get used in the ICT workplace to research and produce information, products, and services.

Unassigned

• #4.1 Electronic references are a normal source for gathering information and building products or services.

  Unassigned

• #4.2 Technology-based communication tools can help unpack complicated systems and issues, when used responsibly.

  Unassigned

• #4.3 More than one source often needs to be pulled together, weighed against each other, and reconciled -- and information and communication technologies are the tools for doing that.

  Unassigned

• #4.4 Not all information found digitally is equally trustworthy, and spotting bias or intent in a source matters.

  Unassigned

• #4.5 Technology keeps changing, and tracking how it has, does, and will affect a given pathway is worth doing directly.
  • Student Movies: Unit hidden-figures (Hidden Figures) (partial)
    Technology keeps changing.
• #4.6 Different information and communication technologies serve different populations, and choosing the right one is part of the task.

  Unassigned

#5.0 Problem Solving and Critical Thinking

ICT problems get solved through research, ranging from quick lookups to sustained investigation, using critical and creative thinking.

Unassigned

• #5.1 Asking the right question, from more than one point of view, is often the first real step in solving a problem.
  • Bootstrap:Algebra: Chapter 2 (Coordinates), Chapter 5 (Simple Data Types), Chapter 13 (Functions Make Life Easier!), Chapter 14 (The Vertical Line Test) (partial)
    A Notice and Wonder page opens most lessons (Ninja Cat game, blank game starter, Functions, Linearity), a routine for asking questions about an unfamiliar system before using it.
• #5.2 Work problems don't always have a predictable shape, and different kinds of reasoning fit different situations.

  Unassigned

• #5.3 A complex work environment is a system, and understanding how its parts interact explains its outcomes.

  Unassigned

• #5.4 Drawing a sound conclusion from analysis is what actually informs a good decision.
  • Bootstrap:Data Science — Hour of Data: Unit 9 (Data-Informed Decision Making) (partial)
    Part 9 asks students to name the most dangerous road and mile marker from the charts, a conclusion drawn from analysis that would inform where to build a wildlife crossing.
• #5.5 Tracking a problem to its source takes a structured, logical approach, not guesswork.
  • Little Brother (a book by Cory Doctorow): Chapter 8 (The Paradox of the False Positive)
    The false-positive scene is Marcus tracking a surveillance system's actual failure mode to its mathematical source, a structured argument rather than a hunch.
  • MicroPython on Pi Pico and Projects: Chapter 5 (Traffic light controller) (related)
    Debugging a miswired breadboard circuit takes the same structured, methodical approach this standard describes, though the lesson doesn't teach the approach itself, just requires it.
  • Working in Python (a jupyter notebook): Chapter 5 (Conditionals and Recursion)
    Chapter 5's Debugging section traces a symptom back to its structural cause rather than guessing: an indentation error reported at one line but caused by the line above, a decibels bug reported at line 5 but actually on line 4 (integer division). Headers only -- the chapter demonstrates this but doesn't name it as its own skill.
• #5.6 Knowing where to look for help solving a problem is itself a resource worth knowing.

  Unassigned

• #5.7 Some problems get solved by working through them repeatedly, refining the approach each pass.
  • Student Movies: Unit big-hero-6 (Big Hero 6) (partial)
    Refining a solution on repeated passes.
  • porttack.com: Hardware: Kilo & Milli: Borrowing the Meter Stick to Teach Electrical Units (partial)
    The chaining exercise (converting across two steps by repeating the same divide/multiply-by-1000 rule) is a small, concrete instance of this standard's iterative problem-solving, as the post's own appendix already names.
  • Working in Python (a jupyter notebook): Chapter 7 (Iteration and Search)
    Chapter 7's has_e build-up (inline loop, then encapsulated, then a boolean return, then parameterized) and the incremental construction of uses_any mirror this standard's start-rough-and-refine framing -- the same pattern as AP's 3.9 Developing Algorithms, from the Anchor-standard side.
• #5.8 Algorithms are a tool for solving problems, not just an abstract concept.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 0 (Week 0: Scratch -- everything but data representation (computational thinking, abstraction, algorithms, pseudocode, Scratch constructs))
    Algorithms and Pseudocode, named week-0 topics, introduce algorithms as a general problem-solving tool before any specific language.
  • Student Movies: Unit the-wild-robot (The Wild Robot), Unit wall-e (WALL-E) (partial)
    Algorithms as a tool for solving problems.
• #5.9 A large problem becomes tractable once it's broken into smaller components.
  • Bootstrap:Algebra: Chapter 21 (Problem Decomposition)
    'Problem Decomposition' is this standard by name.
  • Carnegie Mellon's Introduction to Programming with Python (High School): Unit 3.3 (Helper Functions)
    This carrier's own inference: helper functions (3.3) is the same decomposition evidence as 9-12.AP.16 and 6-8.AP.13 above.
  • CodeHS' Intro to JavaScript: Unit 1 (Programming with Karel), Unit 2 (Karel Challenges) (partial)
    This carrier's own inference: Karel's top-down design (units 1-2) is the same decomposition evidence as 9-12.AP.16 above.
  • Code.org's CS Discoveries (Units 1-2): Unit 1 (Unit 1 - Problem Solving and Computing)
    This carrier's own inference: Unit 1's whole Problem Solving Process -- breaking a large, unfamiliar problem into smaller, tractable pieces -- is this anchor standard's own decomposition language almost verbatim.
  • Code.org's CS Discoveries (Unit 3a: Music Lab): Unit 3 (Unit 3a - Programming with Music Lab)
    This carrier's own inference: Music Lab's own 'Functions - Practice' objective ('decompose songs into specific parts by using functions strategically') is this anchor standard's own decomposition language, nearly word for word.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 2 (Week 2: Arrays), Unit 6 (Week 6: Python)
    Functions, named in both weeks, are breaking a large problem into smaller components.
  • Harvard's CS50-Python (Weeks 0-8): Unit 0 (Lecture 0: Functions, Variables, Strings, def), Unit 8 (Lecture 8: Object-Oriented Programming)
    Functions (week 0) and Classes (week 8) are both named ways of breaking a large problem into smaller components.
  • Student Movies: Unit closest-thing-to-alien-technology (The Closest Thing We Have to Alien Technology) (partial)
    Breaking a big problem into smaller parts.
  • TurtleLab Lessons: Unit step-1-your-initials (Step 1: Your initials), Unit step-5-random-art (Step 5: Capstone, random art), Unit step-12-capstone-2 (Step 12: Capstone 2, boxes and blocks) (partial)
    Step 1 breaks the initials into one letter at a time, and Step 5 breaks the capstone into a loop first, then random, then the if and else, running after each piece.
  • Working in Python (a jupyter notebook): Chapter 3 (Functions), Chapter 4 (Functions and Interfaces), Chapter 5 (Conditionals and Recursion)
    Chapter 3's 'Why functions?' section explicitly frames functions as a way to divide a big program into smaller, debuggable, reusable pieces -- a direct match. Chapter 4's development plan is a literal, numbered decomposition procedure. Chapter 5's recursive decomposition (countdown, the Sierpinski exercise splitting a triangle of degree n into three of degree n-1) is a purer instance of the same idea.
• #5.10 Layers of abstraction let you work with a system without tracking every detail underneath it.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 0 (Week 0: Scratch -- everything but data representation (computational thinking, abstraction, algorithms, pseudocode, Scratch constructs)), Unit 1 (Week 1: C), Unit 5 (Week 5: Data Structures)
    Abstraction is a named week-0 topic; the Source Code/Compiler/Machine Code pipeline (week 1) and Abstract Data Types (week 5) are both layers that let you work with a system without tracking every detail underneath.
  • Harvard's CS50-Python (Weeks 0-8): Unit 4 (Lecture 4: Libraries), Unit 8 (Lecture 8: Object-Oriented Programming)
    Using a Library (week 4) without tracking its internals, and a Class's own encapsulation (week 8), are both this standard's abstraction-layer claim.
  • Working in Python (a jupyter notebook): Chapter 3 (Functions), Chapter 4 (Functions and Interfaces), Chapter 6 (Return Values)
    Calling repeat/print_twice without re-deriving what's inside them is a first, light instance of working through a layer of abstraction -- headers only, since the book doesn't use the word 'abstraction' this early and the connection is implicit. Chapter 4's interface/implementation split (two different circle implementations sharing one interface) makes the concept explicit for the first time. Chapter 6's leap of faith -- trusting a function's return value without re-examining its body -- is the clearest, most direct treatment of abstraction in the book so far.
• #5.11 Numbers can be represented in more than one base system, including binary and hexadecimal.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 0 (Week 0: Scratch -- data representation only (unary, binary, decimal, ASCII, Unicode, RGB)), Unit 4 (Week 4: Memory -- data representation only (hexadecimal, images, file I/O))
    Base conversion -- unary/binary/decimal (week 0), hexadecimal (week 4) -- is this anchor standard by name.
  • MicroPython on Pi Pico and Projects: Chapter 10 (Digital communication protocols: I2C and SPI), Chapter 12 (Bluetooth connectivity) (partial)
    Chapter 10's HEXADECIMAL aside directly explains base-16 notation for I2C addresses. Chapter 12 uses hexadecimal UUIDs (0x181A, 0x2A6E) for BLE service and characteristic identifiers, converting one to decimal by hand as an example.
  • Pico Projects: Chapter p1.4 (Project 1.4: Blinking Your LEDs) (partial)
    Project 1.4's binary-counting challenge is a sustained, hands-on exercise in base-2 representation rather than a passing aside: place values and a count from 0 to 7, worked out across three physical LEDs.
  • porttack.com: Coding: Teaching Binary With Coins
    The anchor standard's own paraphrase, 'numbers can be represented in more than one base system, including binary and hexadecimal,' is close to a one-line summary of this whole lesson -- the coin-store base-2 conversion, then the byte-to-hex split in the last section.
  • CS Unplugged: Count the Dots: binary numbers, Secret Messages in ASCII
    Numbers in base 10 and base 2 (Count the Dots); hexadecimal isn't covered. ASCII uses the same binary numbers for character codes (partial on its own).
• #5.12 Boolean logic underlies both decision-making and searching in computing.
  • Bootstrap:Algebra: Chapter 22 (Simple Inequalities), Chapter 23 (Compound Inequalities: Solutions & Non-Solutions) (partial)
    Inequalities and compound inequalities are Boolean logic used to make decisions; searching is not part of the course.
  • Code.org's CS Discoveries (Unit 3b: Animations & Games): Unit 4 (Unit 3b - Interactive Animations and Games)
    This carrier's own inference: Unit 3b's 'Conditionals' lesson is this anchor standard's own Boolean-logic-underlies-decision-making territory.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 3 (Week 3: Algorithms (searching, sorting, asymptotic notation, recursion))
    Binary Search depends on the Boolean comparison at each step (higher/lower/found).
  • Little Brother (a book by Cory Doctorow): Chapter 8 (The Paradox of the False Positive)
    The single cleanest match in this file: the paradox of the false positive is Boolean-logic-style search and decision-making (does this trait mean 'terrorist,' yes or no, applied to millions of people) taken apart in the book's own words.
  • MicroPython on Pi Pico and Projects: Chapter 6 (Reaction game) (related)
    The winner-decision logic is boolean comparisons (is left_btn / is right_btn), though the lesson doesn't discuss boolean logic as a topic in its own right.
  • Pico Projects: Chapter p1.7 (Project 1.7: Reading Your Switches)
    The switch-watching loop's if v1 != last1 or v2 != last2 or v3 != last3 condition is boolean logic driving a decision, three comparisons combined with or -- the same underlying idea chapter 6's winner-decision logic uses, now built by students instead of read.
  • Working in Python (a jupyter notebook): Chapter 5 (Conditionals and Recursion), Chapter 7 (Iteration and Search), Chapter 8 (Strings and Regular Expressions)
    Chapter 5's boolean expressions and logical operators feed directly into its if statements -- boolean logic driving decision-making is the chapter's structure, not just present in it. Chapter 7's has_e/uses_any (booleans built from in/or) driving linear search, and Chapter 8's re.search result tested against None, are the searching half of the same standard -- the single best new match found in either chapter.

#6.0 Health and Safety

ICT work environments come with their own health and safety procedures, and their own specialized vocabulary.

Unassigned

• #6.1 Material Safety Data Sheets exist to be located and followed.

  Unassigned

• #6.2 Workplace policies and regulations spell out what employers and employees are each responsible for.

  Unassigned

• #6.3 Keeping tools, equipment, and supplies stored, clean, and in working order is itself a health and safety practice.

  Unassigned

• #6.4 Lifting, bending, and moving equipment safely protects the person doing it.

  Unassigned

• #6.5 Preventing and responding to workplace accidents includes understanding ergonomics.

  Unassigned

• #6.6 A safe, healthy workplace has to be actively maintained, not just assumed.

  Unassigned

• #6.7 OSHA laws and regulations apply to this workplace and are worth knowing.

  Unassigned

• #6.8 Maintaining safety and health in the workplace is an ongoing responsibility, restated here as its own point.

  Unassigned

• #6.9 E-waste carries health, environmental, and legal risk if it isn't disposed of properly.

  Unassigned

• #6.10 Using natural resources like paper and ink deliberately, not wastefully, is a workplace habit.

  Unassigned

• #6.11 Conserving energy while computing -- powering down equipment, using power-saving settings -- is a small but real practice.

  Unassigned

#7.0 Responsibility and Flexibility

Working in the ICT sector means collaborating in ways that show personal and professional responsibility, flexibility, and respect.

Unassigned

• #7.1 Financial management choices ripple outward into the economy, the workforce, and the community.

  Unassigned

• #7.2 Following through on your role -- whether it's personal, in your community, or at work -- takes real accountability.

  Unassigned

• #7.3 Roles and responsibilities shift over time, and adapting to that is part of the job.

  Unassigned

• #7.4 Managing time efficiently is what actually lets responsibilities get fulfilled.

  Unassigned

• #7.5 High-quality work applies to how a product or presentation is designed, not just built.

  Unassigned

• #7.6 Responsible financial management is a skill in its own right, not just a personal habit.

  Unassigned

• #7.7 A professional work demeanor includes both behavior and appropriate attire for the field.

  Unassigned

• #7.8 Issues with global reach touch the ICT sector too, and documenting that impact is worth doing.

  Unassigned

#8.0 Ethics and Legal Responsibilities

Professional, ethical, legal behavior means responding thoughtfully to different perspectives and following applicable laws, regulations, and norms.

Unassigned

• #8.1 Quality assurance standards exist to be understood and actually put into practice.

  Unassigned

• #8.2 Regulatory agencies at every level of government have their own laws and regulations covering this sector.

  Unassigned

• #8.3 Ethical, legal practice in ICT means matching the workplace standards the sector has set.

  Unassigned

• #8.4 Personal integrity, confidentiality, and ethical behavior matter directly to how a workplace functions.
  • Student Movies: Unit sneakers (Sneakers), Unit the-social-network (The Social Network) (partial)
    Integrity and confidentiality.
  • porttack.com: SEL: Words That Built Our Classroom Community (partial)
    The lesson's own "safe space" rule -- share only what you're comfortable with, use a private code word if needed, never comment on someone else's choice -- is a real, age-appropriate version of this standard's confidentiality/personal-integrity concern, even though the standard itself is written for a workplace.
  • porttack.com: Society (Impact of Computing): Prove Me Wrong: A Socratic Seminar on AI and Cheating (partial)
    Personal integrity and ethical behavior is this standard's workplace framing of the same academic-honesty question the seminar raises about AI use, applied to a classroom rather than a job.
• #8.5 An organization's culture and practices shape its whole working environment.

  Unassigned

• #8.6 Copyright and intellectual property law apply to proprietary information, including how it gets cited.
  • Code.org's CS Discoveries (Units 1-2): Unit 2 (Unit 2 - Web Development)
    This carrier's own inference: Unit 2's 'Intellectual Property' lesson is this anchor standard's own copyright/citation territory, taught here for a student audience rather than a workplace one.
  • Little Brother (a book by Cory Doctorow): Chapter intro (Introduction)
    The book's own Creative Commons license, printed in full in the Introduction, is copyright and intellectual property law applied directly, including how to cite and reuse the work.
• #8.7 Confidential information comes with its own rules about who it can be shared with.

  Unassigned

• #8.8 Wider technology adoption has brought its own legal and ethical problems, including hacking, scams, and privacy breaches.
  • Little Brother (a book by Cory Doctorow): Chapter intro (Introduction), Chapter epilogue (Epilogue)
    The whole novel is wider technology adoption's own legal and ethical problems -- hacking, government overreach, privacy breaches -- bookended by the Introduction's framing and the Epilogue's reckoning. Cited here directly rather than de-emphasized as too generic, since unlike a programming-course carrier, this book has no Pathway C content to prefer instead.
  • Student Movies: Unit sneakers (Sneakers), Unit wargames (WarGames), Unit the-social-network (The Social Network) (partial)
    Hacking and scams are legal and ethical problems.

#9.0 Leadership and Teamwork

Working with peers means engaging with different perspectives, leadership styles, group dynamics, and resolving conflict productively.

Unassigned

• #9.1 Good leaders share a recognizable set of responsibilities, competencies, and behaviors.

  Unassigned

• #9.2 Successful teams share traits: leadership, cooperation, collaboration, and sound decision-making.
  • Kagan Cooperative Learning — Classbuilding: Unit Corners (Corners), Unit Similarity Groups (Similarity Groups) (related)
    These involve group discussion and shared reasoning, which touches on the cooperation/decision-making traits 9.2 names, but classbuilding groupings are ad hoc and whole-class, not the stable, role-differentiated teams 9.2 is really describing -- worth surfacing, not counted as real team-decision-making coverage.
  • Kagan Cooperative Learning — Teambuilding: Unit RoundRobin (RoundRobin), Unit RoundTable (RoundTable), Unit Placemat Consensus (Placemat Consensus), Unit Fan-N-Pick (Fan-N-Pick), Unit Team Statements (Team Statements) (related)
    RoundRobin/RoundTable's equal turns, Fan-N-Pick's rotating roles, and Placemat Consensus/Team Statements' individual-input-to-group-decision arc all put students through the behaviors this standard names -- cooperation, rotating leadership, consensus. But none of it is taught or named as content; a student practices the trait by doing the structure, without the structure ever explaining what a team trait is or why it matters. That's support for the standard, not coverage of it.
  • Student Movies: Unit spare-parts (Spare Parts) (partial)
    Successful teams share recognizable traits.
• #9.3 Teamwork, leadership, and citizenship matter in school, community, and workplace settings alike.
  • Kagan Cooperative Learning — Classbuilding: Unit Corners (Corners), Unit Line-Ups (Line-Ups), Unit Similarity Groups (Similarity Groups), Unit Mix-Freeze-Group (Mix-Freeze-Group) (related)
    Classbuilding's own stated purpose -- improving whole-class climate -- touches 9.3's scope ("school, community" settings, not just workplace teams), and Corners/Line-Ups/Similarity Groups do have the class sort itself by a trait and discuss across the grouping. But none of it is instruction connecting that experience to citizenship or teamwork as a concept -- students do the sorting and discussing, nothing in the structure names why it matters, which keeps this at related rather than a taught match.
  • Kagan Cooperative Learning — Teambuilding: Unit Team Projects (Team Projects), Unit Team Formations (Team Formations) (related)
    Team Projects and Team Formations have the whole team coordinate on a shared build, which is the general shape of teamwork this standard names, and the book's own preface draws an explicit line to workplace teams. But that line is teacher-facing front matter, not something a student encounters -- students experience the coordination itself, not instruction connecting it to school/community/workplace citizenship.
• #9.4 Being part of a professional organization, or competing in career-development events, can genuinely sharpen academic preparation and open career doors.

  Unassigned

• #9.5 Today's world is interconnected, and that calls for a genuinely global outlook.
  • Student Movies: Unit closest-thing-to-alien-technology (The Closest Thing We Have to Alien Technology) (partial)
    A global outlook.
• #9.6 Respecting individual and cultural differences is part of valuing diversity in the workplace.
  • Bootstrap:Algebra: Chapter 1 (Computing Needs All Voices)
    'Computing Needs All Voices' is about valuing diverse perspectives in computing: a film and posters of pioneers, a Windows and Mirrors reflection and the article on why diverse teams have an advantage.
  • Kagan Cooperative Learning — Classbuilding: Unit Corners (Corners), Unit Find Someone Who (Find Someone Who), Unit Similarity Groups (Similarity Groups), Unit Who Am I? (Who Am I?) (related)
    These structures only work because classmates differ, and the preface names celebrating "the diversity of every other classmate" as a goal -- but what students actually do is trade trivia and sort by preference, not engage with the standard's own frame of respecting individual and cultural differences in a workplace. Worth surfacing for the shared theme, not close enough to call taught.
  • Kagan Cooperative Learning — Teambuilding: Unit Team Interview (Team Interview), Unit Three-Step Interview (Three-Step Interview), Unit Pairs Compare (Pairs Compare), Unit Team Statements (Team Statements), Unit Find-the-Fiction (Find-the-Fiction) (related)
    "Valuing Differences" is one of the book's own named Five Aims, and these interview-style structures are built to surface personal differences between teammates -- but that means classmates trading trivia about favorite movies and weekend plans, not the standard's own frame of respecting individual and cultural differences in a workplace. Close enough in spirit to surface, not close enough to call taught.
  • Student Movies: Unit the-imitation-game (The Imitation Game), Unit hidden-figures (Hidden Figures) (partial)
    Respecting individual and cultural differences.
  • porttack.com: SEL: Words That Built Our Classroom Community (partial)
    "Respect individual and cultural differences" is a workplace-diversity standard; the word wall's display of classmates' varied cultural/personal identities is a middle-school-scale analog of it, not a direct instance.
• #9.7 Real ICT-sector problems get solved through active, interactive teamwork.
  • Kagan Cooperative Learning — Teambuilding: Unit Team Projects (Team Projects) (related)
    Team Projects has a team solve a shared task through assigned roles and active back-and-forth, which is the general shape 9.7 describes, but the book's projects (build a team tower, invent something from pipe cleaners, solve a puzzle) are generic classroom tasks, not ICT-sector work -- worth noting as a transferable skill-builder, not sector-specific coverage.

#10.0 Technical Knowledge and Skills

Every pathway in this sector draws on the same core toolkit of hands-on know-how, put into practice by following procedure carefully.

Unassigned

• #10.1 The ICT sector has its own terminology and practices worth being able to interpret and explain.

  Unassigned

• #10.2 Every corner of the ICT sector comes with its own rules, regulations, and expectations to follow.

  Unassigned

• #10.3 Projects and products in this sector have their own specific requirements and expectations to build toward.

  Unassigned

• #10.4 Working with industry experts is a real way to gain specific technical knowledge and skill.

  Unassigned

• #10.5 Both a single computer and a network are built from hardware and software parts that depend on each other.
  • Student Movies: Unit closest-thing-to-alien-technology (The Closest Thing We Have to Alien Technology) (related)
    Hardware and software depend on each other.
• #10.6 Different kinds of information -- text, images, sound, video -- take up different amounts of data, and media formats vary in capacity.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 0 (Week 0: Scratch -- data representation only (unary, binary, decimal, ASCII, Unicode, RGB)), Unit 4 (Week 4: Memory -- data representation only (hexadecimal, images, file I/O))
    RGB (week 0) and Images/file I/O (week 4) are concrete cases of different media taking different amounts of data to represent.
  • CS Unplugged: Pixel Pictures (related)
    Counting how many bits a page of pixels takes, and how many fewer run-length encoding needs.
• #10.7 Metric prefixes like kilo, mega, giga, and tera describe scale throughout computing.
  • Student Movies: Unit closest-thing-to-alien-technology (The Closest Thing We Have to Alien Technology) (related)
    Metric prefixes describe scale.
  • MicroPython on Pi Pico and Projects: Chapter 9 (Data logger) (partial)
    The FILE STORAGE aside works entirely in bytes and MiB to figure out how long the logger can run before filling the Pico's storage -- a real, worked use of metric prefixes, though it's one aside rather than a running theme.
  • porttack.com: Hardware: Kilo & Milli: Borrowing the Meter Stick to Teach Electrical Units
    Direct quote match, named in the post's own appendix: the standard's 'kilo, mega, giga, and tera' examples are written with data sizes in mind, but the competency -- fluency with SI prefixes as a scale factor -- is exactly what this lesson teaches, applied to volts/amps/ohms instead.
• #10.8 Security in computing rests on concepts like authorization, access rights, and encryption.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 2 (Week 2: Arrays)
    Cryptography, a named week-2 topic, is this standard's own 'encryption' concept.
  • Student Movies: Unit sneakers (Sneakers), Unit wargames (WarGames) (partial)
    Authorization, access rights, encryption.
  • MicroPython on Pi Pico and Projects: Chapter 11 (Wi-Fi connectivity) (partial)
    The lesson touches on private-versus-public IP addressing and explains what https:// buys you over plain http://, but doesn't get into authorization or access rights specifically.
  • CS Unplugged: Caesar Cipher (related)
    Encryption with a shared key, at an introductory level.
• #10.9 Industry-standard software -- word processors, spreadsheets, databases, multimedia tools -- are common working tools.

  Unassigned

• #10.10 Files get organized and managed within a hierarchical system.
  • MicroPython on Pi Pico and Projects: Chapter 9 (Data logger)
    The data logger reads, writes, and appends files on the Pico's own filesystem, and main.py's special auto-run behavior is part of how that filesystem is organized.
  • Pico Projects: Chapter p1.3 (Project 1.3: Files on Your Pico, and Your First REPL Commands)
    Project 1.3 introduces the basic idea underneath chapter 9's own data logger: Thonny shows two entirely separate file panels, This computer and Raspberry Pi Pico, and a script has to be saved to the Pico's own storage, not the computer's, to actually run there.
• #10.11 Text, data, sound, video, and images can all move from one software program or system to another, and there's more than one route for doing it.

  Unassigned

• #10.12 Different kinds of information call for different search strategies.

  Unassigned

• #10.13 Retrieved information should be checked for accuracy, relevance, and completeness.
  • Bootstrap:Data Science — Hour of Data: Unit 4 (Scatter Plots, Outliers & Human Error), Unit 7 (Patterns in the Code — More Subsets & Pie Charts via Filtering) (partial)
    Part 4's human-error argument and Part 7's 50% 'unknown' turtles are both checking retrieved information for accuracy and completeness before trusting it.
• #10.14 Online resources can meaningfully support collaboration, research, publishing, communication, and productivity -- or fail to.

  Unassigned

#11.0 Demonstration and Application

The knowledge and skills named across this sector's anchor and pathway standards get demonstrated directly, in classrooms, labs, and real workplace settings.

Unassigned

• #11.1 Work-based learning experiences extend and apply what's learned in the classroom and lab.

  Unassigned

• #11.2 Getting genuinely good at a technical pathway is what actually opens the door to certification, licensure, or further study.

  Unassigned

• #11.3 Entrepreneurship, self-employment, and new ventures are all real options worth understanding.

  Unassigned

• #11.4 Entrepreneurial practices and behaviors apply specifically within ICT-sector opportunities.

  Unassigned

• #11.5 A portfolio is one way to show evidence of the skills and knowledge named in these standards.

  Unassigned

#C1.0 Systems Development Process

Building software well means following a real systems-development process, not improvising.

Unassigned

• #C1.1 A systems-development life cycle moves through recognizable phases: analysis, design, programming, testing, deployment, maintenance, and improvement.

  Unassigned

• #C1.2 Systems development can follow different models, including a traditional life-cycle approach or agile methods.

  Unassigned

• #C1.3 Specifications and requirements for a piece of software, new or existing, get developed through a real process.

  Unassigned

• #C1.4 Working on a development team means operating within that team's defined scope and boundaries.

  Unassigned

• #C1.5 Versioning is how a project's milestones get tracked over time.

  Unassigned

• #C1.6 Flowcharts and UML are tools for diagramming a process.

  Unassigned

#C2.0 Requirements Analysis

Software and systems requirements need to be defined and analyzed before building starts.

Unassigned

• #C2.1 Development work serves different ends: automating a task, making people more productive, building a model to analyze something, or simply entertaining.

  Unassigned

• #C2.2 Development work can have unintended consequences -- bugs, security holes, health or environmental risk, privacy problems -- that are worth watching for and preventing.
  • Code.org's AP CSP (Units 1,2,5,8,10): Unit 10 (Unit 10: Cybersecurity and Global Impacts)
    This carrier's own inference: the unit's privacy/security risk discussion is this standard's own 'unintended consequences' framing, though the standard is written for a development-team context this unit doesn't have.
  • CS50 Problems: Unit 5 (Caesar) (related)
    Caesar: headers only -- the cipher touches basic security concepts without the problem asking students to reason about them directly.
• #C2.3 A development strategy should target what a specific customer actually needs and wants.

  Unassigned

• #C2.4 Understanding a customer's needs is a distinct analytical step in development.

  Unassigned

• #C2.5 Requirements and possible solutions both need to be worked out and written down before they can be built.

  Unassigned

#C3.0 Human-Computer Interfaces

The interface between a person and a piece of technology is itself something to design well.

Unassigned

• #C3.1 Every interface runs on the same basic cycle: input, processing, output.

  Unassigned

• #C3.2 A good interface reflects real knowledge of how people think, move, and interact socially.

  Unassigned

• #C3.3 Accessibility -- for users with disabilities and users who don't speak English -- has to be actively supported, not assumed.

  Unassigned

#C4.0 Programming Languages

Software gets built in a programming language, and that language sits at some level of abstraction.

Unassigned

• #C4.1 Programming languages range from low-level, close to the hardware, to high-level and web-based.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 1 (Week 1: C), Unit 6 (Week 6: Python)
    C (week 1) and Python (week 6) are named, back-to-back, as this teacher's own low-level-to-high-level range.
  • MicroPython on Pi Pico and Projects: Chapter 10 (Digital communication protocols: I2C and SPI) (partial)
    I2C and SPI are low-level hardware protocols; the ssd1306.py driver sits above them as a higher-level interface the program actually calls -- touches the standard's low-level-to-high-level spectrum without discussing it as a spectrum.
• #C4.2 Programming languages and protocols interact -- client-side code, server-side code, and a query language reaching into a database are all pieces of the same system.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 8 (Week 8: HTML, CSS, JavaScript), Unit 9 (Week 9: Flask)
    JavaScript (client-side), Flask (server-side), and SQL (query language) interacting is this standard's own example, and is literally how weeks 7-9 fit together.
  • MicroPython on Pi Pico and Projects: Chapter 11 (Wi-Fi connectivity) (partial)
    The chapter has the Pico act as an HTTP client (making GET requests) and, separately, as an HTTP server (hosting its own page) -- a real client-side/server-side round trip, though the lesson doesn't frame the two roles as one system.
• #C4.3 Software gets built inside some kind of environment -- a simple content editor on one end, a full-featured IDE on the other.
  • MicroPython on Pi Pico and Projects: Chapter 2 (Programming with MicroPython) (partial)
    Chapter 2 (in both its Thonny and ViperIDE forms) is entirely about working inside a development environment, though the lesson doesn't compare it against a bare content editor the way the standard frames the spectrum.
  • Pico Projects: Chapter p1.2 (Project 1.2: Flashing MicroPython with Thonny) (partial)
    Project 1.2 is a step earlier than chapter 2's own development-environment lessons: provisioning that environment in the first place, flashing MicroPython firmware and confirming Thonny shows the device connected, before any of chapter 2's lessons ever put it to use.
• #C4.4 Data has types, and those types get encoded in specific ways.
  • Bootstrap:Algebra: Chapter 5 (Simple Data Types), Chapter 7 (Contracts for Strings and Images)
    Data types and the contracts that name them are the middle of 'Simple Data Types' and 'Contracts for Strings and Images'.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 1 (Week 1: C)
    Types is a named week-1 topic; Integer Overflow and Floating-Point Imprecision are what it means for a type to have a specific encoding with real limits.
  • CS50 Problems: Unit 2 (Pathfinder), Unit 5 (Caesar)
    Pathfinder and Caesar both convert data between representations (hex byte to character, letter to shift number) -- data has types, and those types get encoded in specific ways.
  • MicroPython on Pi Pico and Projects: Chapter 12 (Bluetooth connectivity)
    struct.pack and struct.unpack encode a floating-point temperature into a specific binary layout and decode it back on the other end -- a direct, hands-on example of data having a type and that type being encoded in a specific way.
  • CS Unplugged: Secret Messages in ASCII (partial)
    Text is encoded as numbers and then bits; the same bits can be read as a number or a letter.
  • Working in Python (a jupyter notebook): Chapter 1 (Welcome), Chapter 6 (Return Values)
    Chapter 1 introduces int, float, and str as distinct types with different encodings, and the type() function to check them -- a direct match. Chapter 6's Checking types section (isinstance, a type-guarded factorial) extends it with a second, applied instance -- checking a type at runtime, not just naming types.
• #C4.5 Programming paradigms differ -- procedural, object-oriented, event-driven, multithreaded -- and each shapes how code gets structured.
  • Bootstrap:Algebra: Chapter 24 (Sam the Butterfly — Applying Inequalities), Chapter 26 (Player Animation) (partial)
    Sam moves with the arrow keys and update-player is chosen by which key was pressed, which is event-driven code, but the event loop is supplied by the starter file.
  • Harvard's CS50-Python (Weeks 0-8): Unit 8 (Lecture 8: Object-Oriented Programming)
    Object-Oriented Programming is this standard's own named paradigm example, in the week's own heading.
  • MicroPython on Pi Pico and Projects: Chapter 5 (Traffic light controller), Chapter 6 (Reaction game), Chapter 7 (Burglar alarm), Chapter 12 (Bluetooth connectivity)
    Chapters 5, 6, and 7 are hands-on examples of the event-driven paradigm this standard names, in contrast to the purely procedural style of earlier chapters. Chapter 12's asyncio coroutines and tasks are a software-level instance of the same paradigm, running concurrently rather than start to finish.
• #C4.6 Every programming language has its own syntax, and using it correctly matters.
  • Bootstrap:Algebra: Chapter 5 (Simple Data Types), Chapter 6 (Order of Operations)
    Pyret's own strict syntax is the subject of Simple Data Types: quotes on strings, a leading zero on decimals, spaces around operators, parentheses required for mixed operators, with error messages read on purpose.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 1 (Week 1: C)
    Syntax Highlighting, a named week-1 topic (in VS Code), foregrounds that C has its own syntax to use correctly.
  • MicroPython on Pi Pico and Projects: Chapter 2 (Programming with MicroPython)
    Chapter 2's SYNTAX ERROR callout is a direct example of this standard: Python has its own syntax, and a misspelled keyword or missing quotation mark stops the program from running at all.
  • Working in Python (a jupyter notebook): Chapter 1 (Welcome), Chapter 2 (Variables and Statements)
    Chapter 1 introduces syntax errors (missing parentheses, illegal quote marks); Chapter 2's Debugging section explicitly names 'syntax error' as one of three error kinds. Both are about a language's own syntax rules, matching this standard directly.
• #C4.7 Data structures, arrays, objects, files, and databases are all ways of organizing a program's data.
  • Carnegie Mellon's AP CSP in Python: Unit 3 (Unit 3: Groups, Lists, and Loops)
    This carrier's own inference: Groups and Lists (Unit 3) are the data-structure content this standard names.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 2 (Week 2: Arrays), Unit 5 (Week 5: Data Structures)
    Arrays (week 2) and the named data structures (week 5) are this standard's own list of ways to organize a program's data.
  • Harvard's CS50-Python (Weeks 0-8): Unit 2 (Lecture 2: Loops, Lists, Dictionaries), Unit 6 (Lecture 6: File I/O)
    Lists and Dictionaries (week 2) and Files (week 6) are named ways of organizing a program's data.
  • Working in Python (a jupyter notebook): Chapter 8 (Strings and Regular Expressions), Chapter 9 (Lists), Chapter 10 (Dictionaries), Chapter 11 (Tuples), Chapter 13 (Files and Databases)
    Chapter 8's Writing files section (open, read mode vs 'w' mode, close) is a direct match for this standard's 'files' item. Chapters 9 (lists), 10 (dictionaries), 11 (tuples), and 13 (files and shelve-based key-value storage) extend it to the 'data structures' and 'databases' items -- in sequence, this book's treatment of every structure this standard names except objects.
• #C4.8 Object-oriented programming brings its own vocabulary: objects, properties, methods, inheritance.
  • Harvard's CS50-Python (Weeks 0-8): Unit 8 (Lecture 8: Object-Oriented Programming)
    Classes, Inheritance, Class Methods, Static Methods, and Operator Overloading -- all named week-8 headings -- are this standard's own OOP vocabulary list.
• #C4.9 A working program leans on a shared toolkit of constructs -- branches and loops, reusable procedures and functions that take parameters, variables to hold state, ways to recover from errors, and sometimes a function that calls itself.
  • Bootstrap:Algebra: Chapter 13 (Functions Make Life Easier!), Chapter 25 (Piecewise Functions and Conditionals) (partial)
    Functions with parameters, branches and named values are in; loops and error recovery are not.
  • Carnegie Mellon's Introduction to Programming with Python (High School): Unit 2.1 (Functions), Unit 3.2 (Conditionals (if Statements)), Unit 7.3 (For Loops)
    This carrier's own inference: functions (2.1), conditionals (3.2), and for loops (7.3) are the branches-loops-procedures-with-parameters-and-variables toolkit this standard names, taught across nearly the whole course.
  • Carnegie Mellon's AP CSP in Python: Unit 2 (Unit 2: Functions, Mouse Events, Conditionals), Unit 3 (Unit 3: Groups, Lists, and Loops), Unit 4 (Unit 4: Complex Conditionals, More Events, and Libraries)
    This carrier's own inference, quoting the standard's own language: 'a shared toolkit of constructs -- branches and loops, reusable functions' is exactly Units 2-4's Conditionals, Loops, and Functions content.
  • CodeHS' Intro to JavaScript: Unit 1 (Programming with Karel), Unit 6 (JavaScript Control Structures), Unit 8 (Functions) (partial)
    This carrier's own inference: control flow and conditionals in Karel (1) and JavaScript Control Structures (6), plus functions with parameters (8), are the branches-loops-procedures toolkit this standard names.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 1 (Week 1: C), Unit 6 (Week 6: Python)
    Conditionals, Loops, and Functions -- named in both weeks -- are the shared toolkit this standard describes.
  • Harvard's CS50-Python (Weeks 0-8): Unit 0 (Lecture 0: Functions, Variables, Strings, def), Unit 1 (Lecture 1: Conditionals), Unit 2 (Lecture 2: Loops, Lists, Dictionaries)
    Functions (week 0), Conditionals (week 1), and Loops (week 2) are named instances of this standard's shared programming toolkit.
  • CS50 Problems: Unit 1 (Mario (less comfortable)), Unit 3 (Palindromes), Unit 4 (Square), Unit 5 (Caesar), Unit 7 (Readability), Unit 8 (Battery Gauge), Unit 11 (Inheritance)
    Mario, Palindromes, Square, Caesar, and Readability all lean on the same programming toolkit (loops, conditionals, functions with parameters) this standard names. Battery Gauge adds the toolkit's "ways to recover from errors" clause (its try/except retry loop), not demonstrated by any of the first six psets; Inheritance adds "a function that calls itself" (create_family and print_family are both recursive).
  • MicroPython on Pi Pico and Projects: Chapter 2 (Programming with MicroPython), Chapter 4 (Physical computing with Raspberry Pi Pico), Chapter 6 (Reaction game), Chapter 7 (Burglar alarm)
    Chapter 2 introduces the basic toolkit -- branches, loops, variables. Chapter 4 exercises loops and conditionals together for the first time on real hardware. Chapter 6 exercises the full toolkit in one lesson: branches, loops, a reusable procedure that takes a parameter, and state-holding variables. Chapter 7 adds a second reusable, parameterized procedure (the shared interrupt handler) on top of the same toolkit.
  • Pico Projects: Chapter p1.7 (Project 1.7: Reading Your Switches), Chapter p1.8 (Project 1.8: Choosing a Program with Imports), Chapter p2.1 (Project 2.1: Moving a Servo)
    Project 1.7 combines a loop with a compound conditional to watch three switches at once. Project 1.8 adds elif chaining and reuses functions already written in leds.py rather than rewriting them. Project 2.1's setangle and sweep are reusable procedures built from that same toolkit.
  • TurtleLab Lessons: Unit step-2-say-it-once (Step 2: Say it once), Unit step-4-choose-a-path (Step 4: Choose a path), Unit step-5-random-art (Step 5: Capstone, random art), Unit step-6-boxes (Step 6: Variables, boxes that keep a number), Unit step-7-boxes-that-count (Step 7: Boxes that count), Unit step-8-teach-the-turtle-a-word (Step 8: Teach the turtle a word), Unit step-9-a-loop-inside-a-loop (Step 9: A loop inside a loop) (partial)
    Loops are Step 2 and branches are Step 4, and the capstones use them. Steps 6 and 7 teach variables (boxes), Step 8 teaches procedures (blocks of your own with an input), and Step 9 puts a loop inside a loop. Together they cover loops, branches, variables and procedures in simple programs.
  • Working in Python (a jupyter notebook): Chapter 2 (Variables and Statements), Chapter 3 (Functions), Chapter 4 (Functions and Interfaces), Chapter 5 (Conditionals and Recursion), Chapter 6 (Return Values), Chapter 7 (Iteration and Search), Chapter 8 (Strings and Regular Expressions)
    Chapter 2 introduces variables; Chapter 3 introduces functions, parameters, and the for loop, plus error handling via %%expect. Chapter 4 adds keyword arguments and more parameter work than chapters 2-3 combined. Chapter 5 adds branches (conditionals) and Chapter 6 adds recursion -- 'sometimes a function that calls itself' is this standard's own closing phrase, and Chapter 6's factorial/fibonacci are exactly that. Chapter 7 reinforces variables-holding-state (Updating variables) and a second error-recovery demo. Chapter 8 adds branch-on-condition file-reading loops and TypeError/IndexError recovery. By chapter 8 this standard's full construct list is covered.
• #C4.10 Different queueing, sorting, and searching algorithms trade off differently against each other.
  • Code.org's AP CSP (Units 1,2,5,8,10): Unit 6 (Unit 6: Algorithms)
    This carrier's own inference, quoting the standard's own language: 'different queueing, sorting, and searching algorithms trade off differently' is this unit's own efficiency-comparison content.
  • CS50 Problems: Unit 10 (Lineup (more comfortable))
    Lineup (more comfortable)'s central point is exactly this trade-off: a queue built on deque instead of a plain list. Lineup (less comfortable) introduces the queue itself but doesn't compare it against an alternative implementation, so it isn't cited here.
  • Working in Python (a jupyter notebook): Chapter 7 (Iteration and Search)
    Chapter 7's Search section explicitly names and builds the linear-search pattern -- the searching half of this standard. The trade-off half isn't reached; no second search algorithm exists yet to compare it against. Headers only.
• #C4.11 Development work needs documentation aimed at more than one audience -- comments for other programmers, manuals for users.
  • Bootstrap:Algebra: Chapter 7 (Contracts for Strings and Images), Chapter 16 (Functions: Contracts, Examples & Definitions), Chapter 19 (Solving Word Problems with the Design Recipe)
    Contracts, purpose statements and examples are documentation for another reader, # comments are introduced with the flag lessons, and the workbook asks students to improve a purpose statement for a teammate.
  • Working in Python (a jupyter notebook): Chapter 2 (Variables and Statements), Chapter 4 (Functions and Interfaces)
    Chapter 2's Comments section is the 'comments for other programmers' half of this standard. Chapter 4's Docstrings section is a more formal instance of the same half -- a documented contract rather than a plain comment, so a distinct but related carrier, not a repeat. The 'manuals for users' half still isn't addressed anywhere.

#C5.0 Testing & Debugging

Software has to be tested, debugged, and improved, not just written.

Unassigned

• #C5.1 Reliable, effective, efficient software shares recognizable characteristics.

  Unassigned

• #C5.2 A program sometimes has to change because its own specification changed, or because the technology around it moved on.

  Unassigned

• #C5.3 Code can be optimized deliberately for better performance.
  • Working in Python (a jupyter notebook): Chapter 10 (Dictionaries)
    Same evidence as this file's new apcsp 3.17 and csta2026 HS-ALG-PS-03 entries: Chapter 10's too_slow rewritten as much_faster is a deliberate, measured performance optimization, not an incidental speedup.
• #C5.4 Testing is a distinct step applied to both software and the broader project.
  • Bootstrap:Algebra: Chapter 16 (Functions: Contracts, Examples & Definitions), Chapter 19 (Solving Word Problems with the Design Recipe), Chapter 28 (Collision Detection — Distance and Inequality) (partial)
    Testing is a step in the Design Recipe, with examples written before the code.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 2 (Week 2: Arrays)
    Debugging, a named week-2 topic with two dedicated Shorts, is testing applied as its own distinct step.
  • Harvard's CS50-Python (Weeks 0-8): Unit 5 (Lecture 5: Unit Tests)
    Unit Tests and pytest, named week-5 headings, are testing as its own distinct step.
  • CS50 Problems: Unit 4 (Square)
    Square: running check50 against a solution makes testing a distinct, visible step rather than an afterthought.
  • Working in Python (a jupyter notebook): Chapter 7 (Iteration and Search)
    Chapter 7's Doctest section -- docstring-embedded tests, a dedicated pass/fail vocabulary, and a runner function built for the purpose -- is close to a literal match for testing as its own distinct development step.
• #C5.5 A finished result gets evaluated against what it was originally required to do.

  Unassigned

• #C5.6 Debugging is part of quality assurance, not separate from it.
  • Carnegie Mellon's AP CSP in Python: Unit 2 (Unit 2: Functions, Mouse Events, Conditionals)
    This carrier's own inference: Unit 2's named Debugging and Test Cases sub-lesson treats debugging as part of building the program, not a separate step -- this standard's own framing.
  • Harvard's CS50AP (C Language Content) (Weeks 1-6): Unit 2 (Week 2: Arrays)
    Same claim as C5.4 -- debugging named directly, not folded into 'writing code.'
  • Harvard's CS50-Python (Weeks 0-8): Unit 3 (Lecture 3: Exceptions)
    Exceptions and runtime errors, named week-3 headings, are debugging folded into the program's own control flow.
  • Working in Python (a jupyter notebook): Chapter 1 (Welcome), Chapter 2 (Variables and Statements), Chapter 3 (Functions), Chapter 4 (Functions and Interfaces), Chapter 5 (Conditionals and Recursion), Chapter 6 (Return Values), Chapter 7 (Iteration and Search), Chapter 8 (Strings and Regular Expressions)
    Every chapter's Debugging section -- same pattern as AP CRD-1.4/CRD-2.I, already the carrier for AP topic 1.4 in every chapter. Headers only throughout; no single chapter's Debugging section is more chapter-specific than any other's.

#C6.0 Media Integration

Development projects often pull together more than one kind of media.

Unassigned

• #C6.1 A print piece, a video, an audio track, and an interactive experience each have their own basic design vocabulary.

  Unassigned

• #C6.2 Media gets encoded in different ways -- vector versus bitmap graphics, different bit depths -- and each choice trades off differently.
  • CS Unplugged: Pixel Pictures (related)
    A bitmap (one bit per pixel) image encoded two ways, as raw pixels and as run lengths. Vector graphics and bit depth beyond black and white aren't covered.
• #C6.3 Editing media takes the right tool for the format -- something for animating frame by frame, something for drawing or touching up an image, something for modeling in three dimensions.

  Unassigned

• #C6.4 A multimedia project -- video, game, interactive site -- moves from storyboard through to finished production.

  Unassigned

• #C6.5 Choosing a file format and compression level for media is its own analytical decision.
  • CS Unplugged: Pixel Pictures (related)
    Deciding when run-length compression helps and when it makes a picture bigger.
• #C6.6 Media has to actually be integrated into a finished project, using the right tools for the job.

  Unassigned

• #C6.7 A finished project can include media built to a professional standard -- pictures, write-ups, sound, footage -- made or recorded directly rather than borrowed.

  Unassigned

#C7.0 Web & Online Development

Web and online projects come with their own development process.

Unassigned

• #C7.1 Web hosting and related services need both server hardware and the right software.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 8 (Week 8: HTML, CSS, JavaScript)
    The week-8 internet primer (routers, servers, DNS) is the hardware-and-software-together claim this standard makes.
  • MicroPython on Pi Pico and Projects: Chapter 11 (Wi-Fi connectivity)
    The Pico W hosts its own small web server, serving a dynamic page over Wi-Fi -- a direct, if miniature, example of web hosting needing both the right hardware and the right software.
• #C7.2 Getting content live online means registering a domain name and arranging both hosting and email for it.

  Unassigned

• #C7.3 Search engine optimization, including keyword and metadata strategy, is how a site attracts visitors.

  Unassigned

• #C7.4 E-commerce capability means handling a shopping cart and credit-card transactions, not just listing products.

  Unassigned

• #C7.5 A website, an online business, or a personal e-portfolio is meant to actually go live, not just stay a plan.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 9 (Week 9: Flask)
    Flask, with Route and Sessions, is the point where a project becomes an actually-served application rather than a local script.
• #C7.6 Delivering and retrieving online content quickly is its own optimization problem.

  Unassigned

#C8.0 Databases

Databases are their own kind of software development.

Unassigned

• #C8.1 Databases play a critical role in how modern organizations actually function.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 7 (Week 7: SQL)
    SQL is a full week on its own -- databases get more instructional weight here than anywhere else in this teacher's courses.
• #C8.2 Databases are built from basic structures: fields, records, tables, and views.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 7 (Week 7: SQL)
    Tables (a named topic) are exactly this standard's 'fields, records, tables, and views.'
• #C8.3 Tables relate to each other in specific ways -- one-to-one, one-to-many, many-to-many -- established through primary keys, foreign keys, and indexes.

  Unassigned

• #C8.4 Data modeling is how a database gets designed around real business needs.

  Unassigned

• #C8.5 Queries are the tool for extracting and manipulating data, whether selecting it or acting on it.
  • Harvard's CS50AP (Weeks 0, 3, 7-9): Unit 7 (Week 7: SQL)
    SQL's own Statements and Keywords/Functions are how a database gets queried and manipulated.
• #C8.6 A well-normalized database follows an appropriate schema.

  Unassigned

• #C8.7 Moving data between a database and other applications comes with real limitations and challenges.

  Unassigned

• #C8.8 Turning data into things such as cross-tabulations, graphs, or charts is what actually makes it useful for deciding something.
  • Code.org's AP CSP (Units 1,2,5,8,10): Unit 9 (Unit 9: Data)
    This carrier's own inference: 'turning data into cross-tabulations, graphs, or charts' is this unit's own data-visualization activity, almost verbatim.
  • Bootstrap:Data Science — Hour of Data: Unit 3 (Introducing the Pyret Programming Environment — Bar Chart / Pie Chart), Unit 4 (Scatter Plots, Outliers & Human Error), Unit 5 (More Pie Charts & Bar Charts), Unit 6 (Comparing Subsets / Making Predictions Using Proportional Reasoning), Unit 7 (Patterns in the Code — More Subsets & Pie Charts via Filtering), Unit 8 (Analyzing Scatter Plots Using Rate of Change)
    Turning one table of collisions into bar charts, pie charts and scatter plots to answer a question is this standard's own point.

#C9.0 Devices & Robotics

Software gets developed for more than just general-purpose computers, including robotics and other devices.

Unassigned

• #C9.1 Device-focused development shows up anywhere from personal computers to robots to smart appliances.
  • MicroPython on Pi Pico and Projects: Chapter 9 (Data logger) (related)
    Turning the Pico into a standalone, headless logging device touches the idea of device-focused development beyond a personal computer, but the lesson doesn't connect it to the standard's own broader examples (robots, smart appliances).
• #C9.2 Installing equipment and assembling hardware both call for the right tools and testing.
  • MicroPython on Pi Pico and Projects: Chapter 1 (Get to know your Raspberry Pi Pico), Chapter 4 (Physical computing with Raspberry Pi Pico), Chapter 10 (Digital communication protocols: I2C and SPI)
    Chapter 1's soldering section is a full walkthrough of assembling hardware with the right tools (iron, solder, stand) and testing the result (checking every joint for bridges or cold joints). Chapter 4 builds a breadboard circuit and tests it by running the program. Chapter 10 wires and tests an external OLED module.
  • Pico Projects: Chapter p1.1 (Project 1.1: Wiring Three LEDs), Chapter p1.6 (Project 1.6: Wiring a Switch Bank)
    Project 1.1 hand-wires three LEDs and resistors with the right tools (wire strippers and cutters) following a color convention, then tests the result against a written rubric through a two-stage sign-off, rather than by running a program. Project 1.6 repeats the same assembling-and-testing pattern for three switches, wired and checked against an exemplar before anything is powered back on.
• #C9.3 Hardware is what actually captures input, processes it, and acts on it.
  • MicroPython on Pi Pico and Projects: Chapter 4 (Physical computing with Raspberry Pi Pico), Chapter 5 (Traffic light controller), Chapter 7 (Burglar alarm), Chapter 8 (Temperature gauge) (partial)
    Chapter 4's button-to-LED chain, chapter 5's button-to-interrupt-to-LED/buzzer chain, chapter 7's PIR-to-interrupt-to-LED/buzzer chain, and chapter 8's potentiometer-to-PWM chain are all hardware capturing input, processing it, and acting on it, though none of the lessons frame it in those terms explicitly.
  • Pico Projects: Chapter p1.7 (Project 1.7: Reading Your Switches), Chapter p2.1 (Project 2.1: Moving a Servo), Chapter p2.3 (Project 2.3: Adding a NeoPixel Bar), Chapter p2.4 (Project 2.4: Animating the NeoPixel Bar), Chapter p2.5 (Project 2.5: Swapping in a Light Sensor)
    Project 1.7's switches, project 2.1's servo, and project 2.3's potentiometer-plus-NeoPixel-bar are each hardware capturing input or acting as output, with code doing the processing in between: switches read and compared against their last state, a servo driven to a commanded angle, a potentiometer's voltage reading converted into a pixel count and color. Project 2.5 swaps the input hardware for an LDR with the output and processing unchanged.
• #C9.4 Embedded programming involves digital logic, how data is represented at the machine level, and how memory is organized.
  • MicroPython on Pi Pico and Projects: Chapter 8 (Temperature gauge) (partial)
    Reading the ADC and driving PWM both touch how a microcontroller represents and processes data at a low level, though the lesson doesn't discuss digital logic or memory organization directly.
  • Pico Projects: Chapter p1.5 (Project 1.5: Fading an LED with PWM), Chapter p2.1 (Project 2.1: Moving a Servo) (partial)
    Project 1.5 isolates the PWM half of embedded, low-level hardware control on its own: machine.PWM, freq(), and duty_u16() explored directly, without the ADC half chapter 8 also covers. Project 2.1 reuses the exact same PWM mechanism for a different physical effect, turning duty cycle into a servo's angle instead of an LED's brightness.
• #C9.5 A microcontroller can be programmed to run a device or a robot.
  • MicroPython on Pi Pico and Projects: Chapter 5 (Traffic light controller), Chapter 6 (Reaction game), Chapter 7 (Burglar alarm)
    Chapters 5, 6, and 7's projects are all a microcontroller (the Pico) programmed to run a physical device -- a traffic light system, a reaction-time game, and a burglar alarm -- the standard's own example.

#C10.0 Intelligent Computing

Intelligent computing is its own area of software development.

Unassigned

• #C10.1 Models of intelligent behavior raise the question of what actually distinguishes a human from a machine.

  Unassigned

• #C10.2 Intelligent computing covers areas like perception, proximity sensing, processing, and control.

  Unassigned

• #C10.3 AI methods include things like neural networks, Bayesian inference, fuzzy logic, and finite state machines.

  Unassigned

• #C10.4 Making AI behavior actually happen can lean on math-based modeling, reinforcement learning, or probability-based analysis, among other methods.

  Unassigned