Standards in this Framework
Standards Mapped
Mapped to Course
| Standard | Lessons |
|---|---|
|
1.1
Identify common computer threats (e.g., viruses, phishing, suspicious email, social engineering, spoofing, identity theft, spamming, and AI) |
|
|
1.2
Describe potential vulnerabilities and risk management for information security [i.e., SIEM (security information and event management) software, OWASP’s Top 10, CVEs (common vulnerabilities and exposure), etc.) |
|
|
1.3
Identify procedures to maintain data integrity and security (e.g., lock the screen; report and delete unrecognized, suspicious emails; use trustworthy USB flash drives; and use approved software) |
|
|
1.4
Explain best practices to maintain integrity and security in software development (e.g., encryption, hashing, code signing, sandboxes, virtual machine (VM) containers, code versioning systems, and digital signatures) |
|
|
1.5
Describe methods for sanitizing user input to prevent issues (e.g., buffer overflows and SQL injection) |
|
|
1.6
Analyze the CIA (confidentiality, integrity, and availability) triad |
|
|
1.7
Explain how software defects relate to software security (e.g., buffer overflows and cross-site scripting) |
|
|
2.1
Identify hazards and unsafe practices that can lead to serious accidents or injuries (i.e., electrostatic discharge hazards, poor ergonomic practices, etc.) |
|
|
2.2
Describe OSHA and other state and national regulations designed to reduce safety risks and workplace injuries |
|
|
2.3
Explain environmental considerations when disposing of computer/network components (i.e., disposing of batteries, devices with lithium batteries, etc.) |
|
|
2.4
Manage power consumption in the networked environment (i.e., wattage usage, green methods such as climate batteries and energy efficiency methods, cloud-based software, etc.) |
|
|
3.1
Differentiate among numeric, Boolean, character, string variables, and float and double |
|
|
3.2
Select the appropriate data type for a given situation |
|
|
3.4
Identify the correct syntax and usage for constants and variables (e.g., variable scope) in a program |
|
|
3.5
Determine the correct syntax and safe functions for operations on strings, arrays, and data structures, including length, substring, and concatenation |
|
|
3.6
Explain complications of storing and manipulating data (i.e., the Big-O notation used to analyze storage and efficiency concerns, etc.) |
|
|
3.7
Discuss data structure size concerns and memory management, including stack and heap |
|
|
3.8
Implement file storage operations, including reading, writing, and creating files |
|
|
4.1
Apply basic mathematics to hardware and software design, logic, and variable scope (e.g., bits, bytes, kilobytes, megabytes, gigabytes, terabytes, and petabytes) including kilohertz, megahertz, and gigahertz |
|
|
4.2
Calculate binary conversions (e.g., decimal, hexadecimal, and binary) to solve hardware and software problems |
|
|
4.3
Identify and correctly use arithmetic operations applying the order of operations (precedence) for programming |
|
|
4.4
Interpret and construct mathematical formulas used in code [i.e., y=n*x+b2-n*(a+b)] |
|
|
4.5
Identify correct and problematic uses of integers, floating-point numbers, and fixed-point numbers in arithmetic |
|
|
4.6
Emphasize the importance of precision and accuracy in numerical computations to mitigate errors in software development |
|
|
4.7
Investigate bit-shift left/right and bit-wise operations |
|
|
5.1
Compare values using relational operators (e.g., =, >, <, >=, <=, and not equal) |
|
|
5.2
Evaluate Boolean expressions (e.g., AND, OR, NOT, NOR, and XOR) |
|
|
5.3
Demonstrate and diagram conditional structures |
|
|
5.4
Determine the correct syntax and nesting for decision structures (e.g., if/else, if, and switch case) |
|
|
5.5
Create and utilize functions and methods |
|
|
6.1
Demonstrate basic uses of arrays including initialization, storage, retrieval of values, and how to use them as arguments |
|
|
6.2
Distinguish between arrays and hash maps (associative arrays) |
|
|
6.3
Identify techniques for declaring, initializing, and modifying user-defined data types |
|
|
6.4
Search and sort data in an array |
|
|
6.5
Diagram, create, and use two-dimensional arrays |
|
|
6.6
Describe the efficiency of different sorting algorithms (e.g., bubble, insertion, and merge) |
|
|
6.7
Describe the efficiency of linear vs. binary searches [e.g., O(n) and O(log n)] |
|
|
6.8
Investigate more advanced data structures like trees and graphs |
|
|
7.1
Identify various types of iteration structure (e.g., while, for, for-each, and recursion) |
|
|
7.2
Explain how loops are controlled (variable conditions and exits) |
|
|
7.3
Employ the correct syntax for nested loops |
|
|
7.4
Compute the values of variables involved with nested loops (i.e., variable changes throughout a loop) |
|
|
7.5
Diagram iterative structures and use in writing programs |
|
|
8.1
Explain the benefits of cloud-based computing |
|
|
8.2
Classify the components and functions of the common internet protocols (e.g., HTTP, HTTPS, SSH, SFTP, FTPS, IP addresses, IPV6, and IMAP) |
|
|
8.3
Determine services run by web servers [e.g., scripting languages (client- and server-side scripting), serverless architectures, cloud computing, databases, and media] |
|
|
8.4
Identify performance issues (e.g., bandwidth, internet connection types, pages loading slowly, resolution, and size graphics) |
|
|
8.5
Compare different cloud service models [Software as a Service (SaaS), Platform as a Service (PaaS), Infrastructure as a Service (IaaS), and Function as a Service (FaaS)] |
|
|
9.1
Examine key components and functions of the internet and web browsers |
|
|
9.2
Identify client collaboration sources/platforms (e.g., GitHub, Google Drive, Dropbox, JSFiddle, Visual Studio Live Share, and browser developer tools) |
|
|
9.3
Analyze remote computing tools and services and their application [e.g., SSH (secure shell)] |
|
|
9.4
Explore Modern Web and Application Frameworks (i.e., Node.js, Next.js, React, Django, GoLang, Flutter, etc.) |
|
|
9.5
Discuss Containerization and Microservices in the context of Internet-based software architectures |
|
|
10.1
Develop a maintenance plan to prioritize and schedule network security tasks (i.e., Cron Jobs) |
|
|
10.2
Describe the purpose and benefits of network utilities [i.e., Network Statistics (Netstat), Name Server Lookup(NsLookup), Ping, Traceroute, etc.] |
|
|
10.3
Demonstrate the use of visual indicators and diagnostic utilities (i.e., Wireshark, etc.) to interpret problems |
|
|
10.4
Evaluate connectivity issues in various node environments (i.e., smartphones, switches, tablets, Linux/UNIX, Windows, etc.) |
|
|
10.5
Identify and resolve network issues (i.e., cable failure, connection failure, environmental, misconfigurations, power, user error, etc.) |
|
|
10.6
Research common tools and methods for monitoring a network |
|
|
10.7
Describe AI and machine learning-based tools for network maintenance and issue resolution (i.e., LLM) |
|
|
11.1
Discuss common editors and add-ins |
|
|
11.2
Use a program editor to enter and modify code |
|
|
11.3
Identify correct input/output statements |
|
|
11.4
Choose the correct method of assigning input to variables including data sanitization (i.e., input text to numbers) |
|
|
11.5
Determine the correct method of outputting data with formatting and escaping (e.g., ANSI escape code) |
|
|
11.6
Differentiate between interpreted and compiled code and run executable code |
|
|
11.7
Identify the purpose of a build system (e.g., make, rake, ant, maven, SCons, and grunt) |
|
|
11.8
Apply industry standards to program documentation (e.g., self-documenting code; function-level, program-level, and user-level documentation) |
|
|
11.9
Name identifiers and formatting code by applying recognized conventions (e.g., camel casing) |
|
|
11.10
Perform refactoring techniques to reduce repetitious code and improve maintainability |
|
|
11.11
Use parameters to pass data into program modules and return values from modules |
|
|
11.12
Discuss the use of random number generators, including concepts of true randomness and seeding |
|
|
12.1
Explain errors in program modules |
|
|
12.2
Identify boundary cases and generate appropriate test data |
|
|
12.3
Perform integration testing, including tests within a program, to protect execution from bad input or other run-time errors (e.g., CI (continuous integration) and automated testing) |
|
|
12.4
Categorize, identify, and correct errors in code, including syntax, semantic, logic, and runtime |
|
|
12.5
Practice different methods of debugging (e.g., hand-trace code and real-time debugging tools) |
|
|
13.1
Integrate standard library functions |
|
|
13.2
Design code that incorporates third-party libraries (e.g., web-based and package managers) |
|
|
13.3
Explain and interact with an Application Program Interface (API) |
|
|
13.4
Investigate using community information to solve problems (e.g., stack overflow, forum post, etc.) |
|
|
13.5
Create a README markdown file (.md) to document and explain basic install and usage steps |
|
|
14.1
Compare version control system (e.g., Git and Mercurial) |
|
|
14.2
Identify the purpose and types of version control systems (e.g., local, centralized, and distributed) |
|
|
14.3
Create new repositories and perform basic operations (e.g., adding, pushing, and pulling source code from repositories) |
|
|
14.4
Explain version control branching and its uses |
|
|
14.5
Restore previous versions of code from the repository |
|
|
14.6
Research the principles of DevOps, DevSecOps, and Continuous Integration/Continuous Deployment (CI/CD) as part of version control and software development lifecycle |
|
|
14.7
Integrate version control workflows (i.e., continuous deployment) using collaborative development practices |
|
|
14.8
Demonstrate document version control (i.e., commit messages, recovery from common errors, release notes, etc.) |
|
|
15.1
Investigate user-centered design (UCD), prototyping, and wireframing used during the design process |
|
|
15.2
Apply W3C standards and style conventions (e.g., HTML, CSS, and JavaScript) |
|
|
15.3
Construct web pages and applications that are compliant with ADA (Americans with Disabilities Act) and sections 504 and 508 standards (e.g., emphasize accessibility and inclusive design in user interface development) |
|
|
15.4
Explain the concept of responsive design and applications (i.e., loading times) |
|
|
15.5
Employ graphics methods to create images at specified locations |
|
|
15.6
Choose correct GUI (graphical user interface) objects for input and output of data to the GUI interface (e.g., text boxes, labels, radio buttons, check boxes, dropdowns, and list boxes) |
|
|
15.7
Apply UI/UX design for multiple platforms including computers, mobile devices, and browsers |
|
|
15.8
Incorporate SEO (search engine optimization) and web optimization techniques |
|
|
15.9
Integrate user testing and feedback loops to refine interface designs and improve user experience |
|
|
15.10
Analyze feature limitations and compatibility issues between different browsers and their versions |
|
|
15.11
Discuss framework and component libraries for CSS (cascading style sheets)and JavaScript |
|
|
16.1
Identify different data storage types (e.g., RAID, Cloud, SSD, HDD, Flash, tape, etc.) and explain how they relate to designing and developing software applications |
|
|
16.2
Discuss data backup and recovery, data integrity, and data privacy (e.g., blockchain, edge computing, and quantum storage |
|
|
16.3
Read/write data from/to a sequential file or database [i.e., handling sequential files, database operations, CRUD (create, read, update, delete) operations] |
|
|
16.4
Differentiate among cloud storage, software storage, defined storage, file storage, block storage, object storage, memory, and cache storage in software applications |
|
|
16.5
Demonstrate creating, reading, updating, and dropping a database |
|
|
16.6
Employ the proper use of database applications that work with different languages (e.g., MongoDB MQL, Microsoft Access SQL, and Oracle Databases SQL) |
|
|
16.7
Use, update, and manage data storage (i.e., local, cloud, NAS, RAID, SANs, etc.) |
|
|
16.8
Review relational and NoSQL databases, covering normalization and schema design |
|
|
16.9
Discuss data migration and synchronization to simulate real-world data management scenarios (i.e., banking transactions) |
|
|
17.1
Identify the differences between primitive and non-primitive data structures |
|
|
17.2
Differentiate between an object instance and a class |
|
|
17.3
Discuss the roles of inheritance, composition, and class relationships |
|
|
17.4
Instantiate objects from existing classes |
|
|
17.5
Interpret the state of an object by invoking accessor methods (i.e., getter) |
|
|
17.6
Change the state of an object by invoking a modifier method (i.e., setter) |
|
|
17.7
Determine the requirements for constructing new objects by reading the documentation |
|
|
17.8
Create a user-defined class and a subclass of an existing class |
|
|
17.9
Identify the use of an abstract class as opposed to an interface |
|
|
17.10
Explore advanced programming concepts (i.e., splitting files into different source files, principles of Inheritance, encapsulation, and polymorphism) |
|
|
17.11
Investigate data representations in project creation (e.g., JSON and XML) |
|
|
17.12
Explain the implementation and use of arguments, pointers, and references in programming |
|
|
17.13
Demonstrate the principles of SOLID design and design patterns in object-oriented programming (OOPs) |
|
|
18.1
Investigate debugging techniques, error propagation and handling, and graceful degradation |
|
|
18.2
Research causes for compilation and logical errors |
|
|
18.3
Identify and resolve runtime errors |
|
|
18.4
Describe error handling strategies based on severity |
|
|
18.5
Identify and resolve unexpected return values |
|
|
18.6
Investigate standard exception classes and their uses |
|
|
18.7
Develop custom exception classes (i.e., throw) |
|
|
19.1
Discuss software development methods (i.e., waterfall, agile, etc.) and ownership rights |
|
|
19.2
Explore the basics of app markets, including popular platforms (i.e., Google Play Store and Apple App Store) and identify components of a successful app |
|
|
19.3
Identify components of a successful app |
|
|
19.4
Discuss the cost in developing and launching an app |
|
|
19.5
Research monetization strategies for apps (i.e., ads, in-app purchases, and premium features) |
|
|
19.6
Investigate basic project management concepts in the software development process |
|
|
19.7
Evaluate the importance of customer feedback in the software development cycle |
|
|
19.8
Research trends in the technology sector (i.e., blockchain, quantum computing, edge computing mobile apps, cloud computing, AI, etc.) |
|
