Trajectory Visualizations

Prototype learning trajectories for computer science at grades K-5.

Published Trajectories

Sequence

 Sequence Trajectory. Beginning concepts include items 1, 3.1, 3.2, and 4.1; intermediate concepts include beginning items plus 2, 3, 4, and 5; advanced concepts include all items. Items: 1: Precise instructions are more likely to produce the intended outcome than general ones. 2: Different sets of instructions can produce the same outcome. 3: The order in which instructions are carried out can affect the outcome. 3.1: Precision and completeness are important when writing instructions in advance. 3.2: Programs are made by assembling instructions from a limited set. 4: Computers have a default order of execution, so order matters in programming. 4.1: Computers require precise instructions using limited commands. 5: Creating working programs requires considering both appropriate commands and their order. 6: Some commands modify the default order of execution, altering when and which instructions are executed. 7: The position of a new command can affect outcomes.

This trajectory focuses on ideas that will support elementary students in creating sequences of instructions that are both interpretable by a computer and produce a desired outcome. The trajectory is designed to guide the development of activities that support growth in student thinking around two core ideas that relate to this overall goal. One idea is that the order in which instructions are written and carried out can have an impact on the final result. Another idea is that instructions must be precise to lead to the desired outcome. The trajectory is designed to support students in exploring these core ideas in unplugged, then progress to applying the ideas to programming.

Repetition

 Repetition Trajectory. Beginning concepts include items 2, 3, and 5; intermediate concepts include beginning items plus 1, 4, 4.1, and 5.1; advanced concepts include all items. Items: 1: Repeating things can have a cumulative effect. 2: Some tasks involve repeating actions. 3: Instructions like 'Step 3 times' do the same thing as 'Step, step, step.' 4: Repetitions can go on forever or stop. 4.1: Different kinds of tasks require different kinds of repetition. 5: Computers use repeat commands. 5.1: Different kinds of repetition have different commands. 6: Variables can be used to control the number of repetitions. 8: Programs use conditions to end loops. 9: Loops can be nested to accomplish complex tasks.

This trajectory focuses on how elementary students’ common understandings of repetition can be used as a starting point to develop an understanding of iteration and loops. The trajectory suggests that students can begin instruction on looping by exploring situations in everyday life where actions are repeated. Next, they can consider key questions about different examples of repetition: Does the repetition stop? If so, what makes it stop? The trajectory suggests building on students’ explorations of why repetitions stop to discuss the difference between infinite loops, counted loops, and conditional loops. Students can also ask, What is the effect of the repetition? to think about the cumulative effects that make loops such a powerful programming construct.

Conditionals

 Conditionals Trajectory. Beginning concepts include items 0, 1, 2, 3, and 5; intermediate concepts include beginning items plus 1.2, 4, 4.1, and 7; advanced concepts include all items. Items: 0: Actions often result from specific causes. 1: A condition is something that can be true or false. 1.1: A Boolean is a variable that can be true or false. 1.2: Sometimes multiple conditions must be considered. 2: A conditional connects a condition to an outcome. 3: Each of the two states of a condition may have its own action. 4: Computers require all actions to be specified. 4.1: Conditions can overlap, and more than one can apply. 5: Conditional statements are computer commands to evaluate conditions and complete connected actions. 6: Logical operators can be used to combine conditions. 7: Conditional statements can create branches in the flow of execution. 8: Conditional statements can be combined in several ways.

The overall goal of this trajectory is to help students develop the skills and understanding needed to be fluent and flexible users of conditional statements. The two earliest subgoals in the trajectory focus on the two parts of a conditional -- a condition that can be true or false, and an action that is associated with some particular event or cause -- and then suggests guiding students to think about those two parts can be systematically coordinated in an if-then statement, using examples from everyday life. The trajectory also includes a goal about attending to both possible states of a binary condition and considering whether each state should have an associated action. After students map these basic ideas onto the conditional construct in programming, the trajectory suggests that they explore how complex conditions can be used to create more sophisticated conditionals and how conditionals can be situated within a program to create branches in execution.

Decomposition

 Decomposition Trajectory. Items are not broken down by skill level. Items (not numbered): Systems are made up of smaller parts. Complex problems can be broken into smaller parts. Programs can be decomposed into components. System components are often not unique within or across systems. A multi-instruction code snippet may serve a single unified purpose. Code can be written in small parts (called procedures). Code is reusable. Problem decomposition is a useful early step in problem solving. Defining procedures allows for easy reuse of code within programs. Often existing code from other programs can be used to solve parts of a decomposed problem. Sometimes it is useful to modify and repurpose existing code. Defining general procedures makes code more useful in the future. Decomposition and modularization are useful in problem solving.

This trajectory focuses on building understanding of the utility of thinking about systems, including problems and programs, as being made up of several smaller parts. There are two interrelated strands in the trajectory. The upper part of the trajectory focuses on top-down thinking, or decomposing problems into smaller subproblems. The lower part of the trajectory focuses on bottom-up thinking, or putting together a complex solution from smaller parts. The trajectory is designed to suggest multiple ways that students could progress in their thinking on each strand and make productive connections between strands. For example, as students create solutions in a bottom-up manner, the trajectory suggests encouraging them to think about how components of their solutions could be used in other programs. As students decompose problems, the trajectory suggests encouraging them to think about whether a piece of the problem could be solved with an existing piece of code.

Debugging

 Debugging Trajectory. Beginning concepts include first 3 items; intermediate concepts include beginning items plus next 4 items; advanced concepts include all items. Items (not numbered): Outcomes can be used to decide whether or not there are errors (6,S). D1: Iterative refinement can help fix errors (6,S). D3: Errors play a valuable role in problem solving (2,S). D2: Small errors can change outcomes (4,S). D2: Errors can be caused by missing, as opposed to incorrect, information within instructions (3,S). D1: Intermediate results can help find and fix errors (2,S). D1: Step-by-step execution of instructions can help find and fix errors (6,S). D1: Compile errors should be fixed in the order the compiler reports them (1,S). D1: Reproducing a bug can help find and fix it (1,T). D3: Code can always be improved, but may not be worth the effort (1,S). Debugging strategies can be chosen strategically (14,S).

The overall goal of this trajectory is to support students in developing multiple strategies and techniques for debugging and the knowledge necessary to apply those techniques efficiently and strategically. The trajectory includes attention to five specific debugging strategies, including iterative refinement through trial and error and attending to intermediate results. There are also subgoals about two types of errors: small errors (e.g., in case or punctuation) and errors of omission. We expect that further research will suggests further strategies and error types that could be added. Lastly and importantly, the trajectory also includes subgoals about the overall role of errors in problem solving, noting that they can be useful, rather than always being seen as failures. We believe this disposition-oriented goal will be important to include in debugging instruction for young children.