A student chooses a tablet to photograph a classroom plant and a keyboard to type its label, then uses each successfully. The student explains, “The camera helps me show what it looks like, and the keyboard helps me write its name.”

Pointing to a classroom computer, a student explains, “The keyboard puts letters in, the screen shows my work, and the drawing program lets me make a picture.” The student distinguishes a part they can touch from a program they use.

When a drawing will not print, a student reports, “My picture is on the screen, but the printer did not print it,” instead of simply saying that everything is broken. The student names the device or program and describes what happened.

Using people, string, and picture cards, a student models sending a class picture to another classroom through connected devices. The student explains that the network lets people in different places share information.

A student explains, “A password helps keep someone else from opening my account and changing my work.” In a pretend sign-in activity, the student keeps the password private instead of sharing it with classmates.

A student invents a repeating clap-and-tap pattern that means “come to the circle,” teaches its meaning to a partner, and uses it to send the message. The partner correctly interprets the pattern.

Using practice files, a student saves a drawing, makes a copy, finds and reopens it, changes the copy, and deletes the unwanted practice copy. The student explains, “The picture and its name are data the computer stores.”

A student surveys classmates about a favorite fruit, records each answer, and presents the same counts as a picture graph and a simple bar graph. Both displays accurately match the collected answers.

Looking at a class weather graph, a student says, “We had more sunny days than rainy days. I predict another sunny day, but it could still rain.” The student points to the graph as the reason for the prediction.

A student arranges picture cards showing how to wash hands and follows the steps in order. A partner can complete the routine using the student's instructions without needing a missing step explained.

A student uses a labeled cup called “score” to hold a number card. When a pretend program earns a point, the student replaces 2 with 3 and explains, “The program remembers the score so it can use it later.”

In a block-based program, a student makes a character move, speak, and then repeat a dance three times. The commands run in the intended order, and the student points to the loop that repeats the dance.

To guide a classroom robot to a book, a student breaks the journey into move and turn instructions. The student puts those instructions in order and checks that following them reaches the book.

Before coding an animated greeting, a student draws a three-frame plan: the character enters, says hello, and waves. The student explains the goal and predicts what a viewer will see when the program starts.

A student uses a classmate's suggested character in a simple animation and adds a spoken or written credit: “Maya gave me the idea for the turtle.” The student identifies which contribution came from someone else.

When a character turns the wrong way and repeats a move too many times, a student locates the incorrect turn and repeat count. The student changes them and reruns the program to show that it reaches the intended destination.

A student describes a first attempt, a test, and a change: “My character went past the house. I changed the repeat block from five to three. I tried it again, and now it stops at the house.”

Using before-and-after pictures, a student compares mailing a letter with sending a digital message. The student describes something that stayed the same—sharing news—and something that changed, such as how quickly the message arrives.

In a teacher-managed digital discussion, a student takes turns, writes or dictates a kind response about a classmate's work, and asks before sharing the classmate's picture. The response is relevant and respectful.

A student demonstrates signing out of a shared practice account and explains, “I keep my login private and sign out so the next person cannot use my account.” The student identifies a trusted adult to ask for login help.

A student draws a labeled system with a computer, keyboard, headphones, and printer, marking wired or wireless connections. The student explains what each connection lets the components do together.

A student records a short narration and plays it back, explaining that the microphone captures sound, the recording software saves and edits it, and the speakers produce the playback. The demonstration shows how the parts work together.

When a practice recording has no sound, a student proposes checking volume, the selected output device, and the headphone connection. The student tries a reasonable check, describes the result, and identifies a next step or when to ask for help.

A student divides a message into numbered paper packets, sends them through classmates representing network devices along different routes, and reassembles them at the destination. The student explains why the receiver needs information about packet order.

For a fictional student account, a student recommends both a physical measure, such as putting the device away securely, and a digital measure, such as a private password and screen lock. The student explains what each measure helps protect.

A student creates a substitution pattern, uses it to encode a short message, and gives the decoding key only to the intended partner. The partner recovers the message, and the student explains why someone without the key would find it harder to read.

A student compares the file sizes of two versions of the same picture saved in the same format at different resolutions. The student explains that more image detail generally requires more storage and notes that file format can also affect size.

A student organizes a class transportation survey into a labeled bar graph and writes, “More students in our class walk than ride a bike,” citing the two counts. The graph's labels and scale support the claim accurately.

Using several weeks of classroom library checkout data, a student predicts which book category may need more copies and cites the pattern in the counts. The student recognizes that future choices could differ from past choices.

A student compares two sets of directions for navigating the same maze, tests both, and removes unnecessary moves. The student selects the revised route and explains why it is suitable, using accuracy and number of steps as evidence.

A student creates a quiz with a score variable that starts at zero and increases after a correct answer. The student demonstrates the changing value and explains why the program needs to store it.

A student's game starts when a button is clicked, uses a loop to move an object, and uses an if statement to award a point when the object touches a target. The student demonstrates and identifies all three structures.

A student breaks an animated story into scenes, then breaks one scene into setting the background, moving characters, and displaying dialogue. The resulting task list is small enough to guide the actual programming work.

A student takes a movement sequence from a permitted sample program and adapts it for a new maze game. The student shows which blocks were reused, what was changed, and how the new program behaves differently.

A student asks classmates what would make a quiz easy to use, creates a first version, and observes them trying it. The student revises confusing instructions and shows how the change responds to their preferences.

A student selects a character image whose stated permissions allow reuse, follows those conditions, and includes the creator and source in the project's credits. The student explains why finding an image online does not automatically mean it can be reused.

A student tests a quiz with both correct and incorrect answers, notices that both earn points, and fixes the condition. A second test shows that points are now awarded only for correct answers.

Across a group project, a student helps plan a story, takes a turn programming a scene, and later tests a partner's scene. A brief role log or explanation shows a useful contribution during design, creation, and review.

A student adds a comment explaining why a loop repeats four times, demonstrates the resulting square, and describes that decision to classmates. The explanation connects the code choice to what the program does.

A student explains how video calls let distant family members participate in celebrations and how families' languages and traditions can shape the features they want in calling tools. The example shows technology influencing culture and culture influencing technology.

After trying a classroom app, a student proposes larger controls, spoken directions, or text labels beside icons and explains who each change could help. A sketch shows how at least one proposed change would work.

A student asks peers with different experiences to try an interactive story and listens to their suggestions. The student revises an unclear symbol or unfamiliar phrase and explains how another person's perspective improved the story.

A student explains, “A game artist might let us look at the artwork but not sell copies because they want to be paid and decide how it is used.” The student gives a clear reason a creator might restrict copying or changes.

A student designs a larger, tactile input button for a device used by someone who finds a small touchscreen difficult. A labeled prototype shows how the modification changes the interaction, and the student explains how it addresses the user's need.

A student designs a classroom temperature monitor with a sensor, a programmable board, and software that sends readings to another device for display. A diagram identifies the data collected, the components, and the path the data follows.

For a malfunctioning sensor project, a student records the symptom, checks power and connections, tests the sensor separately, and then checks the code. The student changes one factor at a time and documents the fix and successful retest.

In a packet-delivery simulation, a student specifies rules for addressing, numbering, acknowledging, and resending messages. The student demonstrates how agreed rules let the receiver reconstruct a message when a packet is delayed or lost.

For a fictional account, a student matches a deceptive login message, a guessed password, and an outdated application with appropriate protective measures. The student explains how each measure reduces its particular threat and why one measure does not address every threat.

In a classroom simulation, a student encrypts a message with a shared key, uses a separate agreed check to authenticate the sender, and limits who receives the key. The student demonstrates delivery and explains the different purpose of each protection.

A student represents a small black-and-white image as a grid, a sequence of zeros and ones, and a sequence of counts of repeated pixels. The student reconstructs the same image from each representation and explains the encoding rules.

A student collects light readings with a sensor, imports them into a spreadsheet, labels units, and groups readings by time of day. The student documents how missing or erroneous readings were handled and explains how the transformed data helps answer a question.

Using a population simulation, a student changes food availability while holding other settings constant and records the resulting population sizes. The student explains the observed pattern and distinguishes a result of the model from a guaranteed real-world outcome.

A student designs a flowchart for a library checkout process that checks whether a book is available, checks borrowing eligibility, and repeats for additional books. Walking through several cases shows clear decisions and a complete path to an outcome.

A student's program stores values in variables such as itemPrice, quantity, and totalCost, calculates the total, and updates it when quantity changes. The student explains the purpose of the names and verifies the calculation with sample inputs.

A student builds a game that checks input repeatedly and opens a door only when the player has a key AND enough points. Tests of all combinations reveal an error, which the student corrects and retests.

A student divides a quiz program into displaying questions, checking answers, and tracking scores, then breaks answer checking into smaller steps. The plan assigns each part a clear responsibility and supports separate implementation and review.

A student creates a drawPolygon(sides, size) procedure and calls it with different values to draw several shapes. The student shows how parameters change the result while the same procedure replaces repeated code.

A student records feedback from teammates and intended users of a homework organizer, prioritizes a confusing due-date display, and revises it. A follow-up trial and explanation show whether the revision better meets the identified need.

A student combines original game code with a permitted sound file and an existing animation library. The program works, and its credits identify the outside contributions, their creators or projects, and their sources.

A student creates a test table for a score calculator with ordinary scores, zero, the maximum allowed value, and invalid input. The student compares actual and expected results, fixes failures, and reruns the tests.

A team uses a shared task board with owners and due dates to build an interactive map. A student completes assigned work, updates progress, and helps revise the timeline when a dependent task takes longer than expected.

A student supplies setup instructions, sample inputs and outputs, and comments explaining a tricky calculation. A peer can run the program and locate the relevant section when a provided test produces an unexpected result.

A student compares automated checkout with staffed checkout, describing changes in convenience, accessibility, and job tasks. The student explains who may benefit or face difficulties and supports a balanced conclusion with specific examples.

A student reviews a voice-controlled tool and explains how difficulty recognizing some speech patterns could exclude users. The student distinguishes uneven recognition from the lack of an alternative input method and proposes ways to investigate both issues.

A student helps build a shared digital guide using contributions from several classroom teams. The student integrates others' text, images, or code, resolves conflicting suggestions respectfully, and documents individual contributions to the final artifact.

Using two teacher-provided license summaries, a student compares what each permits people to copy, modify, and share. The student recommends a license for a class project and explains the tradeoff between creator control and opportunities for reuse.

For a fictional club website, a student compares publishing meeting information with publishing members' personal contact details. The student recommends what to share publicly and what to restrict, explaining the benefits and privacy risks of each choice.

A student explains how selecting “Save” lets a user store a file without managing individual storage locations. The explanation identifies the simplified action, the hidden system work, and why hiding that detail makes the interface easier to use.

A student traces playing an audio file from the application through operating-system services and device drivers to audio hardware. The student compares the responsibilities of the layers and explains how one layer requests services from another.

A student creates a troubleshooting decision tree for a device that cannot connect to a network, including symptom checks, isolation steps, retests, and escalation points. A peer uses the guide successfully on a teacher-prepared fault and identifies any unclear instruction for revision.

A student analyzes a simulated slow connection by distinguishing limited bandwidth, high latency, packet loss, and a failed device. The student explains how each issue affects the experience and what observation would help distinguish possible causes.

A student diagrams the Internet as interconnected networks using packet switching, addressing, routing, and shared protocols. The student explains how multiple possible routes support resilience and why a failed local connection can still interrupt a user's access.

For fictional security scenarios, a student compares encryption, multifactor authentication, access permissions, and backups. The student selects a combination and explains which threats each measure addresses, its limitations, and relevant usability tradeoffs.

Using a classroom cryptography model, a student compares a shared-secret approach with a public/private-key approach. The student demonstrates the roles of the keys and explains differences in key distribution and computational cost without treating the teaching model as production security.

A student converts a short text into character codes and binary values, then reconstructs the text using the same encoding. The student also translates a small image into pixel color values and explains how the representations stand for visible information.

For a searchable catalog, a student compares storing full records repeatedly with storing related records once and linking them by identifiers. The student explains tradeoffs in duplication, updating, retrieval, and implementation complexity.

A student creates a labeled visualization of local temperature data, chooses an appropriate scale and chart type, and annotates a meaningful trend. The student explains the pattern and a limitation without using the display to imply more than the data supports.

A student compares a simple school-bus travel-time model with observed times, identifies that stop frequency is missing, and adds that relationship. The student compares predictions before and after the revision using held-out observations and discusses remaining error.

A student designs an event scheduler that uses an existing sorting algorithm and original steps for checking time conflicts and assigning rooms. A trace with overlapping events shows how the combined algorithm produces a valid schedule or reports an unresolved conflict.

A student replaces separate score1, score2, and score3 variables with a collection and a loop that calculates a class average. The solution works when the number of scores changes and handles an empty collection deliberately.

A student compares a counted loop with a condition-controlled loop for processing incoming entries and selects the structure that fits the stopping rule. The explanation addresses ease of implementation, readability, and unnecessary work or performance costs.

A student develops an interactive recycling guide whose buttons and selection changes trigger relevant instructions. User trials lead to revised navigation, and the student demonstrates how the event-driven behavior supports the guide's purpose.

A student analyzes a course-planning application and separates course storage, prerequisite checking, and schedule display into modules or classes. The design specifies inputs, outputs, and responsibilities so each subproblem can be implemented and tested separately.

A student implements a small application with separate input, calculation, and display modules that communicate through defined interfaces. Changing the display requires little or no change to the calculation module, demonstrating the value of modular design.

A student gathers feedback from intended users with varied language, device, and accessibility needs, turns that feedback into requirements, and tests a prototype. The student documents revisions and follow-up results rather than assuming one user's preferences represent everyone.

Given the stated terms for two sample libraries, a student identifies restrictions or obligations affecting modification and redistribution of a class application. The student explains how those terms influence library selection and the notices or permissions the project would need.

A student evaluates a web application for loading speed, incorrect inputs, navigation clarity, and keyboard access. The student makes targeted revisions and uses before-and-after measurements and user trials to show improvements across performance, reliability, usability, and accessibility.

A team develops an application using an issue tracker, shared repository, and design documents. A student fulfills an assigned role, reviews a teammate's contribution, and coordinates an interface change so the integrated program works.

A student maintains a design log with diagrams, short decision notes, and demonstrations of major versions. For one substantial change, the student identifies alternatives, explains the choice, and shows its effect on the program.

A student evaluates a fictional recommendation platform from personal, ethical, social, economic, and cultural perspectives. The student weighs benefits and harms for different groups and supports a reasoned conclusion with evidence from a supplied case study.

A student audits a classroom model trained on a supplied synthetic dataset, compares error rates across relevant groups, and checks for underrepresented cases. The student documents a possible source of bias, tests a revision, and explains both its effect and the limits of the evaluation.

A student applies the same shortest-path algorithm to a transportation map and a game map, defining nodes, edges, and weights for each. Worked examples show how one computational method solves problems in two different fields.

A student develops an evidence-based briefing about an emerging technology, citing credible sources and distinguishing demonstrated capabilities from predictions. The briefing weighs possible effects on work, social relationships, and public decision-making and addresses a competing interpretation.

In a teacher-arranged exchange, a student uses shared documents or video discussion to collaborate with people from another cultural setting or career field. The student adapts questions and communication practices, incorporates what was learned, and documents a contribution to shared work.

Using a teacher-provided intellectual-property case, a student explains how protecting a creator's work could encourage investment while limiting some kinds of reuse or follow-on invention. The response traces both effects and supports a balanced conclusion about innovation.

A student maps how a fictional fitness app automatically collects location and activity data and can generate inferences about routines. The student distinguishes collected data from inferred information and explains privacy concerns related to sharing, retention, and unexpected uses.

Using a fictional proposal for location tracking to improve community safety, a student weighs safety benefits against privacy, unequal impacts, and economic incentives. The student considers legal questions and ethical concerns raised in supplied materials and recommends justified limits and safeguards.

A student builds or simulates a half-adder from logic gates, provides truth tables, and traces the sum and carry outputs for every input pair. The explanation connects Boolean operations to the circuit's hardware components.

A student categorizes operating-system functions into process scheduling, memory management, file management, device input/output, and access control. A traced example of opening and running a program explains how several of these services interact.

A student compares two network designs for a growing school, explaining how switches connect local devices, routers connect networks, servers provide services, and addressing identifies destinations. The analysis identifies bottlenecks and single points of failure and justifies changes for growth and reliability.

A student explains why an Internet-based messaging application must handle variable delay, disconnections, and interoperable protocols. A design sketch connects those characteristics to features such as queued delivery, retries, and duplicate-message handling.

In an isolated classroom application, a student identifies a threat such as unauthorized access to another test user's records and implements an appropriate access check. Tests show that permitted actions still work and prohibited actions are rejected.

Using established cryptographic tools in a controlled exercise, a student models encrypted transmission and analyzes confidentiality, sender authentication, and integrity separately. The student explains the roles of keys, identifies what happens if a key is compromised, and evaluates limitations of the chosen approach.

A student chooses between sensors, an approved survey, or a public-data interface to investigate a question and explains the choice. The resulting dataset includes documented fields, units, sampling procedures, and checks for missing values or collection errors.

A student uses code or analysis software to join and explore transit ridership, weather, and calendar data. The student identifies a pattern, investigates missing data and possible confounding factors, and explains why an association alone does not establish causation.

A student uses a traffic simulation to test whether changing signal timing reduces queues, compares results across repeated runs, and examines sensitivity to assumptions. The student refines the hypothesis and explains which claims require real-world evidence beyond the simulation.

A student explains how an image classifier, a recommendation system, and a robot use inputs to produce predictions or decisions that guide actions. The response identifies the role of training data or encoded knowledge and explains how errors can affect the larger system.

A student implements a simple nearest-neighbor classifier for teacher-provided plant measurements, tests it on examples excluded from training, and reports correct and incorrect classifications. The student explains how the algorithm chooses a class and one limitation of the approach.

A student implements a sorting algorithm and a search algorithm for a catalog, tests ordinary and edge cases, and demonstrates successful and unsuccessful searches. If binary search is used, the student ensures that the data is sorted first.

A student compares linear and binary search by counting comparisons for increasing input sizes on appropriately prepared data. The analysis explains growth in work, considers sorting costs, and identifies when each approach is a reasonable choice.

A student compares a list, stack, queue, and key-value map, describing their typical operations and access patterns. The student selects structures for an undo feature and a waiting-line simulation and justifies both choices with small working examples.

A student traces a recursive factorial procedure for a small input, showing each call, the base case, and the returned values as calls finish. The student explains how progress toward the base case prevents endless recursion.

A student analyzes a district-wide room-booking problem and identifies repeated tasks such as validating requests, checking conflicts, and assigning resources. The student defines reusable representations and operations and demonstrates them on several different buildings or room types.

A student creates reusable validation, storage, and reporting components and assembles them into a working application. Defined interfaces and component tests show how the student's own procedures, modules, or objects support the overall solution.

A student builds a visualization using an existing charting library and an approved data API. The student explains the reused functionality, handles an unavailable or unexpected response, and shows how the application's own code connects the components.

A student follows a stated iterative development process for an application, documenting audience requirements, a backlog, prototype cycles, testing, and a release review. Feedback from varied intended users influences both priorities and completed revisions.

A student develops an application that runs on both a desktop and a mobile platform, adapts input and layout appropriately, and tests core tasks on each. The student records platform differences and fixes issues revealed by testing.

In a teacher-provided practice program, a student finds that a restricted action is protected only by a hidden interface button. The student adds an authorization check where the action is processed and verifies rejection of an unauthorized test request.

A student converts application requirements into a test matrix covering expected behavior, boundary values, invalid input, and relevant failure conditions. The student runs the tests, records expected versus actual outcomes, and retests fixes against the specifications.

A student adds offline saving to an existing note-taking application and demonstrates the intended benefit during disconnection. The student also tests and discusses unintended effects such as stale copies or conflicting edits and explains how the revision handles them.

A student reviews a peer's program using criteria for correctness, readability, efficiency, maintainability, and accessibility where relevant. Specific comments cite code or observed behavior, explain consequences, and recommend changes that the student checks after revision.

A student develops a feature in an IDE on a version-control branch, writes useful commit messages, documents the change, and requests peer review. The team resolves a conflicting edit and integrates the feature while preserving a clear history of contributions.

A student implements a small comparable task in two languages and compares relevant features such as typing, available libraries, execution environment, and memory management. The student justifies which language better fits a stated project instead of declaring one universally best.

A student evaluates a fictional route-planning application for benefits such as shorter trips and harms such as shifting traffic onto residential streets. The student proposes a design change, compares outcomes for affected groups, and explains remaining tradeoffs.

A student traces how a computational innovation such as digital mapping changed everyday practices, then develops two plausible future scenarios. The student uses evidence, identifies assumptions and constraints, and explains why the scenarios are possibilities rather than certain predictions.

Using a supplied international connectivity dataset and case studies, a student analyzes how cost, infrastructure, language, accessibility, and decision-making power affect access to computing resources. The student evaluates a proposed intervention and explains who it may still leave underserved.

In a structured debate about a teacher-provided software regulation proposal, a student builds an evidence-based argument, responds to a counterargument, and considers effects on developers and users. The student distinguishes what the proposal says from personal policy preferences and acknowledges a significant tradeoff.