Search the California Content Standards

Standard:
Design a project that combines hardware and software components to collect and exchange data.

Descriptive Statement:
Collecting and exchanging data involves input, output, storage, and processing. When possible, students select the components for their project designs by considering tradeoffs between factors such as functionality, cost, size, speed, accessibility, and aesthetics. Students do not need to implement their project design in order to meet this standard. For example, students could design a mobile tour app that displays information relevant to specific locations when the device is nearby or when the user selects a virtual stop on the tour. They select appropriate components, such as GPS or cellular-based geolocation tools, textual input, and speech recognition, to use in their project design. Alternatively, students could design a project that uses a sensor to collect the salinity, moisture, and temperature of soil. They may select a sensor that connects wirelessly through a Bluetooth connection because it supports greater mobility, or they could instead select a physical USB connection that does not require a separate power source. (CA NGSS: MS-ETS1-1, MS-ETS1-2)

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:
Describe ways in which abstractions hide the underlying implementation details of computing systems to simplify user experiences.

Descriptive Statement:
An abstraction is a representation of an idea or phenomenon that hides details irrelevant to the question at hand. Computing systems, both stand alone and embedded in products, are often integrated with other systems to simplify user experiences. For example, students could identify geolocation hardware embedded in a smartphone and describe how this simplifies the users experience since the user does not have to enter her own location on the phone. Alternatively, students might select an embedded device such as a car stereo, identify the types of data (e.g., radio station presets, volume level) and procedures (e.g., increase volume, store/recall saved station, mute) it includes, and explain how the implementation details are hidden from the user.

Standard:
Compare levels of abstraction and interactions between application software, system software, and hardware.

Descriptive Statement:
At its most basic level, a computer is composed of physical hardware on which software runs. Multiple layers of software are built upon various layers of hardware. Layers manage interactions and complexity in the computing system. System software manages a computing device's resources so that software can interact with hardware. Application software communicates with the user and the system software to accomplish its purpose. Students compare and describe how application software, system software, and hardware interact. For example, students could compare how various levels of hardware and software interact when a picture is to be taken on a smartphone. Systems software provides low-level commands to operate the camera hardware, but the application software interacts with system software at a higher level by requesting a common image file format (e.g., .png) that the system software provides.

Standard:
Analyze a large-scale computational problem and identify generalizable patterns or problem components that can be applied to a solution.

Descriptive Statement:
As students encounter complex, real-world problems that span multiple disciplines or social systems, they need to be able to decompose problems and apply already developed code as part of their solutions. Students decompose complex problems into manageable subproblems that could potentially be solved with programs or procedures that can be reused or already exist. For example, in analyzing an Internet radio app, students could identify that users need to create an account and enter a password. They could identify a common application programming interface (API) for checking and displaying password strength. Additionally, students could recognize that the songs would need to be sorted by the time last played in order to display the most recently played songs and identify a common API for sorting dates from most to least recent. Alternatively, in analyzing the problem of tracking medical treatment in a hospital, students could recognize that patient records need to be stored in a database and identify a database solution to support quick access and modification of patient records. Additionally, they could recognize that records in the database need to be stored securely and could identify an encryption API to support the desired level of privacy.

Standard:
Construct solutions to problems using student-created components, such as procedures, modules, and/or objects.

Descriptive Statement:
Programmers often address complex tasks through design and decomposition using procedures and/or modules. In object-oriented programming languages, classes can support this decomposition. Students create a computational artifact that solves a problem through use of procedures, modules, and/or objects. This problem should be of sufficient complexity to benefit from decomposition and/or use of objects. For example, students could write a flashcard program in which each card is able to show both the question and answer and record user history. Alternatively, students could create a simulation of an ecosystem in which sprites carry out behaviors, such as consuming resources.

Standard:
Demonstrate code reuse by creating programming solutions using libraries and APIs.

Descriptive Statement:
Code reuse is critical both for managing complexity in modern programs, but also in increasing programming efficiency and reliability by having programmers reuse code that has been highly vetted and tested. Software libraries allow developers to integrate common and often complex functionality without having to reimplement that functionality from scratch. Students identify, evaluate, and select appropriate application programming interfaces (APIs) from software libraries to use with a given language and operating system. They appropriately use resources such as technical documentation, online forums, and developer communities to learn about libraries and troubleshoot problems with APIs that they have chosen. For example, students could import charting and graphing modules to display data sets, adopt an online service that provides cloud storage and retrieval for a database used in a multiplayer game, or import location services into an app that identifies points of interest on a map. Libraries of APIs can be student-created or publicly available (e.g., common graphics libraries or map/navigation APIs).

Standard:
Illustrate ways computing systems implement logic through hardware components.

Descriptive Statement:
Computing systems use processors (e.g., a central processing unit or CPU) to execute program instructions. Processors are composed of components that implement the logical or computational operations required by the instructions. AND, OR, and NOT are examples of logic gates. Adders are examples of higher-leveled circuits built using low-level logic gates. Students illustrate how modern computing devices are made up of smaller and simpler components which implement the logic underlying the functionality of a computer processor. At this level, knowledge of how logic gates are constructed is not expected. For example, students could construct truth tables, draw logic circuit diagrams, or use an online logic circuit simulator. Students could explore the interaction of the CPU, RAM, and I/O by labeling a diagram of the von Neumann architecture. Alternatively, students could design higher-level circuits using low-level logic gates (e.g., adders).

Standard:
Categorize and describe the different functions of operating system software.

Descriptive Statement:
Operating systems (OS) software is the code that manages the computer’s basic functions. Students describe at a high level the different functions of different components of operating system software. Examples of functions could include memory management, data storage/retrieval, processes management, and access control. For example, students could use monitoring tools including within an OS to inspect the services and functions running on a system and create an artifact to describe the activity that they observed (e.g., when a browser is running with many tabs open, memory usage is increased). They could also inspect and describe changes in the activity monitor that occur as different applications are executing (e.g., processor utilization increases when a new application is launched).