Search the California Content Standards

Standard:
Design and iteratively develop programs that combine control structures and use compound conditions.

Descriptive Statement:
Control structures can be combined in many ways. Nested loops are loops placed within loops, and nested conditionals allow the result of one conditional to lead to another. Compound conditions combine two or more conditions in a logical relationship (e.g., using AND, OR, and NOT). Students appropriately use control structures to perform repetitive and selection tasks. For example, when programming an interactive story, students could use a compound conditional within a loop to unlock a door only if a character has a key AND is touching the door. (CA CCSS for ELA/Literacy W.6.3, W.7.3, W.8.3) Alternatively, students could use compound conditionals when writing a program to test whether two points lie along the line defined by a particular linear function. (CA CCSS for Mathematics 8.EE.7) Additionally, students could use nested loops to program a character to do the "chicken dance" by opening and closing the beak, flapping the wings, shaking the hips, and clapping four times each; this dance "chorus" is then repeated several times in its entirety.

Standard:
Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.

Descriptive Statement:
Decomposition facilitates program development by allowing students to focus on one piece at a time (e.g., getting input from the user, processing the data, and displaying the result to the user). Decomposition also enables different students to work on different parts at the same time. Students break down (decompose) problems into subproblems, which can be further broken down to smaller parts. Students could create an arcade game, with a title screen, a game screen, and a win/lose screen with an option to play the game again. To do this, students need to identify subproblems that accompany each screen (e.g., selecting an avatar goes in the title screen, events for controlling character action and scoring goes in the game screen, and displaying final and high score and asking whether to play again goes in the win/lose screen). Alternatively, students could decompose the problem of calculating and displaying class grades. Subproblems might include: accept input for students grades on various assignments, check for invalid grade entries, calculate per assignment averages, calculate per student averages, and display histograms of student scores for each assignment. (CA CCSS for Mathematics 6.RP.3c, 6.SP.4, 6.SP.5)

Standard:
Create procedures with parameters to organize code and make it easier to reuse.

Descriptive Statement:
Procedures support modularity in developing programs. Parameters can provide greater flexibility, reusability, and efficient use of resources. Students create procedures and/or functions that are used multiple times within a program to repeat groups of instructions. They generalize the procedures and/or functions by defining parameters that generate different outputs for a wide range of inputs. For example, students could create a procedure to draw a circle which involves many instructions, but all of them can be invoked with one instruction, such as “drawCircle.” By adding a radius parameter, students can easily draw circles of different sizes. (CA CCSS for Mathematics 7.G.4) Alternatively, calculating the area of a regular polygon requires multiple steps. Students could write a function that accepts the number and length of the sides as parameters and then calculates the area of the polygon. This function can then be re-used inside any program to calculate the area of a regular polygon. (CA CCSS for Mathematics 6.G.1)

Standard:
Represent data in multiple ways.

Descriptive Statement:
Computers store data as sequences of 0s and 1s (bits). Software translates to and from this low-level representation to higher levels that are understandable by people. Furthermore, higher level data can be represented in multiple ways, such as the digital display of a color and its corresponding numeric RGB value, or a bar graph, a pie chart, and table representation of the same data in a spreadsheet. For example, students could use a color picker to explore the correspondence between the digital display or name of a color (high-level representations) and its RGB value or hex code (low-level representation). Alternatively, students could translate a word (high-level representation) into Morse code or its corresponding sequence of ASCII codes (low-level representation).

Standard:
Design algorithms to solve computational problems using a combination of original and existing algorithms.

Descriptive Statement:
Knowledge of common algorithms improves how people develop software, secure data, and store information. Some algorithms may be easier to implement in a particular programming language, work faster, require less memory to store data, and be applicable in a wider variety of situations than other algorithms. Algorithms used to search and sort data are common in a variety of software applications. For example, students could design an algorithm to calculate and display various sports statistics and use common sorting or mathematical algorithms (e.g., average) in the design of the overall algorithm. Alternatively, students could design an algorithm to implement a game and use existing randomization algorithms to place pieces randomly in starting positions or to control the "roll" of a dice or selection of a "card" from a deck.

Standard:
Justify the selection of specific control structures by identifying tradeoffs associated with implementation, readability, and performance.

Descriptive Statement:
The selection of control structures in a given programming language impacts readability and performance. Readability refers to how clear the program is to other programmers and can be improved through documentation. Control structures at this level may include, for example, conditional statements, loops, event handlers, and recursion. Students justify control structure selection and tradeoffs in the process of creating their own computational artifacts. The discussion of performance is limited to a theoretical understanding of execution time and storage requirements; a quantitative analysis is not expected. For example, students could compare the readability and program performance of iterative and recursive implementations of procedures that calculate the Fibonacci sequence. Alternatively, students could compare the readability and performance tradeoffs of multiple if statements versus a nested if statement.

Standard:
Iteratively design and develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.

Descriptive Statement:
In this context, relevant computational artifacts can include programs, mobile apps, or web apps. Events can be user-initiated, such as a button press, or system-initiated, such as a timer firing. For example, students might create a tool for drawing on a canvas by first implementing a button to set the color of the pen. Alternatively, students might create a game where many events control instructions executed (e.g., when a score climbs above a threshold, a congratulatory sound is played; when a user clicks on an object, the object is loaded into a basket; when a user clicks on an arrow key, the player object is moved around the screen).

Standard:
Decompose problems into smaller subproblems through systematic analysis, using constructs such as procedures, modules, and/or classes.

Descriptive Statement:
Decomposition enables solutions to complex problems to be designed and implemented as more manageable subproblems. Students decompose a given problem into subproblems that can be solved using existing functionalities, or new functionalities that they design and implement. For example, students could design a program for supporting soccer coaches in analyzing their teams' statistics. They decompose the problem in terms of managing input, analysis, and output. They decompose the data organization by designing what data will be stored per player, per game, and per team. Team players may be stored as a collection. Data per team player may include: number of shots, misses, saves, assists, penalty kicks, blocks, and corner kicks. Students design methods for supporting various statistical analyses and display options. Students design output formats for individual players or coaches.

Standard:
Create computational artifacts using modular design.

Descriptive Statement:
Computational artifacts are created by combining and modifying existing computational artifacts and/or by developing new artifacts. To reduce complexity, large programs can be designed as systems of interacting modules, each with a specific role, coordinating for a common overall purpose. Students should create computational artifacts with interacting procedures, modules, and/or libraries. For example, students could incorporate a physics library into an animation of bouncing balls. Alternatively, students could integrate open-source JavaScript libraries to expand the functionality of a web application. Additionally, students could create their own game to teach Spanish vocabulary words using their own modular design (e.g., including methods to: control scoring, manage wordlists, manage access to different game levels, take input from the user, etc.).

Standard:
Translate between different representations of data abstractions of real-world phenomena, such as characters, numbers, and images.

Descriptive Statement:
Computers represent complex real-world concepts such as characters, numbers, and images through various abstractions. Students translate between these different levels of data representations. For example, students could convert an HTML (Hyper Text Markup Language) tag for red font into RGB (Red Green Blue), HEX (Hexadecimal Color Code), HSL (Hue Saturation Lightness), RGBA( Red Green Blue Alpha), or HSLA (Hue Saturation Lightness and Alpha) representations. Alternatively, students could convert the standard representation of a character such as ! into ASCII or Unicode.