Standards in this Framework
| Standard | Description |
|---|---|
| 1.1 | Establish objectives and outcomes for a task |
| 1.2 | Explain the process of decomposing a large programming problem into smaller, more manageable procedures |
| 1.3 | Explain “visualizing” as a problem-solving technique prior to writing code |
| 1.4 | Describe problem-solving and troubleshooting strategies applicable to software development |
| 2.1 | Identify common computer threats (e.g., viruses, phishing, suspicious email, social engineering, spoofing, identity theft, and spamming) |
| 2.2 | Describe potential vulnerabilities in software (e.g., OWASP’s Top 10) |
| 2.3 | Identify procedures to maintain data integrity and security (e.g., lock the screen, delete unrecognized emails, use trustworthy thumb drives, and use approved software) |
| 2.4 | Explain best practices to maintain integrity and security in software development (e.g., encryption, hashing, and digital signatures) |
| 2.5 | Describe methods for sanitizing user input to prevent issues (e.g., buffer overflows and SQL injection) |
| 2.6 | Explain the CIA (confidentiality, integrity, and availability) triad |
| 2.7 | Explain how software defects relate to software security (e.g., buffer overflows and cross-site scripting) |
| 3.1 | Explore intellectual property rights including software licensing and software duplication [e.g., Digital Millennium Copyright Act (DMCA), software licensing, and software duplication] |
| 3.2 | Compare and contrast open source and proprietary systems in relation to legal and ethical issues (e.g., data pricing, use of public and private networks, social networking, industry-related data, and data piracy) |
| 3.3 | Identify issues and regulations affecting computers, other devices, the internet, and information privacy (e.g., HIPAA, COPPA, CISPA, FERPA, PCI, GDPR, and data brokers) |
| 4.1 | Declare numeric, Boolean, character, string variables, and float and double |
| 4.2 | Choose the appropriate data type for a given situation |
| 4.3 | Identify the correct syntax and usage for constants and variables in a program |
| 4.4 | Identify the correct syntax and safe functions for operations on strings, including length, substring, and concatenation |
| 4.5 | Explain complications of storing and manipulating data (i.e., the Big-O notation for analyzing storage and efficiency concerns, etc.) |
| 4.6 | Research industry relevant programming languages (i.e., Java, JavaScript, Python, etc.) |
| 5.1 | Apply basic mathematics to hardware (e.g., bits, bytes, kilobytes, megabytes, gigabytes, and terabytes) |
| 5.2 | Use binary to decimal, decimal to hexadecimal, hexadecimal to decimal, binary to hexadecimal, and binary to hexadecimal conversions to solve hardware and software problems |
| 5.3 | Identify and correctly use arithmetic operations applying the order of operations (precedence) with respect to programming |
| 5.4 | Interpret and construct mathematical formulas |
| 5.5 | Identify correct and problematic uses of integers, floating-point numbers, and fixed-point numbers in arithmetic |
| 6.1 | Use the correct syntax for decision statements (e.g., if/else, if, and switch case) |
| 6.2 | Compare values using relational operators (e.g., =, >, <, >=, <=, and not equal) |
| 6.3 | Evaluate Boolean expressions (e.g., AND, OR, NOT, NOR, and XOR) |
| 6.4 | Use the correct nesting for decision structures |
| 7.1 | Identify various types of iteration structure (e.g., while, for, for-each, and recursion) |
| 7.2 | Identify how loops are controlled (variable conditions and exits) |
| 7.3 | Use the correct syntax for nested loops |
| 7.4 | Compute the values of variables involved with nested loops |
| 8.1 | Demonstrate basic uses of arrays including initialization, storage, and retrieval of values |
| 8.2 | Distinguish between arrays and hash maps (associative arrays) |
| 8.3 | Identify techniques for declaring, initializing, and modifying user-defined data types |
| 8.4 | Search and sort data in an array |
| 8.5 | Create and use two-dimensional arrays |
| 8.6 | Describe the efficiency of different sorting algorithms (e.g., bubble, insertion, and merge) |
| 8.7 | Describe the efficiency of linear vs. binary searches [e.g., O(n) and O(log n)] |
| 9.1 | Explain cloud-based computing and content delivery networks |
| 9.2 | Identify the components and functions of the internet (e.g., HTTP, HTTPS, FTP, IP addresses, and IMAP) |
| 9.3 | Identify services run by web servers [e.g., scripting languages (client- and server-side scripting), databases, and media] |
| 9.4 | Identify performance issues (e.g., bandwidth, internet connection types, pages loading slowly, resolution, and size graphics) |
| 9.5 | Differentiate among shared hosting, dedicated server, and virtual private server (VPS) |
| 9.6 | Identify Internet of Things (IOT) and common communication interfaces (e.g., Bluetooth, NFC, Wi-Fi, and LTE) |
| 10.1 | Identify key components and functions of internet and web specialty browsers |
| 10.2 | Use client collaboration sources/platforms (e.g., GitHub, Google Drive, Dropbox, JSFiddle, and browser developer tools) |
| 10.3 | Analyze remote computing tools and services and their application |
| 11.1 | Implement the steps in the System Development Life Cycle (SDLC) (e.g., planning, analysis, design, development, testing, implementation, and maintenance) |
| 11.2 | Develop program requirements/specifications and a testing plan (e.g., user stories, automated testing, and test procedures) |
| 11.3 | Apply pseudocode or graphical representations to plan the structure of a program or module (e.g., flowcharting, whiteboarding, and UML) |
| 11.4 | Create and implement basic algorithms |
| 12.1 | Use a program editor to enter and modify code |
| 12.2 | Identify correct input/output statements |
| 12.3 | Choose the correct method of assigning input to variables including data sanitization |
| 12.4 | Choose the correct method of outputting data with formatting and escaping |
| 12.5 | Differentiate between interpreted and compiled code (e.g., steps necessary to run executable code) |
| 12.6 | Identify the purpose of a build system (e.g., make, rake, ant, maven, SCons, and grunt) |
| 12.7 | Apply industry standards in documentation (e.g., self-documenting code; function-level, program-level, and user-level documentation) |
| 12.8 | Name identifiers and formatting code by applying recognized conventions |
| 12.9 | Demonstrate refactoring techniques to reduce repetitious code and improve maintainability |
| 12.10. | Demonstrate the use of parameters to pass data into program modules |
| 12.11 | Demonstrate the use of return values from modules |
| 13.1 | Identify errors in program modules |
| 13.2 | Identify boundary cases and generate appropriate test data |
| 13.3 | Perform integration testing including tests within a program to protect execution from bad input or other run-time errors |
| 13.4 | Categorize, identify, and correct errors in code, including syntax, semantic, logic, and runtime |
| 13.5 | Perform different methods of debugging (e.g., hand-trace code and real time debugging tools) |
| 14.1 | Use standard library functions |
| 14.2 | Find and use third party libraries (e.g., web-based and package managers) |
| 14.3 | Explain and interact with an Application Program Interface (API) |
| 15.1 | Identify the purpose of version control systems (e.g., Git and Mercurial) |
| 15.2 | Create a new repository |
| 15.3 | Add, push, and pull source code from repository |
| 15.4 | Explain branching and its uses |
| 15.5 | Restore previous versions of code from the repository |
| 16.1 | Apply W3C standards and style conventions |
| 16.2 | Construct web pages and applications that are compliant with ADA and sections 504 and 508 standards |
| 16.3 | Explain the concept of responsive design and applications |
| 16.4 | Employ graphics methods to create images at specified locations |
| 16.5 | Choose correct GUI objects for input and output of data to the GUI interface (e.g., text boxes, labels, radio buttons, check boxes, dropdowns, and list boxes) |
| 17.1 | Input/output data from a sequential file or database |
| 17.2 | Demonstrate creating, reading, updating, and dropping a database |
| 17.3 | Demonstrate the proper use of SQL database applications that work with different languages (e.g., MongoDB, Microsoft Access, Oracle Databases, and Code.org’s App Lab) |
| 18.1 | Make a distinction between an object and a class |
| 18.2 | Differentiate among inheritance, composition, and class relationships |
| 18.3 | Instantiate objects from existing classes |
| 18.4 | Read the state of an object by invoking accessor methods |
| 18.5 | Change the state of an object by invoking a modifier method |
| 18.6 | Determine the requirements for constructing new objects by reading the documentation |
| 18.7 | Create a user-defined class |
| 18.8 | Create a subclass of an existing class |
| 18.9 | Identify the use of an abstract class as opposed to an interface |
| 18.10. | Explain the object-oriented concepts of polymorphism, inheritance, and encapsulation |
| 19.1 | Identify runtime errors |
| 19.2 | Describe error handling strategies |
| 19.3 | Handle unexpected return values |
| 19.4 | Handle (catch) runtime errors and take appropriate action |
| 19.5 | Throw standard exception classes |
| 19.6 | Develop and throw custom exception classes |
