Standards in this Framework
| Standard | Description |
|---|---|
| 1.1.1 | Illustrate effective communication in technical and non-technical contexts (e.g., explaining code to peers, presenting project ideas to non-technical stakeholders). |
| 1.1.2 | Evaluate integrity in software development practices (e.g., acknowledging code sources, respecting user privacy). |
| 1.1.3 | Identify and model interpersonal skills essential for effective teamwork in software development projects. |
| 1.1.4 | Analyze traits important for success in software development (e.g., problem-solving, attention to detail, continuous learning). |
| 1.2.1 | Compare various roles within the software development field (e.g., front-end developer, back-end developer, full-stack developer, mobile app developer). |
| 1.2.2 | Assess professional certifications relevant to different software development careers (e.g., AWS Certified Developer and Certified Entry-Level Python Programmer). |
| 1.2.3 | Evaluate various routes to become software developers (e.g., university degree, bootcamps, self-learning, and internships). |
| 1.3.2 | Critique examples of professional portfolios to identify key components (e.g., project descriptions, code samples, technical blog posts). |
| 1.3.3 | Evaluate different platforms and tools for creating and hosting portfolios (e.g., GitHub Pages, LinkedIn, personal websites). |
| 1.3.4 | Design a plan for curating personal projects and achievements for potential inclusion in a future portfolio. |
| 2.1.1 | Construct programs that use data structures to implement application functionality (e.g., using dictionaries for user profiles, stacks for undo functionality, queues for task scheduling). |
| 2.1.2 | Compare the implementation (e.g., readability) and performance (e.g., time and space complexity) of recursive and iterative approaches in solving programming problems. |
| 2.1.3 | Evaluate and implement basic searching (e.g., linear, binary) and sorting (e.g., bubble sort) algorithms. |
| 2.1.4 | Apply fundamental design patterns to solve common programming problems (e.g., Observer for event handling, Singleton for configuration management). |
| 2.2.1 | Create and use classes demonstrating encapsulation. |
| 2.2.2 | Develop programs using inheritance to extend class functionality (e.g., 'ElectricCar' inheriting from 'Car'). |
| 2.2.3 | Apply composition to build complex objects (e.g., a 'Car' class containing 'Engine' and 'Transmission' objects). |
| 2.2.4 | Implement polymorphism in class design (e.g., method overriding, interface implementation). |
| 2.3.1 | Implement appropriate documentation strategies for code bases (e.g., inline comments, function descriptions, README files). |
| 2.3.2 | Develop reusable code components for use across multiple projects (e.g., functions for common tasks, custom libraries). |
| 2.3.3 | Design error handling techniques to write robust code (e.g., try-catch blocks, logging). |
| 2.3.4 | Apply clean code practices to improve readability and maintainability (e.g., meaningful variable names, consistent indentation). |
| 2.4.1 | Break down complex problems into smaller, manageable sub-problems (e.g., decomposing a game into separate modules for graphics, input handling, and game logic). |
| 2.4.2 | Construct visual representations and structured expressions to plan programs (e.g., flowcharts, pseudocode, UML diagrams). |
| 2.4.3 | Implement systematic debugging and troubleshooting techniques (e.g., using debugger tools, print statements). |
| 2.5.1 | Explain how separation of concerns (e.g., separating data storage logic from user interface code) improves software design by increasing maintainability, reusability, and testability. |
| 2.5.2 | Differentiate between common software architecture patterns (e.g., MVC for web apps, microservices for large-scale systems). |
| 2.5.3 | Analyze how software architecture choices influence system scalability, maintainability, and performance. |
| 2.5.4 | Apply basic architecture principles in simple system designs (e.g., separating user interface from game logic in a tic-tac-toe game). |
| 3.1.1 | Compare different software development methodologies (e.g., Waterfall, Agile). |
| 3.1.2 | Practice requirements gathering and analysis techniques for software projects (e.g., conducting user interviews, creating user stories, developing use cases, employing prototyping, analyzing existing documentation). |
| 3.1.3 | Analyze basic deployment processes and considerations (e.g., preparing applications for different environments, managing code releases, configuring deployments). |
| 3.2.1 | Distinguish between different types of software testing (e.g., unit testing, integration testing, user acceptance testing). |
| 3.2.2 | Explain the benefits of test-driven development (TDD) and how it impacts software design, development time, and overall project success. |
| 3.2.3 | Design and execute test cases for software applications (e.g., creating a test to ensure a temperature conversion function accurately converts Celsius to Fahrenheit). |
| 3.3.1 | Conduct peer code reviews to improve code quality and share knowledge. |
| 3.3.2 | Create and maintain technical documentation for software projects (e.g., README files, project wikis). |
| 3.3.3 | Evaluate collaboration and version control tools for group projects (e.g., Git, GitHub, GitLab). |
| 3.3.4 | Use version control in a project setting (e.g., managing code changes, collaborating with team members, maintaining code history). |
| 4.1.1 | Create programs that utilize structured file formats to store and access data (e.g., CSV for data storage, JSON for configuration files). |
| 4.1.2 | Create programs that validate and clean data during file input and output operations (e.g., checking file formats, filtering invalid data). |
| 4.1.3 | Design programs to manage files within directories (e.g., creating backups, organizing files by date, renaming and moving files). |
| 4.2.1 | Compare various types of databases and their use cases (e.g., relational, NoSQL). |
| 4.2.2 | Create and manage simple databases using basic operations (e.g., CRUD operations). |
| 4.2.3 | Construct programs that interact with databases to store and retrieve data (e.g., a simple inventory management system). |
| 4.3.1 | Explain the concept of APIs and their role in software development. |
| 4.3.2 | Integrate basic API usage within a program (e.g., weather data APIs, operating system APIs, game APIs, database APIs). |
| 5.1.1 | Incorporate fundamental secure coding practices (e.g., input validation, secure authentication, proper error handling). |
| 5.1.2 | Explain how data protection principles are used in software development (e.g., secure storage, encryption, access control). |
| 5.1.3 | Evaluate network security measures used in software development (e.g., secure API design, HTTPS, safe data transmission). |
| 5.2.1 | Assess the impact of software on society and ethical decision-making (e.g., considering bias in AI algorithms). |
| 5.2.2 | Evaluate ways to implement user data protection and privacy principles in software design (e.g., data minimization, user consent for data collection). |
| 5.2.3 | Examine different ways that software can be licensed and how this affects its use. |
| 5.2.4 | Contrast open-source and closed-source software development models (e.g., community-driven development vs. in-house development). |
| 5.3.1 | Evaluate the importance of creating accessible software for users with disabilities. |
| 5.3.2 | Evaluate accessibility design principles and their impact on diverse user needs (e.g., color contrast, keyboard navigation). |
| 5.3.3 | Examine accessibility regulations and standards in software development (e.g., ADA requirements, WCAG guidelines). |
| 6.1.1 | Analyze cloud computing platforms and services in modern software development (e.g., cloud storage, hosting services, scalable computing resources). |
| 6.1.2 | Examine mobile development approaches and platforms (e.g., native apps, cross-platform development, responsive design). |
| 6.1.3 | Evaluate DevOps practices and tools in the software development lifecycle (e.g., continuous integration, automated testing, deployment automation). |
| 6.1.4 | Analyze microservices architecture and its role in scalable applications (e.g., service isolation, distributed systems, API integration). |
| 6.2.1 | Evaluate how artificial intelligence and machine learning are impacting software development practices (e.g., code generation, testing automation, predictive analytics). |
| 6.2.2 | Analyze the impact of low-code/no-code platforms on software development and deployment (e.g., rapid prototyping, citizen developers, business applications). |
| 6.2.3 | Examine blockchain technology applications in software solutions (e.g., smart contracts, decentralized applications, secure transactions). |
| 6.2.4 | Examine extended reality technologies and their software development considerations (e.g., augmented reality, virtual reality, mixed reality). |
