Standards in this Framework
| Standard | Description |
|---|---|
| 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.) |
