common core state standards
MATH.PRACTICE.MP1
Make sense of problems and persevere in solving them. Plans a solution pathway rather than simply jumping into a solution attempt.
MATH.PRACTICE.MP1
Make sense of problems and persevere in solving them. Uses concrete objects or pictures to help conceptualize and solve a problem.
MATH.PRACTICE.MP3
Construct viable arguments and critique others’ reasoning. Analyzes situations by breaking them into cases.
MATH.CONTENT.6.EE.A.2
Apply and extend previous understandings of arithmetic to algebraic expressions. Write, read, and evaluate expressions in which letters stand for numbers.
ELA-LITERACY.RST.6-8.3
Key Ideas and Details. Follow precisely a multistep procedure when carrying out experiments, taking measurements, or performing technical tasks.
ELA-LITERACY.RST.6-8.4
Craft and Structure. Determine the meaning of symbols, key terms, and other domain-specific words and phrases as they are used in a specific scientific or technical context relevant to grades 6–8 texts and topics.
ELA-LITERACY.RST.6-8.7
Integration of Knowledge and Ideas. Integrate quantitative or technical information expressed in words in a text with a version of that information expressed visually (e.g., in a flowchart, diagram, model, graph, or table).
ELA-LITERACY.RST.9-10.4
Craft and Structure. Determine the meaning of symbols, key terms, and other domain-specific words and phrases as they are used in a specific scientific or technical context relevant to grades 9–10 texts and topics.
ELA-LITERACY.RST.9-10.7
Integration of knowledge and Ideas. Translate quantitative or technical information expressed in words in a text into visual form (e.g., a table or chart) and translate information expressed visually or mathematically (e.g., in an equation) into words.
CSTA K-12 Computer Science Standards
LEVEL 1B (AGES 8-11)
Algorithms: Compare and refine multiple algorithms for the same task and determine which is the most appropriate. (P6 .3, P3.3)
LEVEL 1B (AGES 8-11)
Variables: Create programs that use variables to store and modify data. (P5.2)
LEVEL 1B (AGES 8-11)
Control: Create programs that include sequences, events, loops, and conditionals. (P5.2)
LEVEL 1B (AGES 8-11)
Modularity: Decompose (break down) problems into smaller, manageable subproblems to facilitate the program development process. (P3.2)
LEVEL 1B (AGES 8-11)
Modularity: Modify, remix, or incorporate portions of an existing program into one's own work, to develop something new or add more advanced features. (P5.3)
LEVEL 1B (AGES 8-11)
Program Development: Use an iterative process to plan the development of a program by including others' ' perspectives and considering user preferences. (P1.1, P5.1)
LEVEL 1B (AGES 8-11)
Program Development: Test and debug (identify and fix errors) a program or algorithm to ensure it runs as intended. (P6 .1, P6 .2)
LEVEL 1B (AGES 8-11)
Program Development: Describe choices made during program development using code comments, presentations, and demonstrations. (P7.2)
LEVEL 2 (AGES 11-14)
Variables: Create clearly named variables that represent different data types and perform operations on their values. (P5.1, P5.2)
LEVEL 2 (AGES 11-14)
Control: Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals. (P5.1, P5.2)
LEVEL 2 (AGES 11-14)
Modularity: Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs. (P3.2)
LEVEL 2 (AGES 11-14)
Modularity: Create procedures with parameters to organize code and make it easier to reuse. (P4 .1, P4 .3)
LEVEL 2 (AGES 11-14)
Program Development: Incorporate existing code, media, and libraries into original programs, and give attribution. (P4 .2, P5.2, P7.3)
LEVEL 2 (AGES 11-14)
Program Development: Systematically test and refine programs using a range of test cases. (P6 .1)
LEVEL 2 (AGES 11-14)
Program Development: Document programs in order to make them easier to follow, test, and debug. (P7.2)
LEVELS 3A (AGES 14-16)
Variables: Use lists to simplify solutions, generaliz ing computational problems instead of repeatedly using simple variables. (P4 .1)
LEVELS 3A (AGES 14-16)
Control: Justify the selection of specific control structures when tradeoffs involve implementation, readability, and program performance, and explain the benefits and drawbacks of choices made. (P5.2)
LEVELS 3A (AGES 14-16)
Modularity: Decompose problems into smaller components through systematic analysis, using constructs such as procedures, modules, and/or objects. (P3.2)
LEVELS 3A (AGES 14-16)
Program Development: Document design decisions using text, graphics, presentations, and/or demonstrations in the development of complex programs. (P7.2)
LEVEL 3B (17-18)
Algorithms: Use and adapt classic algorithms to solve computational problems. (P4 .2)
LEVEL 3B (17-18)
Algorithms: Evaluate algorithms in terms of their efficiency, correctness, and clarity. (P4 .2)
LEVEL 3B (17-18)
Variables: Compare and contrast fundamental data structures and their uses. (P4 .2)
LEVEL 3B (17-18)
Modularity: Demonstrate code reuse by creating programming solutions using libraries and APIs. (P5.3)
LEVEL 3B (17-18)
Program Development: Develop and use a series of test cases to verify that a program performs according to its design specifications. (P6 .1)
National curriculum in England
KEY STAGE 1
Create and debug simple programs.
KEY STAGE 1
Use logical reasoning to predict the behavior of simple programs.
KEY STAGE 2
Design, write and debug programs that accomplish specific goals, including controlling or simulating physical systems; solve problems by decomposing them into smaller parts
KEY STAGE 2
Use sequence, selection, and repetition in programs; work with variables and various forms of input and output
KEY STAGE 2
Use logical reasoning to explain how some simple algorithms work and to detect and correct errors in algorithms and programs
KEY STAGE 3
Design, use and evaluate computational abstractions that model the state and behaviour of real-world problems and physical systems
KEY STAGE 3
Understand several key algorithms that reflect computational thinking [for example, ones for sorting and searching]; use logical reasoning to compare the utility of alternative algorithms for the same problem
KEY STAGE 3
Use 2 or more programming languages, at least one of which is textual, to solve a variety of computational problems; make appropriate use of data structures [for example, lists, tables or arrays]; design and develop modular programs that use procedures or functions.
KEY STAGE 3
Understand simple Boolean logic [for example, AND, OR and NOT] and some of its uses in circuits and programming;
KEY STAGE 4
Understand how instructions are stored and executed within a computer system;