Standards in this Framework
Standards Mapped
Mapped to Course
Standard  Lessons 

CM.DRS.1.a
Represent data in different number systems, including binary, decimal, and hexadecimal. 

CM.DRS.1.b
Convert data between number systems (e.g., binary to decimal, decimal to hexadecimal). 

CM.DRS.2.a
Describe the characteristics of different variable data types, including i) Boolean; ii) character; iii) integer; iv) decimal (double/float); and v) string. 

CM.DRS.2.b
Differentiate between variable data types to determine the data type needed based upon intended use (e.g., character versus string, integer versus double/float). 

CM.DRS.3.a
Given a specific task or problem, determine the appropriate data structure (e.g., lists, arrays, objects) to represent data. 

CM.DRS.3.b
Perform tasks related to lists or arrays (onedimensional or twodimensional), including i) declare a list or array (onedimensional or twodimensional); ii) choose an appropriate data type for a list or an array; and iii) fill the list or array with data. 

CM.DRS.3.c
Access and manipulate a particular element of a list or an array. 

CM.DRS.3.d
Implement predefined objects to consolidate related information of different data types. 

CM.CP.1.a
Design a stepbystep plan to perform a task or solve a problem using a flowchart or pseudocode that outlines the subtasks needed. 

CM.CP.1.b
Define the variables needed to perform a task or solve a problem. 

CM.CP.1.c
Define the constraints of a task or problem (e.g., preconditions, postconditions) to determine the desired input and output. 

CM.CP.2.a
Write and implement Boolean expressions using logical and relational operators (e.g., !, &&, , ==, <, >, >=, <=, !=). 

CM.CP.2.b
Write and implement “if” conditional statements. 

CM.CP.2.c
Write and implement “if/else” conditional statements. 

CM.CP.2.d
Write and implement compound conditional statements (e.g., nested conditionals, chained conditional statements). 

CM.CP.2.e
Determine which parts of an algorithm are executed based on a condition being true or false. 

CM.CP.3.a
Write and implement “while” and “for” loops. 

CM.CP.3.b
Differentiate between loops that run a fixed number of times and loops that run an indefinite number of times (e.g., stopping dependent on variable conditions). 

CM.CP.3.c
Identify conditions that cause infinite loops. 

CM.CP.3.d
Determine the outcome of code segments that include loops. 

CM.CP.4.a
Write and implement the output phase of a computer program, which may include: i) formatting output in textbased environments; ii) displaying output through a graphical user interface; and iii) sending output to a physical device (e.g., speakers, robots, LED lights). 

CM.CP.4.b
Write output to a file. 

CM.CP.5.a
Write and implement input statements to store user given values into a program. 

CM.CP.5.b
Validate input data using exception coding (e.g., using a “while” loop to control valid input by a user). 

CM.CP.5.c
Determine what output a program will produce given a specific input. 

CM.CP.6.a
Implement library functions to process data. 

CM.CP.6.b
Implement library functions to perform mathematical operations (e.g., random, absolute value, square root, power). 

CM.CP.6.c
Implement void library functions and return library functions. 

CM.CP.6.d
Implement overloaded library functions. 

CM.CP.7.a
Write and implement a userdefined function to complete a task or subtask. 

CM.CP.7.b
Write and implement void functions and return functions. 

CM.CP.7.c
Write and implement functions that accept parameters. 

CM.CP.8.a
Differentiate between types of search routines. 

CM.CP.8.b
Differentiate between types of sort routines. 

CM.CP.8.c
Implement predefined algorithms. 

CM.CP.8.d
Implement a search routine on a onedimensional list or an array, including sequential search and binary search. 

CM.CP.8.e
Implement a sort routine on a onedimensional list or an array (e.g., selection sort, insertion sort, merge sort). 

CM.AP.1.a
Determine what components of programming are needed to implement a stepbystep plan to perform a specific task or solve a problem. 

CM.AP.1.b
Write a computer program that includes sequencing, selection (conditionals), and iteration (loops). 

CM.AP.1.c
Write and implement computer programs to solve mathematical problems using i) formulas and equations; ii) functions; iii) probability and statistics; and iv) dataanalysis. 

CM.AP.2.a
Create documentation using written comments to: i) describe the overall purpose of a program; ii) align a previously created stepbystep plan to a written program; iii) describe preconditions and postconditions; and iv) improve the readability of a program. 

CM.AP.3.a
Verify that the variable types are aligned to the purpose of the algorithm. 

CM.AP.3.b
Verify that global variables are set to constant values before run time. 

CM.AP.3.c
Differentiate between the scopes of variables (e.g., global scope versus local scope) and verify the intended use. 

CM.AP.4.a
Declare, initialize, and assign variables to represent mathematical expressions or statements. 

CM.AP.4.b
Implement order of operations, including logical and relational operators. 

CM.AP.4.c
Translate a mathematical expression or statement into a programming statement(s). 

CM.AP.5.a
Trace existing code of an algorithm to i) identify values at each stage of an algorithm; and ii) predict return values of functions given specific arguments. 

CM.AP.5.b
Use tracing to describe the intended purpose of existing code for an algorithm. 

CM.EP.1.a
Produce a given output by entering a data set. 

CM.EP.1.b
Test a program including boundary cases and inaccurate data types to verify the intended outcomes. 

CM.EP.2.a
Differentiate among syntax errors, runtime errors, and logic errors. 

CM.EP.2.b
Debug a program using various techniques: i) interpret syntax and runtime error messages; ii) place controlled breaks; iii) output intermediate results; iv) disable a section of code by converting it into a comment; v) trace code to identify logic errors; and vi) use debugging tools available in the programming environment 

CM.EP.3.a
Compare and contrast the efficiency of computer programs in terms of i) complexity of algorithms with the same intended outcomes; ii) memory space used; and iii) run time. 
