Study guide

4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

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

4.4 Algorithm Formats: Natural Language, Flowcharts, Pseudocode, and Tracing

Key Takeaways Explain This Topic AI

An algorithm is a finite, ordered sequence of unambiguous steps that solves a problem; the same algorithm can be written in natural language, as a flowchart, or in pseudocode.

In standard flowchart notation, ovals mark start and end, parallelograms mark input and output, rectangles mark processing steps, and diamonds mark decisions; on the test, use the symbol legend ETS provides.

A trace table has one column for each variable, plus columns for conditions and output, and one row for each step that changes something.

Sequencing errors include initializing a variable inside a loop, using a value before computing it, and updating a counter in the wrong place.

A pre-test loop (while) can run zero times; a post-test loop (do … while, repeat … until) always runs at least once.

Last updated: September 2026

What this competency asks

ETS asks you to understand how to develop and analyze algorithms expressed in multiple formats (natural language, flowcharts, and pseudocode):

Interpret diagrams that describe algorithms, given an explanation of the symbols used .

Compare algorithms written in multiple formats.

Trace and analyze algorithms written in different formats.

Identify the correct sequencing of steps in an algorithm, and errors in sequencing.

Three ways to express one algorithm

An algorithm is a finite sequence of unambiguous steps that solves a problem. Here is one algorithm, finding the largest value in a list, in three formats.

Natural language

Take the first value as the largest so far.

Look at each remaining value in turn.

If a value is greater than the largest so far, it becomes the new largest.

When no values remain, report the largest so far.

  • Pseudocode (ETS notation) int findMax ( int[ ] nums, int n )
  • int largest ← nums[0]
  • for ( int i ← 1; i < n; i ← i + 1 )
  • if ( nums[i] > largest )
  • largest ← nums[i]
  • end if
  • end for
  • return largest
  • end findMax

Flowchart: see the diagram in this section.

Format Strength Weakness

Natural language Easy for anyone to read Ambiguous ("look at each value": in what order? what if the list is empty?)

  • Flowchart Shows branching and looping visually Bulky for long algorithms; hard to edit
  • Pseudocode Precise and compact; close to real code Requires knowing the notation

When a question asks you to compare formats, check that each version has the same initialization , the same condition (for example, > versus ≥ ), the same loop range , and the same result . A natural-language version that says "start with 0 as the largest" is not equivalent to one that starts with the first element, because it fails when every value is negative.

Reading flowcharts

ETS's content description says you will interpret diagrams given an explanation of the symbols used , so read the legend on the test. The conventional symbols (from the ISO 5807 flowchart standard) are:

  • Symbol Name Meaning
  • Oval (rounded) Terminator Start or end
  • Parallelogram Input/output Read input or display output
  • Rectangle Process Assignment or calculation
  • Diamond Decision A yes/no or true/false test with two labeled exits
  • Arrow Flow line Order of execution

A loop in a flowchart is an arrow that returns to an earlier decision. When you trace one, keep going around the loop until the decision sends you out.

Tracing: the most important skill

Tracing (also called desk checking) means executing an algorithm by hand. Build a trace table :

One column per variable, plus columns for any condition and for output.

Write the initial values.

Go line by line. When a variable changes, add a row with its new value.

Record true or false for each condition so you follow the correct branch.

Stop when the loop condition fails, and note the final values.

  • Worked trace int total ← 0
  • int k ← 1
  • while ( k ≤ 4 )
  • if ( k % 2 == 0 )
  • total ← total + k * 3
  • else
  • total ← total + k
  • end if
  • k ← k + 1
  • end while
  • print "Result: " + total
  • k (at test) k ≤ 4 k % 2 == 0 total after body k after body
  • 1 true false 0 + 1 = 1 2
  • 2 true true 1 + 6 = 7 3
  • 3 true false 7 + 3 = 10 4
  • 4 true true 10 + 12 = 22 5
  • 5 false — exit —

Output: Result: 22 . Notice that the loop test runs five times but the body runs four times. Questions about "how many times is the condition evaluated" versus "how many times does the body execute" test exactly this difference.

Sequencing: order matters

Many questions show an algorithm with steps missing or out of order. Common sequencing errors:

Error Example Symptom

Initialization inside the loop sum ← 0 placed inside the for loop The sum is reset every pass; only the last value survives

Using a value before it is computed Printing average before average ← sum / n Prints a stale or default value

Updating the counter in the wrong place i ← i + 1 placed before list[i] is used Skips the first element and may run past the end

  • Missing update No k ← k + 1 in a while loop Infinite loop
  • Return too early return inside the loop body Only the first element is checked
  • Example of the first error: int sum ← 0
  • for ( int i ← 0; i < n; i ← i + 1 )
  • sum ← 0
  • sum ← sum + list[i]
  • end for

Deleting the sum ← 0 inside the loop fixes the algorithm, because the initialization above the loop already runs once. To find a sequencing error, trace a small input, such as a list of two or three values, and compare with the intended result.

Loops that test at the top vs. the bottom

A pre-test loop ( while ) checks its condition before each pass, so it may run zero times. A post-test loop ( do … while , repeat … until ) checks after each pass, so it runs at least once . This matters with sentinel values , special values such as −1 that mark the end of input: // Version A: pre-test

  • int record ← readNext ( )
  • while ( record ≠ -1 )
  • process ( record )
  • record ← readNext ( )
  • end while
  • // Version B: post-test
  • int record ← 0
  • repeat
  • record ← readNext ( )
  • process ( record )
  • until ( record == -1 )

Version A reads first and tests before processing, so the sentinel is never processed, and an input that starts with −1 processes nothing. Version B processes whatever it just read before testing, so it always calls process ( -1 ) once at the end, including when the input is empty.

Other defects that tracing reveals

Off-by-one errors: i ≤ n instead of i < n in a 0-based array of length n reaches the invalid index n.

Infinite loops: the condition can never become false. For example, while ( count ≠ 10 ) with count starting at 1 and increasing by 2 skips 10 forever.

Unreachable code: statements after an unconditional return , or inside an if whose condition can never be true, such as ( x > 10 ) and ( x < 5 ) .

Loading diagram... Flowchart of the findMax algorithm