Contribute
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 State and Common Core Standards for Mathematics, covering most Functional and Algebraic standards across the 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.
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 examnples, 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 progammer. 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 |
| 1 (B) : 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 |
| 1 (D) : communicate mathematical ideas, reasoning, and their implications using multiple representations, including symbols, diagrams, graphs, and language as appropriate | Units 3-8 |
| 1 (F) : analyze mathematical relationships to connect and communicate mathematical ideas | Units 3-8 |
| 1 (G) : display, explain, and justify mathematical ideas and arguments using precise mathematical language in written or oral communication | Units 3-8 |
| 4 (B) : apply qualitative and quantitative reasoning to solve prediction and comparison of real-world problems involving ratios and rates | Unit 4 |
| 6 (B) : write an equation that represents the relationship between independent and dependent quantities from a table | Unit 4 |
| 9 (A) : write one-variable, one-step equations and inequalities to represent constraints or conditions within problems | Unit 6 |
| 10 (A) : model and solve one-variable, one-step equations and inequalities that represent problems, including geometric concepts | Unit 6 |
| 10 (B) : determine if the given value(s) make(s) one-variable, one-step equations or inequalities true | Unit 6 |
| 11 : 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 : Expressions, equations, and relationships. The student applies mathematical process standards to represent linear relationships using multiple representations. The student is expected to represent linear relationships using verbal descriptions, tables, graphs, and equations that simplify to the form y = mx + b | Units 4-5 |
| 10 (A) : write one-variable, two-step equations and inequalities to represent constraints or conditions within problems | Unit 6 |
| 11 (B): determine if the given value(s) make(s) one-variable, two-step equations and inequalities true | Unit 2 |
| 5 (I): 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 |
| 6 (C): use models and diagrams to explain the Pythagorean theorem | Unit 8 |
| 7 (C): use the Pythagorean Theorem and its converse to solve problems | Unit 8 |
| 7 (D): determine the distance between two points on a coordinate plane using the Pythagorean Theorem | Unit 8 |
| 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 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. | 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 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. |
| 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). | 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. | 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 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 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. | Bootstrap1 covers functions, variables, logic, and conditionals (this is all one needs to create a rich game in our software infrastructure!). Bootstrap2 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. | Design and execution of test cases is emphasized throughout Bootstrap1 and Bootstrap2. 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's Design Recipe emphasizes design, coding, and testing from early in Bootstrap1. The process is explicit in Bootstrap's worksheets and exercises. Bootstrap2 continues to emphasize this process. |
| L3:CPP:A2: Use mobile devices/emulators to design, develop, and implement mobile computing applications. | Bootstrap2 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). | Testing is emphasized throughout Bootstrap. Bootstrap1 drills black-box test cases (with tests written before corresponding code). As problems get more challenging in Bootstrap2, students begin to confront elements of white-box testing as well. Bootstrap does not introduce modular programming, as would be required to cover unit or integration testing. |
| L3:CPP:A4: Apply analysis, design, and implementation techniques to solve problems (e.g., use one or more software lifecycle models). | Bootstrap's Design Recipe is a step-by-step software development technique that emphasixes 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 | Bootstrap1 introduces this process at a general level; students dig deeper into how programs evaluate when they reach loops in Bootstrap2. |
| L3:CPP:A12: Describe how mathematical and statistical functions, sets, and logic are used in computation. | Bootstrap1 puts mathematical and logical functions in the context of programming videogames. Bootstrap2 introduces sets and their implementation via lists. |
| L3:CT:B5: Use data analysis to enhance understanding of complex natural and human systems. | Bootstrap2 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). | Bootstrap2 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). 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. | Bootstrap2 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). | Bootstrap1 introduces the core idea of functions as abstractions over repeated computations. Bootstrap2 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. | Bootstrap2 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. |