Study guide
8.3 Reading, Completing, and Modifying Code
Praxis Computer Science 5652
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Praxis 5652 Exam Overview and ETS Pseudocode
1.1 Praxis 5652 Test Facts, Scoring, and Registration 1.2 Official ETS Pseudocode Notation and Tracing Strategy
2 Chapter 2: Impacts of Computing: Innovation, Access, and Effects
2.1 Computing for Creativity, Problem Solving, Communication, and Innovation 2.2 Equal Access, the Digital Divide, and Accessibility 2.3 Beneficial and Harmful Effects of Computing Innovations
3 Chapter 3: Impacts of Computing: Intellectual Property, Ethics, Privacy, and Security
3.1 Intellectual Property: Copyright, Open Source, and Creative Commons 3.2 Ethical and Unethical Computing Practices and Their Implications 3.3 Privacy, Security, Data Collection, and Local vs. Cloud Storage
4 Chapter 4: Algorithms and Computational Thinking: Abstraction, Decomposition, Number Bases, and Representation
4.1 Abstraction and Abstraction Hierarchies 4.2 Decomposition, Pattern Recognition, and Developing Algorithms 4.3 Number Bases: Binary, Octal, Decimal, and Hexadecimal 4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing
5 Chapter 5: Algorithms: Efficiency, Limits of Computing, and Randomization
5.1 Algorithm Efficiency: Linear, Quadratic, Exponential, and Logarithmic Growth 5.2 Limits of Computing: Unsolvable Problems, Intractability, and Heuristics 5.3 Randomization, Random vs. Pseudorandom Numbers, and Scaling to a Range
6 Chapter 6: Algorithms: Searching, Sorting, and Recursion
6.1 Searching Algorithms: Linear Search and Binary Search 6.2 Sorting Algorithms: Tracing, Comparisons, Correctness, and Efficiency 6.3 Recursion: Base Cases, Tracing, Errors, and Iterative Equivalents
7 Chapter 7: Programming: Variables, Data Types, Strings, and Expressions
7.1 Variables, Data Types, and Type Conversion 7.2 Strings and String Operations 7.3 Operators, Precedence, Expressions, and Formulas 7.4 Boolean Expressions, Truth Tables, and Boolean Algebra
8 Chapter 8: Programming: Selection, Iteration, and Writing Code
8.1 Sequence and Selection: if, else, Chained and Nested Conditions 8.2 Iteration: for, while, do … while, and repeat … until Loops 8.3 Reading, Completing, and Modifying Code
9 Chapter 9: Programming: Procedures, Arrays, and Data Structures
9.1 Procedures, Parameters, Return Values, Nested Calls, and Scope 9.2 Arrays, Lists, and Two-Dimensional Arrays 9.3 Stacks, Queues, and Dictionaries (Maps)
10 Chapter 10: Programming: Correctness, Errors, Testing, and Code Quality
10.1 Program Correctness: Preconditions, Postconditions, Invariants, and Testing vs. Proof 10.2 Error Types and Debugging Techniques 10.3 Choosing Useful Test Cases: Boundaries, Partitions, Coverage, and Regression 10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization 10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
11 Chapter 11: Programming: Events, Usability, Input Validation, and APIs
11.1 Event-Driven Programming, Asynchronous Events, and Concurrency 11.2 Usability, Meaningful Error Messages, and Input Validation vs. Verification 11.3 Libraries and APIs: Reading Definitions, Making Calls, and Weighing Trade-offs
12 Chapter 12: Programming: Languages, Tools, Paradigms, and Object-Oriented Design
12.1 Low- and High-Level Languages, Compilers and Interpreters, and IDEs 12.2 Programming Paradigms: Procedural, Object-Oriented, and Others 12.3 Classes, Objects, Instance Variables, Methods, and Encapsulation 12.4 Inheritance, Polymorphism, and Overloading vs. Overriding
13 Chapter 13: Data: Bits, Encoding, Compression, and Encryption
13.1 Bits and Bytes: Why Binary, Storage Calculations, and Signed Integers 13.2 Encoding Text, Images, and Sound 13.3 Lossless and Lossy Compression: Run-Length Encoding, Huffman Coding, and Media Formats 13.4 Encoding vs. Encryption, Symmetric and Public-Key Encryption, and Their Trade-offs
14 Chapter 14: Data: Analysis Tools, Simulation, Storage, and Collection
14.1 Analyzing Data with Spreadsheets: Cleaning, Transforming, and Visualizing 14.2 Simulation and Modeling 14.3 Files, Databases, and Storage Requirements: Scale, Redundancy, and Backup 14.4 Collecting, Aggregating, and Generating Data: Public Data Sets, Surveys, Sensors, and Crowdsourcing
15 Chapter 15: Computing Systems: Hardware, Operating Systems, and Computing Environments
15.1 Hardware Components and the Fetch–Decode–Execute Cycle 15.2 Operating Systems, Software Components, and Resource Issues 15.3 Embedded Systems, the Internet of Things, and Types of Computing Systems 15.4 Local, Network, and Cloud Computing and Storage; How Binary Data Are Stored
16 Chapter 16: Networks, the Internet, the Web, and Cybersecurity
16.1 Network Types and Wired and Wireless Communication 16.2 Network Hardware and Layered Network Models (OSI and TCP/IP) 16.3 Network Performance: Bandwidth, Latency, Load, and Estimating Needs 16.4 How the Internet Works: Protocols, IP Addressing, DNS, URLs, and Reliability 16.5 The Web: HTTP, HTML and Markup Languages, Browsers, Servers, and Clients 16.6 Cybersecurity: The Five Pillars, Strong Passwords, Security Strategies, and Trade-offs
8.3 Reading, Completing, and Modifying Code
Key Takeaways Explain This Topic AI
To describe what code does, trace it with two or three small inputs, then name the pattern, such as summing, counting, finding a maximum, or searching.
To choose missing code, decide what each variable must mean at every step, then test each choice on a small case, including a boundary case.
Statements must appear in dependency order: input before calculation, calculation before output, and initialization before a loop that uses the variable.
Small edits have predictable effects: changing < to ≤ adds one iteration, moving a statement into a loop repeats it, and changing an initial value shifts every result.
A loop that repeatedly adds n % 10 to a total and then sets n ← n / 10 computes the sum of the digits of n.
Last updated: September 2026
What this competency asks
ETS asks you to understand how to write and modify computer programs in a text-based programming language :
Describe what a program does, or choose the code segment that correctly implements an intended purpose.
Identify missing code in a code segment with a stated intended purpose.
Place statements in an appropriate order to create a correct program.
Identify how changing one part of a code segment will affect the output.
These four skills recur throughout the Programming category. ETS's sample questions include a missing condition in a find-the-maximum procedure, a missing recursive statement, and a mystery procedure whose purpose you must name.
- Skill 1: Describing what code does
- Strategy: trace with small, simple inputs, then name the pattern . int mystery ( int[ ] a, int n )
- int c ← 0
- for ( int i ← 0; i < n; i ← i + 1 )
- if ( a[i] > a[0] )
- c ← c + 1
- end if
- end for
- return c
- end mystery
Try a = {5, 8, 2, 9} : the values greater than 5 are 8 and 9, so the procedure returns 2. Try {3, 1} : none, so it returns 0. Purpose: it counts how many elements are greater than the first element.
Patterns worth recognizing on sight
- Pattern Telltale code Purpose
- Accumulator total ← total + x inside a loop Sum (or product, with * and a start of 1)
- Counter count ← count + 1 inside an if How many items meet a condition
- Extreme value if ( a[i] > max ) max ← a[i] Maximum (or minimum, with < )
- Search with a flag found ← true or return i when matched Whether, or where, a value occurs
- Filter An if controls which items are added or printed Keep only certain items
- Digit loop n % 10 then n ← n / 10 Work with each digit
- Swap temp ← a , a ← b , b ← temp Exchange two values
Beware of answer choices that describe almost the right thing. "Returns the sum of the numbers from 1 to n" and "returns the sum of the multiples of 3 from 1 to n" differ by one if . ETS's own sample mystery procedure is exactly that case.
Skill 2: Identifying missing code
Strategy: state what each variable must hold at every point (its role), then test every choice on a small case, including a boundary case .
Purpose: return the average of the positive values in a , or 0 if there are none. double avgPositive ( int[ ] a, int n )
- int sum ← 0
- int count ← 0
- for ( int i ← 0; i < n; i ← i + 1 )
- if ( a[i] > 0 )
- /* missing code */
- end if
- end for
- if ( count == 0 )
- return 0
- end if
- return sum / count // assume floating-point division here
- end avgPositive
sum must hold the total of the positive values seen so far, and count must hold how many there were. The missing code must update both: sum ← sum + a[i] and count ← count + 1 . A choice that updates only sum leaves count at 0 and always returns 0. A choice that adds i instead of a[i] sums positions rather than values.
Boundary checks that eliminate wrong choices quickly:
- An empty array, or no qualifying values
- A single element
- Values equal to a threshold (tests > versus ≥ )
- The first and last positions (tests loop bounds)
- Skill 3: Putting statements in order
Order follows dependencies : a value must exist before it is used.
Declare and initialize variables.
Get input.
Compute, with any loops (accumulators initialized before the loop).
Output the result.
- Example: compute and print the average of three input values. int a ← readInt ( )
- int b ← readInt ( )
- int c ← readInt ( )
- int sum ← a + b + c
- double avg ← sum / 3.0
- print avg
Common ordering errors are printing before computing, computing an average before the sum is complete, updating a loop variable before it is used, and resetting an accumulator inside the loop. Swapping two variables needs the order temp ← a , a ← b , b ← temp . Any other order loses a value.
Skill 4: Predicting the effect of a change
Change one thing, then re-trace only what that change affects.
- Change Typical effect
- < to ≤ in a loop condition One more iteration (possibly out of bounds)
- > to ≥ in a comparison Values equal to the threshold now count
- Initial value of an accumulator (0 to 1) Every sum shifts by 1; a product that starts at 0 stays 0
- Moving a statement inside a loop It repeats every iteration
- Moving a statement outside a loop It runs once, before or after
- Swapping two statements Can change which value is used
- Changing the loop step ( +1 to +2 ) Skips every other item
Example. In mystery above, changing a[i] > a[0] to a[i] ≥ a[0] makes the loop count a[0] itself, and any values equal to it. The result for {5, 8, 2, 9} becomes 3 instead of 2.
Reading code efficiently on the test
Read the stated purpose first, and the preconditions (such as "n is positive").
Identify the pattern before tracing everything.
Trace only as much as you need. Often one or two iterations eliminate three choices.
For "which choice works," find one input where each wrong choice fails.