Study guide

1.2 Official ETS Pseudocode Notation and Tracing Strategy

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

1.2 Official ETS Pseudocode Notation and Tracing Strategy

Key Takeaways Explain This Topic AI

ETS pseudocode uses ← for assignment and == for equality; the relational symbols are ≤, ≥, and ≠, and the logical operators are the lowercase words and, or, and not.

The ETS notation table lists + - / * ^ % as arithmetic operators and says / means floating-point division unless a question states otherwise.

ETS loops are written for ( initialization; condition; increment ) … end for, while ( condition ) … end while, do … while ( condition ), and repeat … until ( condition ).

Indentation and end statements are significant in ETS pseudocode; they, not braces, show which statements belong to an if, loop, or procedure.

A repeat … until loop runs at least once and stops when its condition becomes true, while a do … while loop runs at least once and stops when its condition becomes false.

Last updated: September 2026

Why the notation matters

About 55% of Praxis 5652 comes from Programming and Algorithms, and many of those questions show a code segment. ETS does not use Python, Java, or C++ syntax. It uses a pseudocode notation that is published on pages 21–23 of the free Study Companion (5652) . If you learned to code in Python, several symbols will look unfamiliar. If you learned Java, the typed declarations will feel familiar, but the arrows, the end keywords, and the word operators will not.

Learn the notation first. Every minute you spend decoding a symbol on test day is a minute you are not spending on the logic.

The official notation, element by element

  • Purpose ETS notation Notes for test day
  • Assignment ← total ← total + 5 evaluates the right side, then stores the result
  • Arithmetic + - / * ^ % % is the remainder (modulus); ^ also appears in ETS's list of arithmetic operators
  • Division / ETS: / is floating-point division unless stated otherwise
  • Relational == < > ≤ ≥ ≠ == tests equality; ← never does

Logical and or not Lowercase words, not && , || , or !

  • String concatenation + "Score: " + 95
  • Boolean values true false Lowercase
  • Empty reference null
  • Comment // this is a single-line comment Comments often explain what a helper call returns
  • Missing code /* missing code */ , /* missing condition */ Marks the blank you must fill
  • Output print arg A comment says whether a space or line feed follows the output

Data types boolean , char , double , float , int , int[ ] , int[ ][ ] , short , String Declarations look like int count ← 0

Arrays int[ ] a ← {1, 2, 3} , int b[0..2] ← {1, 2, 3} , int[ ][ ] c , a[0] The b[0..2] form states the index range; stems often say "the first element is at index 0"

  • Control structures if ( condition )
  • block of statements
  • else
  • another block of statements
  • end if
  • for ( initialization; condition; increment )
  • block of statements
  • end for
  • while ( condition )
  • block of statements
  • end while
  • do
  • block of statements
  • while ( condition )
  • repeat
  • block of statements
  • until ( condition )

ETS states that indentation and end statements are significant . There are no curly braces. An else belongs to the if it lines up with, and a loop body is everything indented under the header until end for or end while .

  • Procedures and classes int procedureName ( int arg1, int arg2 )
  • block of statements
  • return value
  • end procedureName
  • void procedureName ( int arg1, int arg2 )
  • block of statements
  • end procedureName
  • class className
  • variable declarations
  • procedures
  • end class className

The return type in the header is the type of the value the procedure returns, or void when it returns nothing. The object-oriented keywords listed are extends , new , public , and private . Method calls use dot notation, for example value.substring ( 0, 1 ) , and a stem that uses a class usually supplies a table explaining each method.

Division: the one symbol to watch

The ETS notation table says / means floating-point division unless stated otherwise. However, ETS's own sample explanations treat / between two int values as integer division. One sample procedure tests ( c / 2 ) ≠ 0 for an int c , and the explanation calls / the "integer division operator" and says the fix is to use % . Use this rule:

Read the declared types and any note in the stem first.

When both operands are declared int and the stem gives no other instruction, check the answer choices for integer results. That is how ETS's sample explanations behave.

When a double or float is involved, expect a fractional result such as 3.5.

% always gives the remainder: 17 % 5 is 2 , and n % 2 == 1 tests for an odd positive n .

Reading loops correctly

A for header runs its initialization once. It then checks the condition before every iteration and runs the increment after every iteration. So for ( int i ← 0; i < 6; i ← i + 1 ) runs 6 times, for i = 0 through 5. When the loop ends, the condition has just become false (i is 6).

The two post-test loops are opposites:

  • Loop Minimum runs Keeps looping while… Stops when…
  • while ( c ) … end while 0 c is true c is false (checked first)
  • do … while ( c ) 1 c is true c is false (checked after the body)
  • repeat … until ( c ) 1 c is false c becomes true (checked after the body)
  • A worked trace in ETS notation int total ← 0
  • for ( int k ← 1; k ≤ 5; k ← k + 1 )
  • if ( k % 2 == 1 )
  • total ← total + k * 2
  • else
  • total ← total + k / 2
  • end if
  • end for
  • print total

Here k is an int , and the even values of k divide exactly by 2, so no division question arises.

  • k k % 2 == 1 ? Update total
  • — — start 0
  • 1 true 0 + 1 * 2 2
  • 2 false 2 + 2 / 2 3
  • 3 true 3 + 3 * 2 9
  • 4 false 9 + 4 / 2 11
  • 5 true 11 + 5 * 2 21
  • 6 loop test 6 ≤ 5 is false exit 21

The segment prints 21 . Notice that the table records the loop variable, the branch decision, and the running value. That is the minimum you need to avoid mental-arithmetic slips.

A two-pass pacing plan

With 100 questions in 180 minutes you average 108 seconds per question. Definition and scenario questions (much of Categories I, IV, and V) usually take well under a minute. Long traces can take three minutes. A workable plan:

First pass: Answer everything you can resolve quickly. On a long trace, pick your best answer, flag the question, and move on. Never leave a question blank, because there is no deduction for a wrong answer.

Second pass: Return to flagged questions and build full trace tables on your scratch materials.

Final check: Confirm that no question is unanswered and that every select-all-that-apply item reflects your judgment of each option.

As a rough checkpoint, aim to have reached about question 35 after 60 minutes and question 70 after 120 minutes. That pace leaves time for flagged traces.

Habits that prevent lost points

Parenthesize mentally. ETS usually writes full parentheses, as in ( ( a == 6 ) or ( b == 6 ) ) . When it doesn't, apply precedence: not , then and , then or .

Check index conventions. Stems normally say "the first element of arr is at index 0." An array of length n then has valid indexes 0 through n − 1.

Read the method table. For example, a substring ( begin, end ) table may say it returns characters from begin through end − 1 . Use exactly the behavior the table gives.

Watch the print comment. "Print a space after the number" tells you how the output is formatted.

Separate ← from == . An assignment changes state; a comparison produces true or false .