Please enable JavaScript to use CodeHS

Standards Mapping

for Arkansas Software Development

65

Standards in this Framework

29

Standards Mapped

44%

Mapped to Course

Standard Lessons
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. 4.5 Showcase Your Project
  2. 7.6 Showcase and Reflection
  3. 9.6 Showcase and Reflection
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. 2.4 Inheritance
  2. 4.5 Showcase Your Project
  3. 7.6 Showcase and Reflection
  4. 8.11 Decision Trees
  5. 9.6 Showcase and Reflection
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).
  1. 5.1 Lists, Tuples, Dictionaries
  2. 5.2 Sets
  3. 5.3 Last-In, First-Out
  4. 5.4 First-In, First-Out
  5. 5.5 Linked Lists
  6. 5.6 Hash Tables
  7. 5.7 Basic Trees
  8. 5.8 Heaps
  9. 5.9 Graphs
  10. 7.1 Plan Your Music Library
  11. 7.2 Store and Find Your Songs
  12. 7.3 Playlists and Player Features
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.
  1. 6.3 Big O Notation
  2. 6.9 Recursion
  3. 6.10 Merge Sort
  4. 6.11 Quick Sort
  5. 7.6 Showcase and Reflection
2.1.3
Evaluate and implement basic searching (e.g., linear, binary) and sorting (e.g., bubble sort) algorithms.
  1. 6.1 Algorithms in Computing
  2. 6.3 Big O Notation
  3. 6.4 Linear Search
  4. 6.5 Binary Search
  5. 6.6 Bubble Sort
  6. 6.7 Selection Sort
  7. 6.8 Insertion Sort
  8. 6.10 Merge Sort
  9. 6.11 Quick Sort
  10. 7.4 Searching and Sorting the Library
  11. 10.1 Advanced Python and AI Programming Final Exam
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.
  1. 2.2 Classes
  2. 2.3 Getters and Setters
  3. 2.6 Constructors
2.2.2
Develop programs using inheritance to extend class functionality (e.g., 'ElectricCar' inheriting from 'Car').
  1. 2.4 Inheritance
  2. 4.2 Building Your Characters
  3. 4.5 Showcase Your Project
2.2.3
Apply composition to build complex objects (e.g., a 'Car' class containing 'Engine' and 'Transmission' objects).
  1. 2.8 Composition
  2. 4.3 Items, Choices, and the Loop
  3. 4.5 Showcase Your Project
  4. 10.1 Advanced Python and AI Programming Final Exam
2.2.4
Implement polymorphism in class design (e.g., method overriding, interface implementation).
  1. 2.5 Polymorphism
  2. 2.7 Magic Methods
  3. 4.3 Items, Choices, and the Loop
  4. 4.5 Showcase Your Project
  5. 7.4 Searching and Sorting the Library
  6. 10.1 Advanced Python and AI Programming Final Exam
2.3.1
Implement appropriate documentation strategies for code bases (e.g., inline comments, function descriptions, README files).
  1. 1.2 Comments and Docstrings
  2. 1.4 Error Handling with Exceptions
  3. 2.2 Classes
  4. 6.1 Algorithms in Computing
2.3.2
Develop reusable code components for use across multiple projects (e.g., functions for common tasks, custom libraries).
  1. 1.1 The Main Function
  2. 2.4 Inheritance
  3. 3.1 Standard and Third-Party Libraries
  4. 4.2 Building Your Characters
  5. 4.3 Items, Choices, and the Loop
  6. 5.4 First-In, First-Out
  7. 9.2 Build Your Dataset
2.3.3
Design error handling techniques to write robust code (e.g., try-catch blocks, logging).
  1. 1.4 Error Handling with Exceptions
  2. 3.3 Exploring Web Data with Python
  3. 7.5 Put It All Together
2.3.4
Apply clean code practices to improve readability and maintainability (e.g., meaningful variable names, consistent indentation).
  1. 1.1 The Main Function
  2. 1.2 Comments and Docstrings
  3. 2.7 Magic Methods
  4. 6.6 Bubble Sort
  5. 11.3 Variables and Types
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).
  1. 1.1 The Main Function
  2. 2.4 Inheritance
  3. 4.1 Project Launch and Design
  4. 4.2 Building Your Characters
  5. 4.3 Items, Choices, and the Loop
  6. 4.4 Import Packages
  7. 6.1 Algorithms in Computing
  8. 7.1 Plan Your Music Library
  9. 9.1 Plan Your Classifier
  10. 9.2 Build Your Dataset
  11. 9.3 Train Your First Model
  12. 9.4 Test With Unseen Data
  13. 9.5 Compare and Tune
2.4.2
Construct visual representations and structured expressions to plan programs (e.g., flowcharts, pseudocode, UML diagrams).
  1. 4.1 Project Launch and Design
  2. 4.5 Showcase Your Project
  3. 6.1 Algorithms in Computing
  4. 11.9 Flowcharts and Pseudocode
2.4.3
Implement systematic debugging and troubleshooting techniques (e.g., using debugger tools, print statements).
  1. 1.4 Error Handling with Exceptions
  2. 2.3 Getters and Setters
  3. 3.7 Testing Your Code
  4. 6.2 Informal Runtime Analysis
  5. 6.6 Bubble Sort
  6. 6.10 Merge Sort
  7. 8.2 Breadth-First Search
  8. 8.5 Heuristic Algorithms
  9. 8.9 K Nearest Neighbors
  10. 8.10 Overfitting and Evaluation
  11. 8.12 Neural Networks and Perceptrons
  12. 11.7 Looping: While Loops
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.
  1. 1.1 The Main Function
  2. 2.1 What is Object-Oriented Programming?
  3. 2.4 Inheritance
  4. 4.5 Showcase Your Project
  5. 7.5 Put It All Together
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).
  1. 1.1 The Main Function
  2. 2.4 Inheritance
  3. 4.2 Building Your Characters
  4. 4.3 Items, Choices, and the Loop
  5. 7.5 Put It All Together
  6. 9.2 Build Your Dataset
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).
  1. 4.1 Project Launch and Design
  2. 4.4 Import Packages
  3. 7.1 Plan Your Music Library
  4. 9.1 Plan Your Classifier
  5. 11.11 String Methods
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).
  1. 3.7 Testing Your Code
  2. 10.1 Advanced Python and AI Programming Final Exam
3.3.1
Conduct peer code reviews to improve code quality and share knowledge.
  1. 4.5 Showcase Your Project
  2. 7.6 Showcase and Reflection
  3. 9.6 Showcase and Reflection
3.3.2
Create and maintain technical documentation for software projects (e.g., README files, project wikis).
  1. 1.2 Comments and Docstrings
  2. 2.2 Classes
  3. 4.4 Import Packages
  4. 9.6 Showcase and Reflection
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).
  1. 3.1 Standard and Third-Party Libraries
  2. 3.3 Exploring Web Data with Python
  3. 3.5 Cleaning and Structuring
  4. 8.10 Overfitting and Evaluation
  5. 9.2 Build Your Dataset
4.1.2
Create programs that validate and clean data during file input and output operations (e.g., checking file formats, filtering invalid data).
  1. 1.4 Error Handling with Exceptions
  2. 3.3 Exploring Web Data with Python
  3. 3.5 Cleaning and Structuring
  4. 9.2 Build Your Dataset
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.
  1. 3.3 Exploring Web Data with Python
  2. 3.8 Libraries and Packages Quiz
4.3.2
Integrate basic API usage within a program (e.g., weather data APIs, operating system APIs, game APIs, database APIs).
  1. 3.1 Standard and Third-Party Libraries
  2. 3.3 Exploring Web Data with Python
5.1.1
Incorporate fundamental secure coding practices (e.g., input validation, secure authentication, proper error handling).
  1. 1.4 Error Handling with Exceptions
  2. 3.3 Exploring Web Data with Python
  3. 3.7 Testing Your Code
  4. 5.6 Hash Tables
  5. 7.5 Put It All Together
5.1.2
Explain how data protection principles are used in software development (e.g., secure storage, encryption, access control).
  1. 2.3 Getters and Setters
  2. 3.3 Exploring Web Data with Python
  3. 5.6 Hash Tables
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).
  1. 8.11 Decision Trees
  2. 8.13 Clustering
  3. 9.2 Build Your Dataset
  4. 9.6 Showcase and Reflection
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).