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