CA ICT & Anchor Standards Reference

What this is. A locally built index of California's CTE Model Curriculum Standards, ICT sector (2013): the 11 cross-sector anchor standards plus Pathway C (Software and Systems Development). What this is not. Original paraphrases, not the CDE's text; only codes are reproduced as-is.

Anchor Standards

#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.

    Unassigned

  • #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.

    Unassigned

  • #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.

    Unassigned

  • #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.

    Unassigned

  • #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: 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.
    • 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.
  • #5.9 A large problem becomes tractable once it's broken into smaller components.
    • 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.
    • 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.
  • #5.11 Numbers can be represented in more than one base system, including binary and hexadecimal.
  • #5.12 Boolean logic underlies both decision-making and searching in computing.
    • 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: 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.
    • 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.

    Unassigned

  • #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.

#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.
  • #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.

    Unassigned

  • #9.6 Respecting individual and cultural differences is part of valuing diversity in the workplace.
    • 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.
  • #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.

    Unassigned

  • #10.6 Different kinds of information -- text, images, sound, video -- take up different amounts of data, and media formats vary in capacity.
  • #10.7 Metric prefixes like kilo, mega, giga, and tera describe scale throughout computing.
    • MicroPython on Pi Pico: 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.
  • #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.
    • MicroPython on Pi Pico: 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.
  • #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: 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.
  • #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.

    Unassigned

  • #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

Pathway C · Software and Systems Development Pathway

Students in this pathway prepare for computer-science-related careers: designing, building, deploying, and maintaining the software systems that keep modern organizations running, from e-commerce to healthcare records to entertainment.

#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 Problem Sets: 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: 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: 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: 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.
  • #C4.4 Data has types, and those types get encoded in specific ways.
    • 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 Problem Sets: 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: 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.
    • 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.
  • #C4.6 Every programming language has its own syntax, and using it correctly matters.
    • 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: 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.
  • #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.
    • 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 Problem Sets: Unit 1 (Mario (less comfortable)), Unit 3 (Palindromes), Unit 4 (Square), Unit 5 (Caesar), Unit 6 (Readability), Unit 7 (Battery Gauge), Unit 10 (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: 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.
    • 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 Problem Sets: Unit 9 (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.
    • 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.
    • 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 Problem Sets: 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.

#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.

    Unassigned

  • #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.

    Unassigned

  • #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: 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.

#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: 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.
  • #C9.3 Hardware is what actually captures input, processes it, and acts on it.
  • #C9.4 Embedded programming involves digital logic, how data is represented at the machine level, and how memory is organized.
    • MicroPython on Pi Pico: 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.
  • #C9.5 A microcontroller can be programmed to run a device or a robot.

#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