Extra lessons are nice, but Math teachers don't have 25 hours of spare classtime to spend on new materials, no matter how good it might be.
That's why Bootstrap is aligned to National and State Standards for Mathematics, covering most Functional and Algebraic standards from Grade 7 through Algebra 2. This alignment makes it possible to integrate Bootstrap into the classroom smoothly, using time you've already planned into your pacing guidelines or scope and sequence plans.
For states using the Common Core, Bootstrap is also a model implementation of Common Core Standards for Mathematical Practice, offering explicit pedgagogical recommendation across all eight practice standards.
Bootstrap also satisfies several of the CSTA (Computer Science Teacher's Association) standards across levels 1 (grades K-6), 2 (grades 6-9), and 3 (grades 9-12); Bootstrap1 (the algebra-oriented first course) covers standards in levels 1 and 2, while Bootstrap2 goes deeper into computer science and covers more standards in levels 2 and 3.
Practice Standard |
Alignment |
MP.1: Make sense of problems and persevere in solving them | Bootstrap students are confronted with challenging problems, and use a problem-solving methodology known as the Design Recipe to solve them. The recipe teaches critical thinking, asking students to write down what they know and think through each step on their way to a solution. |
MP.2: Reason abstractly and quantitatively | Students focus on mathematical models of program behavior, and use quantitative examples to prove these models correct. |
MP.3: Construct viable arguments and critique the reasoning of others | Teachers engage students in discussion about each step in the Design Recipe, asking them to explain how they move from one step to another. In addition, students are challenged to debug the code of others, not just by identifying programmatic flaws but by also identifying faulty reasoning. |
MP.4: Model with mathematics | When Bootstrap students want their characters to move, to stay onscreen or collide with one another, they must first model that behavior mathematically. And since the programming language is purely algebraic, these models become the programs themselves! |
MP.5: Use appropriate tools strategically | Even programmers know that a computer isn't the perfect tool for every situation. Bootstrap students draw graphical diagrams, write out written examples, and use the computer when the situation calls for it. |
MP.6: Attend to precision | Communicating precisely is key, whether you're a mathematician or a professional programmer. In Bootstrap, students consider datatypes, select clear function and variable names, and write comments for their code. |
MP.7: Look for and make use of structure | Bootstrap students look closely at worked-out examples before generalizing to a formula, as part of the Design Recipe. When working with the Circles of Evaluation, students consider the structure of arithmetic expressions as functions being composed on one another -- and this structure becomes the basis for their code. |
MP.8: Look for and express regularity in repeated reasoning | By practicing the Design Recipe repeatedly, students begin to discern the connection between multiple representations of functions. They notice patterns in the examples they write and contracts they derive. |
Algebra Standard |
Bootstrap Units |
N-Q: Reason quantitatively and use units to solve problems. | Units 1, 2, 3 and 5 |
6.NS.5-8: Apply and extend previous understandings of numbers to the system of rational numbers. | Unit 1 |
7.EE.1-4: The student uses numerical and algebraic expressions and equations to solve real-life and mathematical problems. | Units 3 and 6 |
8.F.1-3: Define, evaluate, and compare functions. | Unit 4, 6 and 8 |
A-SSE.1-2: Interpret the structure of expressions | Units 1, 2, 3, 7 and Supplemental Lessons |
A-SSE.3-4: Write expressions in equivalent forms to solve problems | Units 1, 2 and Supplemental Lessons |
A-CED.1-4: Create equations that describe numbers or relationships | Units 3, 4, 5, 6, 7, 8 and Supplemental Lessons |
A-REI.1-2: Understand solving equations as a process of reasoning and explain the reasoning | Units 1, 2 and Supplemental Lessons |
A-REI.3-4: Solve equations and inequalities in one variable | Unit 6 |
A-REI.10-12: Represent and solve equations and inequalities graphically | Unit 6 |
8.G.6-8: Understand and apply the Pythagorean Theorem | Unit 8 |
F-IF.1-3: Understand the concept of a function and use function notation | Units 2-9 and Supplemental Lessons |
F-IF.4-6: Interpret functions that arise in applications in terms of the context | Units 3, 4, 6, 8 and Supplemental Lessons |
F.IF.7-9: Analyze functions using different representations | Units 3-9 and Supplemental Lessons |
F-BF.1-2: Build a function that models a relationship between two quantities | Units 3-9 and Supplemental Lessons |
F-BF.3-4: Build new functions from existing functions | Units 6, 7, 8 and Supplemental Lessons |
F-LE.1-4: Construct and compare linear, quadratic, and exponential models and solve problems | Unit 3 |
F-LE.5: Interpret expressions for functions in terms of the situation they model | Unit 5 and Supplemental Lessons |
F-TF.5: Model periodic phenomena with trigonometric functions | Supplemental Lessons |
TEKS Standard | Alignment |
1A (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to apply mathematics to problems arising in everyday life, society, and the workplace | Units 3-8 |
1B (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to use a problem-solving model that incorporates analyzing given information, formulating a plan or strategy, determining a solution, justifying the solution, and evaluating the problem-solving process and the reasonableness of the solution | Units 3-8 |
1C (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to select tools, including real objects, manipulatives, paper and pencil, and technology as appropriate, and techniques, including mental math, estimation, and number sense as appropriate, to solve problems; | Units 3-8 |
1D (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to communicate mathematical ideas, reasoning, and their implications using multiple representations, including symbols, diagrams, graphs, and language as appropriate | Units 3-8 |
1F (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to analyze mathematical relationships to connect and communicate mathematical ideas | Units 3-8 |
1G (all grades): Mathematical process standards. The student uses mathematical processes to acquire and demonstrate mathematical understanding. The student is expected to display, explain, and justify mathematical ideas and arguments using precise mathematical language in written or oral communication | Units 3-8 |
5.4F: Algebraic reasoning. The student applies mathematical process standards to develop concepts of expressions and equations. The student is expected to simplify numerical expressions that do not involve exponents, including up to two levels of grouping. | Units 1-2 |
5.8A: Geometry and measurement. The student applies mathematical process standards to identify locations on a coordinate plane. The student is expected to describe the key attributes of the coordinate plane, including perpendicular number lines (axes) where the intersection (origin) of the two lines coincides with zero on each number line and the given point (0, 0); the x-coordinate, the first number in an ordered pair, indicates movement parallel to the x-axis starting at the origin; and the y-coordinate, the second number, indicates movement parallel to the y-axis starting at the origin. | Unit 1 |
5.8B: Geometry and measurement. The student applies mathematical process standards to identify locations on a coordinate plane. The student is expected to describe the process for graphing ordered pairs of numbers in the first quadrant of the coordinate plane. | Unit 1 |
5.8C: Geometry and measurement. The student applies mathematical process standards to identify locations on a coordinate plane. The student is expected to graph in the first quadrant of the coordinate plane ordered pairs of numbers arising from mathematical and real-world problems, including those generated by number patterns or found in an input-output table. | Units 1-2 |
6.2C: Number and operations. The student applies mathematical process standards to represent and use rational numbers in a variety of forms. The student is expected to locate, compare, and order integers and rational numbers using a number line. | Units 1-2 |
6.4B: Proportionality. The student applies mathematical process standards to develop an understanding of proportional relationships in problem situations. The student is expected to apply qualitative and quantitative reasoning to solve prediction and comparison of real-world problems involving ratios and rates. | Units 4-5 |
6.6A: Expressions, equations, and relationships. The student applies mathematical process standards to use multiple representations to describe algebraic relationships. The student is expected to identify independent and dependent quantities from tables and graphs. | Units 4-8 |
6.6B: Expressions, equations, and relationships. The student applies mathematical process standards to use multiple representations to write an equation that represents the relationship between independent and dependent quantities from a table. | Units 4-8 |
6.7A: Expressions, equations, and relationships. The student applies mathematical process standards to develop concepts of expressions and equations. The student is expected to generate equivalent numerical expressions using order of operations, including whole number exponents, and prime factorization. | Units 1-2 |
6.9A: Expressions, equations, and relationships. The student applies mathematical process standards to use equations and inequalities to represent situations. The student is expected to write one-variable, one-step equations and inequalities to represent constraints or conditions within problems. | Units 4-8 |
6.10A: Expressions, equations, and relationships. The student applies mathematical process standards to use equations and inequalities to solve problems. The student is expected to model and solve one-variable, one-step equations and inequalities that represent problems, including geometric concepts. | Units 4-8 |
6.10B: Expressions, equations, and relationships. The student applies mathematical process standards to use equations and inequalities to solve problems. The student is expected to determine if the given value(s) make(s) one-variable, one-step equations or inequalities true. | Units 4-8 |
6.11A: Measurement and data. The student applies mathematical process standards to use coordinate geometry to identify locations on a plane. The student is expected to graph points in all four quadrants using ordered pairs of rational numbers. | Unit 2 |
7.5C: Proportionality. The student applies mathematical process standards to use geometry to describe or solve problems involving proportional relationships. The student is expected to solve mathematical and real-world problems involving similar shape and scale drawings. | Units 2-3 |
7.10A: Expressions, equations, and relationships. The student applies mathematical process standards to use one-variable equations and inequalities to represent situations. The student is expected to write one-variable, two-step equations and inequalities to represent constraints or conditions within problems. | Units 6, 8 |
7.11B: Expressions, equations, and relationships. The student applies mathematical process standards to solve one-variable equations and inequalities. The student is expected to determine if the given value(s) make(s) one-variable, two-step equations and inequalities true. | Units 6, 8 |
8.3A: Proportionality. The student applies mathematical process standards to use proportional relationships to describe dilations. The student is expected to generalize that the ratio of corresponding sides of similar shapes are proportional, including a shape and its dilation. | Unit 2, Supplemental Units |
8.3B: Proportionality. The student applies mathematical process standards to use proportional relationships to describe dilations. The student is expected to compare and contrast the attributes of a shape and its dilation(s) on a coordinate plane. | Unit 2, Supplemental Units |
8.5I: Proportionality. The student applies mathematical process standards to use proportional and non-proportional relationships to develop foundational concepts of functions. The student is expected to write an equation in the form y = mx + b to model a linear relationship between two quantities using verbal, numerical, tabular, and graphical representations. | Units 4-5 |
8.6C: Expressions, equations, and relationships. The student applies mathematical process standards to develop mathematical relationships and make connections to geometric formulas. The student is expected to use models and diagrams to explain the Pythagorean theorem. | Unit 8 |
8.7C: Expressions, equations, and relationships. The student applies mathematical process standards to use geometry to solve problems. The student is expected to use the Pythagorean theorem and its converse to solve problems. | Unit 8 |
8.7D: Expressions, equations, and relationships. The student applies mathematical process standards to use geometry to solve problems. The student is expected to determine the distance between two points on a coordinate plane using the Pythagorean theorem. | Unit 8 |
A.2A: Linear functions, equations, and inequalities. The student applies the mathematical process standards when using properties of linear functions to write and represent in multiple ways, with and without technology, linear equations, inequalities, and systems of equations. The student is expected to determine the domain and range of a linear function in mathematical problems; determine reasonable domain and range values for real-world situations, both continuous and discrete; and represent domain and range using inequalities. | Units 4-8 |
A.6A: Quadratic functions and equations. The student applies the mathematical process standards when using properties of quadratic functions to write and represent in multiple ways, with and without technology, quadratic equations. The student is expected to determine the domain and range of quadratic functions and represent the domain and range using inequalities. | Units 4, Supplemental Units |
A.7A: Quadratic functions and equations. The student applies the mathematical process standards when using graphs of quadratic functions and their related transformations to represent in multiple ways and determine, with and without technology, the solutions to equations. The student is expected to graph quadratic functions on the coordinate plane and use the graph to identify key attributes, if possible, including x-intercept, y-intercept, zeros, maximum value, minimum values, vertex, and the equation of the axis of symmetry. | Units 4, Supplemental Units |
G.2A: Coordinate and transformational geometry. The student uses the process skills to understand the connections between algebra and geometry and uses the one- and two-dimensional coordinate systems to verify geometric conjectures. The student is expected to understand the connections between algebra and geometry and uses the one- and two-dimensional coordinate systems to verify geometric conjectures. | Unit 8 |
G.2B: Coordinate and transformational geometry. The student uses the process skills to understand the connections between algebra and geometry and uses the one- and two-dimensional coordinate systems to verify geometric conjectures. The student is expected to derive and use the distance, slope, and midpoint formulas to verify geometric relationships, including congruence of segments and parallelism or perpendicularity of pairs of lines. | Unit 8 |
G.3A: Coordinate and transformational geometry. The student uses the process skills to generate and describe rigid transformations (translation, reflection, and rotation) and non-rigid transformations (dilations that preserve similarity and reductions and enlargements that do not preserve similarity). The student is expected to describe and perform transformations of figures in a plane using coordinate notation. | Unit 2, Supplemental Units |
G.4B: Logical argument and constructions. The student uses the process skills with deductive reasoning to understand geometric relationships. The student is expected to identify and determine the validity of the converse, inverse, and contrapositive of a conditional statement and recognize the connection between a biconditional statement and a true conditional statement with a true converse | Unit 7 |
G.4C: Logical argument and constructions. The student uses the process skills with deductive reasoning to understand geometric relationships. The student is expected to verify that a conjecture is false using a counterexample. | Unit 7 |
CSTA Standard |
Alignment |
L1:6:CT.1: Understand and use the basic steps in algorithmic problem-solving (e.g., problem statement and exploration, examination of sample instances, design, implementation, and testing). |
Bootstrap:Algebra - Units 2-8
Bootstrap:Reactive - Units 1-10 Bootstrap teaches students to develop programs and solve problems through a concrete sequence of steps called the Design Recipe. Summarizing problem statements, writing test cases, designing functions around data, coding, and testing are all explicit steps in this recipe. Bootstrap1 begins introducing these steps in unit 2, building on them throughout the curriculum. Bootstrap2 extends these steps into richer structured data. |
L1:6:CPP.6: Implement problem solutions using a block-based visual programming language. |
N/A
Bootstrap currently has students implement programs in a simple textual language. |
L2:CT:1: Use the basic steps in algorithmic problem-solving to design solutions (e.g., problem statement and exploration, examination of sample instances, design, implementing a solution, testing, evaluation). |
Bootstrap:Algebra - Units 2-8
Bootstrap:Reactive - Units 1-10 Bootstrap teaches students to develop programs and solve problems through a concrete sequence of steps called the Design Recipe. Summarizing problem statements, writing test cases, designing functions around data, coding, and testing are all explicit steps in this recipe. Bootstrap:Algebra begins introducing these steps in unit 2, building on them throughout the curriculum. Bootstrap:Reactive extends these steps into richer structured data. |
L2:CT:6: Describe and analyze a sequence of instructions being followed (e.g., describe a character's behavior in a video game as driven by rules and algorithms). |
Bootstrap:Algebra - Units 5 and 7
Bootstrap:Reactive - Units 3-6, 8-10 In Bootstrap, students write algebraic functions that are used repeatedly to move characters across a screen and respond to key presses. Bootstrap emphasizes sequences of instructions less than other early programming efforts, but in doing so gains close adherence to algebra. |
L2:CT:7: Represent data in a variety of ways including text, sounds, pictures, and numbers. |
Bootstrap:Algebra - Units 2-8
Bootstrap:Reactive - Units 1-10 Students write functions that consume and produce each of text, images, and numbers in the Bootstrap curriculum. Functions over each datatype are used in students' games, as well in as the in-class exercises. |
L2:CT:14: Examine connections between elements of mathematics and computer science including binary numbers, logic, sets and functions. |
Bootstrap:Algebra - Units 1-9
Bootstrap:Reactive - Units 1-10 Bootstrap relies heavily on algebraic functions. Students learn how different representations of functions from mathematics (domain/range, input/output tables, and symbolic representations) correspond to important artifacts in writing programs. Within their games, students use Boolean logic to determine how characters move, to report collisions, and to determine when characters have moved off the screen. |
L2:CPP:4: Demonstrate an understanding of algorithms and their practical application. |
Bootstrap:Algebra - Units 3-8
Bootstrap:Reactive - Units 2-10 Bootstrap emphasizes computation, particularly the idea that computations are reusable with different inputs. Through their games and in-class exercises, students see various applications for reusable computations in practical settings. |
L2:CPP:5: Implement problem solutions using a programming language, including: looping behavior, conditional statements, logic, expressions, variables, and functions. |
Bootstrap:Algebra - Units 1-9
Bootstrap:Reactive - Units 1-10 Bootstrap:Algebra covers functions, variables, logic, and conditionals (this is all one needs to create a rich game in our software infrastructure!). Bootstrap:Reactive introduces looping in the context of handling multiple similar game elements with similar behavior. |
L2:CPP:9: Collect and analyze data that is output from multiple runs of a computer program. |
Bootstrap:Algebra - Units 3-8
Bootstrap:Reactive - Units 2-10 Design and execution of test cases is emphasized throughout Bootstrap:Algebra and Bootstrap:Reactive. Students are required to write multiple test cases (including expected answers for each) for each function; our software helps them track which tests are passing and which are failing. |
L3:CT:A2: Describe a software development process used to solve software problems (e.g. design, coding, testing, verification). |
Bootstrap:Algebra - Units 3-8
Bootstrap:Reactive - Units 1-10 Bootstrap's Design Recipe emphasizes design, coding, and testing from early in Bootstrap:Algebra. The process is explicit in Bootstrap's worksheets and exercises. Bootstrap:Reactive continues to emphasize this process. |
L3:CPP:A2: Use mobile devices/emulators to design, develop, and implement mobile computing applications. |
Bootstrap:Reactive - Unit 10
Bootstrap:Reactive has optional material on writing games that respond to common mobile-phone stimuli (such as shaking, tilting, and GPS), and a library for exporting these games to mobile phones. |
L3:CPP:A3: Use various debugging and testing methods to ensure program correctness (e.g., test cases, unit testing, white box, black box, integration testing). |
Bootstrap:Algebra - Units 3-8
Bootstrap:Reactive - Units 1-10 Testing is emphasized throughout Bootstrap. Bootstrap:Algebra drills black-box test cases (with tests written before corresponding code). As problems get more challenging in Bootstrap:Reactive, students begin to confront elements of white-box testing as well. Note: Bootstrap does not introduce modular programming, as would be required to cover integration testing. |
L3:CPP:A4: Apply analysis, design, and implementation techniques to solve problems (e.g., use one or more software lifecycle models). |
Bootstrap:Algebra - Units 2-8
Bootstrap:Reactive - Units 1-10 Bootstrap's Design Recipe is a step-by-step software development technique that emphasizes test-first and data-driven design. Bootstrap strongly recommends (and has exercises written for) pair programming, a common software development practice. |
L3:CPP:A8: Explain the program execution process |
Bootstrap:Algebra - Units 1-8
Bootstrap:Reactive - Units 1-10 Bootstrap1 introduces this process at a general level; students dig deeper into how programs evaluate when they reach loops in Bootstrap:Reactive. |
L3:CPP:A12: Describe how mathematical and statistical functions, sets, and logic are used in computation. |
Bootstrap:Algebra - Units 3-8
Bootstrap:Reactive - Units 1-10 Bootstrap puts mathematical and logical functions in the context of programming videogames. |
L3:CT:B5: Use data analysis to enhance understanding of complex natural and human systems. |
Bootstrap:Reactive - Units 3-10
Bootstrap:Reactive begins to emphasize data modeling: the Design Recipe includes an explicit step in which students determine how to model data for a problem and develop illustrative examples of the problem relative to their data model. |
L3:CT:B6: Compare and contrast simple data structures and their uses (e.g., arrays and lists). |
Bootstrap:Reactive - Units 2-10
Bootstrap:Reactive emphasizes the differences between structs (compound data with fixed numbers of fields) and lists (compound data with arbitrary numbers of elements). Students practice recognizing each of these basic data patterns in various problems, and learn how to nest these concepts to build richer data structures (advanced students can easily get to trees with this approach). Note: Bootstrap does not cover different linear data structures (lists versus arrays), preferring to emphasize how to design richer data structures from simple building blocks of structs and lists. |
L3:CT:B10: Decompose a problem by defining new functions and classes. |
Bootstrap:Algebra - Units 6 and 8
Bootstrap:Reactive - Units 4-10 Bootstrap introduces students to programming problems that benefit from decomposition into multiple functions and data structures. The Design Recipe provides some structured guidance on when to introduce new functions when decomposing problems. |
L3:CPP:B2: Use tools of abstraction to decompose a large-scale computational problem (e.g., procedural abstraction, object-oriented design, functional design). |
Bootstrap:Algebra - Units 6 and 8
Bootstrap:Reactive - Units 4-10 Bootstrap:Algebra introduces the core idea of functions as abstractions over repeated computations. Bootstrap:Reactive moves into larger programs that get decomposed into subproblems, which are designed, implemented, and tested independently. |
L3:CPP:B7: Use data analysis to enhance understanding of complex natural and human systems. |
Bootstrap:Reactive - Units 4-10
Bootstrap:Reactive begins to emphasize data modeling: the Design Recipe includes an explicit step in which students determine how to model data for a problem and develop illustrative examples of the problem relative to their data model. |
K12 CS Framework |
Alignment |
Practice 1: Fostering an Inclusive Computing Culture | By integrating Computing into standard math classes, Bootstrap allows schools to immediately create an inclusive computing environment. Everyone takes math, which means everyone computes. But in addition to the course settings the curriculum allows, Bootstrap also embeds teamwork, metacognition and group reflection into every step of the programming process - from co-designing a game to thinking about effective co-working strategies, Bootstrap's pedagogy fosters an inclusive culture. |
Practice 2: Collaborating Around Computing | Bootstrap students work on small teams, and must cultivate relationships with other students who possess diverse perspectives, skills and personalities. Students work on problems together, and are given strategies to evaluate and give feedback to one another at each step in the problem-solving process. |
Practice 3: Recognizing and Defining Computational Problems | Bootstrap uses real-world problems throughout the course, as students are constantly engaged in the creation of a meaningful computational artifact (a videogame of their own invention, modeling a physics simulation, or analyzing a rich dataset). Each part of this project requires that students identify problems that can be solved computationally, decompose those problems into sub-problems, and evaluate the limits of their solutions. |
Practice 4: Developing and Using Abstractions | Students develop and use abstractions throughout the course, starting with visual-spatial representations for arithmetic expressions and ending with complex, multi-function programs that define, use and re-use student-generated abstractions. Students define everything from Functions (Bootstrap:Algebra) to Data Structures (Bootstrap:Reactive), and Reactive Simulations (Bootstrap:Physics) to Big Data queries (Bootstrap:Data Science). |
Practice 5: Creating Computational Artifacts | Bootstrap's project-based approach is absed on the creation of computational artifacts. Students write programs to draw flags, make a rocket blast off, trap a butterfly, run a cash register, implement a videogame, answer real questions with data, and model an observed physical phenomenon. The creation of these artifacts is personal, customizable, and based on a rigorous methodology for iterative design and problem solving. |
Practice 6: Testing and Refining Computational Artifacts | Many introductory courses treat testing as a second-class citizen, either asking students to test by running a program and "seeing if it looks right" or by using programming tools that completely lack any framework for automated testing. By contrast, Bootstrap introduces testing early on in each course, and our languages and software enviroments offer rich support for writing tests and developing software based on test feedback. |
Practice 7: Communicating About Computing | Students in our Data Science module must choose a question that matters to them, select a relevant dataset, and answer that question - justifying their choice and answer at every step. Students in our Physics, Data Structures and Algebra courses explain their thinking as well, whether it's about the creation of a piecewise function to handle key events or a data structure to model an interactive program. |
Hardware and Software | Bootstrap:Reactive, Bootstrap:Data Science and Bootstrap:Physics introduce students to sophisticated programming paradigms, in which they must process user input as mediated by the software evironment. This mediation involves the flow of information from multiple sources (keyboards, mice, GPS systems, and internet-connected resources), and students must consider this flow when designing their programs. |
Troubleshooting | All Bootstrap modules embrace Example Driven Design, in which students write test cases for each abstraction they create. This bakes in troubleshooting by design: a student immediately has a mechanism to locate an error, and knows a pedagogical approach for debugging their thinking process. |
Data Collection | Students in Bootstrap:Data Science and Bootstrap:Physics collect data using an array of tools techniques: tapping into existing datasets (e.g. - Spreadsheets) as well as automated or manual sampling using an array of instruments. The choice of sampling mechanism is instruction, as it exposes students to the strengths and weaknesses of a particular approach. Movement-tracking via observation v. changes in a cell phone's GPS coordinates, for example, will influence the amount and quality of the data that is collected. |
Visualization and Transformation | Our Data Science module embraces authentic data science concepts in a lightweight fashion: students must identify, transform, clean and manipulate data sets as they explore a research question of their own design. This involves everything from visualizing to aggregation, and rearrangement to transformation. |
Inference and Models | Bootstrap:Algebra and Bootstrap:Reactive are all build around students' developing a model for a desired (or observed) behavior. Bootstrap:Algebra has students model the process of computation, and Bootstrap:Reactive gives students the ability to model the data behind it. Bootstrap:Physics goes one step farther, having students use these models to predict the behavior of a complex system. In these activities, the tradeoffs between model complexity and model quality become clear. |
Algorithms | Bootstrap students consider many algorithms throughout our material. They are confronted with multiple ways to reach a solution, asked to generalize a algorithms so they can be re-used for other problems, and given opportunities to discuss the tradeoffs between different approaches. |
Variables | Bootstrap introduces variables early on, with students confronting variables and functions almost immediately in Bootstrap:Algebra. These variables can be used to represent Numbers, Strings, Images, Booleans, data structures of infinite complexity, and even remote spreadsheets stored across the internet! Our pedagogy explicitly asks students to come up with meaningful identifiers for every variable they use, and Bootstrap:Reactive allows students to select their own Data Structures. (Note: in a slight deviation from the K12CS standards, Bootstrap uses the mathematical concept of variable. Namely, we do not discuss the notion of "machine storage", since that concept directly undermines the notion of variables in mathematics.) |
Control | Students in all of Bootstrap's modules confront program control, sequences of evaluation, and conditionals. Bootstrap:Reactive, Data Science and Physics add loops and event handlers, to create more complex behavior. |
Modularity | Bootstrap's focus on abstraction works hand in hand with the concept of modularity. Students decompose complex problems into smaller ones, and build abstractions (functions, data structures, etc) to solve them. The abstractions are used to organize code, and can be composed with one another or repurposed to solve more complex problems without having to duplicate code. Students assemble these abstractions to form complex, reactive programs - relying on the modularity of those abstractions to manage complexity. |
Program Development | Our pedagogy is based on a robust process for program development, known as the Design Recipe. This approach has been used for decades at the university level, and mirrors many best practices from industrial contexts. The Design Recipe is an iterative process that involves defining type specifications, communicating those specifications through writing, building example-driven test cases, implementation, and testing. |