google-plus

Standards Alignment

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 Common Core Standards for Mathematics, covering most Functional and Algebraic standards across the Common Core 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.

What's Covered in 25 Hours?

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
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. Strategies for designing functions around data are presented in Bootstrap:2; all remaining steps are presented starting early in Bootstrap:1.
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. A block-based programming language is under active development and testing.
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. Strategies for designing functions around data are presented in Bootstrap:2; all remaining steps are presented starting early in Bootstrap:1.
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.