Big Idea 1: Creative Development

Creative development

The purposeful process of using imagination and intentional decision-making to design and build a computing artifact for an audience.

Computing artifact

Anything created with a computer or programming that has meaning or function (e.g., program, app, game, simulation, visualization, website, digital art, robot behavior, edited video).

Computing innovation

A product or development that uses a program to take in data, transform it, and output data.

Input–process–output (IPO)

A way to explain a computing innovation: what data comes in (input), what the program does to it (process), and what it produces (output).

Purpose (of an artifact)

The real-world goal of the artifact—what it is for, what problem it solves, or what experience it provides.

Audience (of an artifact)

The intended users of the artifact, including what they need, know, care about, and what devices/constraints they have.

Constraints

Limits that shape development, such as time, tools, requirements, resources, and user needs (including accessibility and device limitations).

Trade-off

A decision where improving one aspect can worsen another (e.g., more features vs. finishing on time; better graphics vs. performance).

Program development process

A structured, cyclical approach to move from an idea to a tested, improved computing artifact through planning, building, testing, and refining.

Investigate/define the problem

The stage where you clarify goals, users, success criteria, and constraints, often by asking questions and researching existing solutions.

Requirement

A statement describing what an artifact should do or how it should behave, written so it can be checked and helps prevent unnecessary features.

Functional requirement

A requirement describing a specific behavior or feature (e.g., “the user can save their score”).

Non-functional requirement

A requirement describing a quality or constraint of the system (e.g., response time, readability on a phone, accessibility).

Feature drift

When a project gradually adds extra features beyond the original scope, often caused by unclear requirements.

Design (solution design)

Planning how the artifact will work before coding, using tools like wireframes, storyboards, data plans, and pseudocode to reduce rework.

Wireframe

A simple layout sketch showing where interface elements go (buttons, text, images) without final visual polish.

Storyboard

A sequence of sketches/descriptions showing how a user interacts with an artifact step-by-step to plan user flow and transitions.

Pseudocode

A structured plain-language description of an algorithm used to plan logic without full programming syntax.

Flowchart

A diagram that visualizes steps and branching decisions in a process or algorithm.

Decomposition

Breaking a large problem into smaller, manageable parts that are easier to design, implement, test, and divide among teammates.

Minimum viable version

The smallest workable version built first to reduce risk and allow early testing and iteration before adding complexity.

Implementation

The building/coding stage where you write the program, create UI elements, connect inputs/outputs, and integrate libraries or media.

Testing

Running a program with selected inputs to check whether actual output/behavior matches expected results (including typical and edge cases).

Debugging

Systematically finding and fixing the cause of errors by reproducing the issue, isolating where it occurs, fixing the root cause, and retesting.

Edge case

An unusual or boundary input/situation (e.g., empty input, very large values) that can reveal hidden bugs.

Test case

A specific test that states inputs, expected output/behavior, and the observed actual output/behavior to make “correct” explicit.

Iterative development

Repeating cycles of building, testing, and refining multiple times, using feedback and results to improve each version.

Prototype

An early, simplified version (code or non-code) used to make an idea testable and gather feedback (e.g., sketches, mockups, small feature tests).

Refinement

Improving an artifact after testing/feedback by fixing confusing interactions, clarifying UI, improving performance, or adding needed small features.

User feedback

Information from real users about what is confusing, missing, or hard to use, used to guide refinement and iteration.

Human-centered design (user-centered design)

An approach that focuses on users’ goals, experiences, and limitations throughout development to build something that works for real people.

Usability

How easy it is for users to accomplish their goals with an artifact (distinct from how visually appealing it looks).

Accessibility

Designing so people with disabilities can use the artifact (e.g., good contrast, readable fonts, not relying on color alone, captions/text alternatives, clear navigation).

Input validation

Checking user input to prevent errors and improve usability (e.g., rejecting empty usernames or usernames with spaces).

Collaboration

Working with others effectively during planning, designing, testing, and debugging to improve quality and build in parallel.

Attribution

Giving credit for code, media, or ideas you did not create; required for ethical and academic/professional integrity.

Pair programming

A collaboration technique where two people work at one computer with defined roles and switch periodically for continuous review.

Driver (pair programming)

The person who writes the code while the other partner reviews and thinks ahead.

Navigator (pair programming)

The person who reviews, catches mistakes, suggests improvements, and thinks ahead; should be actively engaged (not just watching).

Version control

A system (e.g., Git) that tracks changes to files and helps teams merge work and avoid overwriting each other.

Source of truth

The agreed-upon authoritative version of project files that the team uses to prevent confusion and conflicting edits.

Merge conflict

A problem that occurs when multiple people change the same file/section and the changes must be reconciled to combine work safely.

Peer instruction

A collaborative learning method where students discuss concepts and solve problems together in pairs or small groups.

Collaborative learning

Learning that happens by working with others (peer-to-peer or in groups) to exchange ideas, resources, and solutions.

Syntax error

An error caused by violating the programming language’s rules (e.g., using an undefined variable name due to case sensitivity).

Runtime error

An error that occurs during execution and may stop the program (e.g., dividing by zero).

Logic error

A mistake in the algorithm that makes the program behave incorrectly even though it runs (e.g., printing multiple grades due to missing conditions).

Overflow error

An error that occurs when a number is outside the allowed range for a data type during computation.

License

The permissions and restrictions that govern how code/media can be reused (e.g., whether attribution is required, modification allowed, or use is noncommercial).

Documentation

Written explanations of an artifact’s purpose, audience, features, design decisions, iteration, and sources so others can understand, maintain, and evaluate it.