Bootstrap:Reactive Pathway

Students begin to program, explorings how Numbers, Strings, Booleans and operations on those data types work in this programming language.

Students learn how to apply Functions in the programming environment and interpret the information contained in Contracts: Name, Domain and Range. Image-producing functions provide an engaging context for this exploration.

Students learn to combine image transformation functions as well as to describe the order of operations involved in algebraic function compositions such as f(g(h(x))) using Circles of Evaluation.

Students learn to improve readability, performance and maintanability of code by defining values that repeat in code, just as we would define variables in math.

Students recreate images of flags of varying complexity by transforming and composing image functions and applying their knowledge of ratios and coordinates to scale and position the shapes precisely.

Students discover that they can make their own functions and are introduced to a structured approach to building them called the Design Recipe.

Students are introduced to the Design Recipe as a scaffold for breaking down word problems into chunks that will support them in writing code.

Students implement animation using a modified Model-View-Controller paradigm called Reactors. Using a data structure to represent the position of an object, they write draw functions to draw single frame from instances of that structure and update functions to generate new instances from previous ones. They learn how to use Reactors to combine their structure and functions into a complete animation.

Students are introduced to if-then-else expressions, writing conditionals that deal with simple types (Numbers, Strings, Booleans, etc) and data structures of their own to implement a more complex animation.

Students are introduced to key events, and use if-then-else expressions to write a key-event handler that moves an image left and right as part of an interactive animation.

This lesson focuses on code quality. Starting from a working program, students refactor the code to be more readable, writing helper functions thinking structurally about a complex program.

This lesson removes earlier scaffolding from working with Reactors, having students brainstorm an original animation of their own and implement it from start-to-finish. This requires them to plan out what kind of data structure they will need, and how it will be drawn and updated.

Students create a game of their own design using what they have learned so far.

Students use the distance formula and their data structures to determine when two or more characters in their games have collided. They extend their update handlers to generate a new structure that represents the game after a collision has occurred.

Students extend the data structure that represents their game to include a score, then modify their helper functions and event handlers to update and display that score.

Students parameterize other parts of their game, so that the experience changes as the score increases. This track delves deeper into conditionals and abstraction, offering students a chance to customize their games further while applying those concepts.

Students use the Animation Design Worksheet to decompose a 2-player game of Pong, and implement it as a Reactor-based program.

Students refactor code from a simple animation to include structures within structures, and see how to use nested structures in their own games and animations to manage complexity.

Students parameterize other parts of their game, so that the experience changes as a new data field, a timer, changes. This track delves deeper into conditionals and abstraction, offering students two possible uses for a timer feature, and a chance to customize their games further while applying those concepts.

This is a single page that contains all the lessons listed above.