Please enable JavaScript to use CodeHS

Standards Mapping

for Washington 2

23

Standards in this Framework

4

Standards Mapped

17%

Mapped to Course

Standard Lessons
2-AP-10
Use flowcharts and/or pseudocode to address complex problems as algorithms.
2-AP-11
Create clearly named variables that represent different data types and perform operations on their values.
  1. 27.1 Classes and Objects
  2. 27.1 Classes and Objects
  3. 27.2 Methods
  4. 27.2 Methods
  5. 27.3 Built-In Methods
  6. 27.3 Built-In Methods
  7. 27.4 Operator Overloading
  8. 27.4 Operator Overloading
  9. 27.5 Class Variables vs. Instance Variables
  10. 27.5 Class Variables vs. Instance Variables
  11. 27.6 Inheritance
  12. 27.6 Inheritance
  13. 27.7 Hidden Attributes
  14. 27.7 Hidden Attributes
  15. 27.8 Namespaces
  16. 27.8 Namespaces
  17. 27.9 Modules
  18. 27.9 Modules
  19. 28.1 Short Circuit Evaluation
  20. 28.1 Short Circuit Evaluation
  21. 28.2 De Morgan's Laws
  22. 28.2 De Morgan's Laws
  23. 29.1 Project: Who Said It?
  24. 29.1 Project: Who Said It?
  25. 33.1 Indexing
  26. 33.1 Indexing
  27. 33.2 Slicing
  28. 33.2 Slicing
  29. 33.3 Immutability
  30. 33.3 Immutability
  31. 33.4 Strings and For Loops
  32. 33.4 Strings and For Loops
  33. 33.5 The in Keyword
  34. 33.5 The in Keyword
  35. 33.6 String Methods
  36. 33.6 String Methods
  37. 34.1 2d Lists
  38. 34.1 2d Lists
  39. 34.2 List Comprehensions
  40. 34.2 List Comprehensions
  41. 34.3 Packing and Unpacking
  42. 34.3 Packing and Unpacking
  43. 34.4 Dictionaries
  44. 34.4 Dictionaries
  45. 34.5 Equivalence vs. Identity
  46. 34.5 Equivalence vs. Identity
2-AP-12
Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.
  1. 27.6 Inheritance
  2. 27.6 Inheritance
  3. 29.1 Project: Who Said It?
  4. 29.1 Project: Who Said It?
  5. 34.1 2d Lists
  6. 34.1 2d Lists
  7. 34.5 Equivalence vs. Identity
  8. 34.5 Equivalence vs. Identity
2-AP-13
Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs.
  1. 27.2 Methods
  2. 27.2 Methods
  3. 27.3 Built-In Methods
  4. 27.3 Built-In Methods
  5. 27.4 Operator Overloading
  6. 27.4 Operator Overloading
  7. 27.5 Class Variables vs. Instance Variables
  8. 27.5 Class Variables vs. Instance Variables
  9. 27.6 Inheritance
  10. 27.6 Inheritance
  11. 27.9 Modules
  12. 27.9 Modules
  13. 28.1 Short Circuit Evaluation
  14. 28.1 Short Circuit Evaluation
  15. 28.2 De Morgan's Laws
  16. 28.2 De Morgan's Laws
  17. 29.1 Project: Who Said It?
  18. 29.1 Project: Who Said It?
  19. 33.1 Indexing
  20. 33.1 Indexing
  21. 33.2 Slicing
  22. 33.2 Slicing
  23. 33.3 Immutability
  24. 33.3 Immutability
  25. 33.4 Strings and For Loops
  26. 33.4 Strings and For Loops
  27. 33.6 String Methods
  28. 33.6 String Methods
  29. 34.1 2d Lists
  30. 34.1 2d Lists
  31. 34.2 List Comprehensions
  32. 34.2 List Comprehensions
  33. 34.3 Packing and Unpacking
  34. 34.3 Packing and Unpacking
  35. 34.4 Dictionaries
  36. 34.4 Dictionaries
  37. 34.5 Equivalence vs. Identity
  38. 34.5 Equivalence vs. Identity
2-AP-14
Create procedures with parameters to organize code and make it easier to reuse.
2-AP-15
Seek and incorporate feedback from team members and users to refine a solution that meets user needs.
2-AP-16
Incorporate existing code, media, and libraries into original programs, and give attribution.
2-AP-17
Systematically test and refine programs using a range of test cases.
2-AP-18
Distribute tasks and maintain a project timeline when collaboratively developing computational artifacts.
  1. 27.1 Classes and Objects
  2. 27.1 Classes and Objects
  3. 27.2 Methods
  4. 27.2 Methods
  5. 27.3 Built-In Methods
  6. 27.3 Built-In Methods
  7. 27.4 Operator Overloading
  8. 27.4 Operator Overloading
  9. 27.5 Class Variables vs. Instance Variables
  10. 27.5 Class Variables vs. Instance Variables
  11. 27.6 Inheritance
  12. 27.6 Inheritance
  13. 27.7 Hidden Attributes
  14. 27.7 Hidden Attributes
  15. 27.8 Namespaces
  16. 27.8 Namespaces
  17. 27.9 Modules
  18. 27.9 Modules
  19. 29.1 Project: Who Said It?
  20. 29.1 Project: Who Said It?
  21. 33.1 Indexing
  22. 33.1 Indexing
  23. 33.2 Slicing
  24. 33.2 Slicing
  25. 33.3 Immutability
  26. 33.3 Immutability
  27. 33.4 Strings and For Loops
  28. 33.4 Strings and For Loops
  29. 33.5 The in Keyword
  30. 33.5 The in Keyword
  31. 33.6 String Methods
  32. 33.6 String Methods
  33. 34.1 2d Lists
  34. 34.1 2d Lists
  35. 34.2 List Comprehensions
  36. 34.2 List Comprehensions
  37. 34.3 Packing and Unpacking
  38. 34.3 Packing and Unpacking
  39. 34.4 Dictionaries
  40. 34.4 Dictionaries
  41. 34.5 Equivalence vs. Identity
  42. 34.5 Equivalence vs. Identity
2-AP-19
Document programs in order to make them easier to follow, test, and debug.
2-CS-01
Recommend improvements to the design of computing devices, based on an analysis of how users interact with the devices.
2-CS-02
Design projects that combine hardware and software components to collect and exchange data.
2-CS-03
Systematically identify and fix problems with computing devices and their components.
2-DA-07
Represent data using multiple encoding schemes.
2-DA-08
Collect data using computational tools and transform the data to make it more useful and reliable.
2-DA-09
Refine computational models based on the data they have generated.
2-IC-20
Compare tradeoffs associated with computing technologies that affect people's everyday activities and career options.
2-IC-21
Discuss issues of bias and accessibility in the design of existing technologies.
2-IC-22
Collaborate with many contributors through strategies such as crowdsourcing or surveys when creating a computational artifact.
2-IC-23
Describe tradeoffs between allowing information to be public and keeping information private and secure.
2-NI-04
Model the role of protocols in transmitting data across networks and the Internet.
2-NI-05
Explain how physical and digital security measures protect electronic information.
2-NI-06
Apply multiple methods of encryption to model the secure transmission of information.