Please enable JavaScript to use CodeHS

Standards Mapping

for Indiana Computer Science


Standards in this Framework


Standards Mapped


Mapped to Course

Standard Lessons
Discuss software development methodology that include fundamental design concepts and principles, Structured and Iterative design, UML (Unified Modeling Language).
Demonstrate fundamental programming constructs such as understanding of language syntax, semantics and style standards including documentation and commenting, using IDEs to create, execute, test, and debug programs utilizing standard software development design and methodologies.
  1. 1.6 Top Down Design and Decomposition in Karel
  2. 1.7 Commenting Your Code
  3. 1.16 Debugging Strategies
  4. 5.2 Graphics Challenges
  5. 7.1 Control Structures Challenges
  6. 9.1 Functions Challenges
  7. 12.1 Breakout
  8. 13.1 Project Prep and Development
Analyze and explain the behavior of simple programs utilizing variables, expressions, assignments, I/O, control structures, functions, parameter passing, preconditions, postconditions, and invariants.
  1. 1.6 Top Down Design and Decomposition in Karel
  2. 1.7 Commenting Your Code
  3. 1.16 Debugging Strategies
  4. 7.1 Control Structures Challenges
  5. 8.1 Functions and Parameters 1
  6. 8.2 Functions and Parameters 2
  7. 8.3 Functions and Parameters 3
Utilize fundamental data types including Primitive types (Integers, Real Numbers, Booleans, and Characters), Pointers, Arrays, Records/Structures, Strings, Enumerations
  1. 4.2 Variables
  2. 4.4 Basic Math in JavaScript
  3. 6.1 Booleans
  4. 26.2 Indexing Into an Array
  5. 26.3 Adding/Removing From an Array
  6. 26.5 Iterating Over an Array
Use the techniques of decomposition to modularize a program.
  1. 1.4 Functions in Karel
  2. 1.6 Top Down Design and Decomposition in Karel
  3. 8.1 Functions and Parameters 1
  4. 8.2 Functions and Parameters 2
  5. 8.3 Functions and Parameters 3
  6. 8.4 Functions and Return Values 1
  7. 8.5 Functions and Return Values 2
  8. 8.6 Local Variables and Scope
Apply a variety of strategies to the testing and debugging of simple programs including: ● Conduct code reviews (focused on common coding errors and the extent to which the code meets documentation and programming style standards) on program components. ● Differentiate between program validation and verification. ● Ensure programs use defensive programming techniques, including input validation, type checking, and protection against buffer overflow. ● Implement refactoring within given program components.
  1. 1.16 Debugging Strategies
  2. 5.1 Collaborative Programming
Explain the role of algorithms in problem-solving including: ● Analyze and compare the best, average, and worst-case behaviors and performance of an algorithm for given problems with various input sizes ● Implement a basic numerical algorithm and apply to a given problem. ● Discuss the halting problem and why it has no algorithmic solution. ● Investigate factors other than computational efficiency that influence the choice of algorithms.
  1. 1.1 Introduction to Programming With Karel
  2. 1.14 More Karel Examples and Testing
  3. 4.4 Basic Math in JavaScript
Analyze machine level representation of data including: ● Bits, bytes, and words ● Numeric data representation (Binary, Hexadecimal, BCD, 1's Complement, 2's Complement, and Floating Point format) ● Non-numeric data (Characters, Images, Sounds, Video) ● Illustrate color models and their use in computer graphics. ● Conversion of numerical data from one format to another ● Effect of fixed-length number representations on accuracy and precision
  1. 4.6 Pixel Images
  2. 4.7 Using RGB to Create Colors
Describe, compare, and contrast the components of Computer Architecture which include all portions of the Von Neumann machine as well as assembly/machine language. Explore the impact of memory latency on execution time (Von Neumann Bottleneck).
Examine major objectives, functions, features, and concepts of modern operating systems. ● Discuss the role, purpose of operating systems ● Compare prevailing types of operating systems. ● Discuss potential threats to operating systems and appropriate features used to provide protection and security. ● Diagram the interaction of an Application Programming Interface (API) with an operating system. ● Illustrate how applications use computing resources managed by the operating system and explain the need for concurrency and common methods to implement concurrency. ● Illustrate the principles of memory management including virtual memory, paging, thrashing, and partitioning. ● Diagram the physical hardware devices and the virtual devices maintained by an operating system.
Investigate principles of secure design. ● Analyze the tradeoffs associated with designing security into a product. ● Implement input validation in applications ● Discuss the security implications of relying on open design vs the secrecy of design. ● Explain the tradeoffs of developing a program in a type-safe language. ● Investigate potential errors detected from both strong-type and weak-type languages. ● Investigate potential vulnerabilities in provided programming code. ● Investigate common coding errors that introduce security vulnerabilities, such as buffer overflows, integer errors, and memory leaks.
Assess human-computer interaction and design issues that analyze the importance of humancentered software and then implement a simple usability test for an existing software application.