Skip to content
PRAXISCode: 5652Computer Science💻 Pseudocode-Based📐 CSTA & K-12 CS Framework

Praxis® Computer Science (5652)
Practice Test & Study Guide

Comprehensive preparation for secondary CS teachers — covering all 5 content categories across Impacts of Computing, Algorithms & Computational Thinking, Programming, Data, and Computing Systems & Networks. All programming questions use the exam's proprietary pseudocode — not Python, Java, or C++.

100
Questions
3 hrs
Time limit
Varies
Passing score*
5
Content categories
$130
Exam fee
Start Practice Free →View Exam Blueprint
4.9 · 12,400

Start Practicing Free

No credit card. 10 questions/day free forever.

Get Free Access →See Premium Plans
Adaptive IRT-based selection
Explanation for every question
Domain-level score breakdown
Timed full-length practice mode
💻

All programming questions use the exam's proprietary pseudocode notation — not Python, Java, or C++. The ETS Study Companion defines a complete pseudocode language with its own assignment operator (←), arithmetic/relational/logical operators, conditional and loop syntax, and procedure/class structures. Candidates must study this notation specifically before test day — familiarity with a real programming language alone is not sufficient preparation.

⚠️

The live page shows the wrong time limit (2h 30m) and wrong domain count (3). The correct time limit is 3 hours and the exam has 5 content categories (not 3), per the official ETS Study Companion. Programming is the largest category at 30% (~30 questions) — not Algorithms or Impacts as the live page implies.

📋

Source: All exam details are drawn from the official ETS Praxis Computer Science (5652) Study Companion. The exam is aligned to the K-12 CS Framework (2016), CSTA K-12 CS Standards (2017), and ISTE Computational Thinking Competencies. Passing scores vary by state — always confirm at ets.org/praxis/states.

Praxis Computer Science (5652) — Test at a Glance

Key facts directly from the official ETS test specifications. Note: the time limit is 3 hours, not 2h 30m as shown on the live page.

TEST NAME
Computer Science
Praxis Subject Assessment
TEST CODE
5652
Computer-delivered
TOTAL QUESTIONS
100
Selected-response
TIME LIMIT
3 hrs
180 minutes
CODE FORMAT
Pseudo
ETS proprietary notation
REGISTRATION FEE
$130
Paid to ETS
PASSING SCORE
Varies
By state/agency
SCORE REPORTING
~5 wks
After test date

About the Praxis Computer Science (5652) Exam

What you need to know before you register.

The Praxis Computer Science test is designed to assess the computer science knowledge and competencies necessary for a beginning teacher of secondary school computer science. Examinees have typically completed a bachelor's program with an emphasis in computer science or computer science education.

The exam requires candidates to understand and work with computer science concepts, use algorithms and computational thinking, work with code, manipulate data, and demonstrate knowledge of computing systems and networks. The test is not designed to be aligned with any particular computer science curriculum, but it is intended to be consistent with the recommendations of national studies on computer science education, including the K-12 Computer Science Framework (2016), the Computer Science Teachers Association (CSTA) K-12 Computer Science Standards (2017), and the ISTE Computational Thinking Competencies.

A critical and unique feature of this exam: all programming questions use a proprietary pseudocode notation defined by ETS — not Python, Java, C++, or any real programming language. The pseudocode uses its own assignment operator (←), relational operators (==, ≤, ≥, ≠), logical operators (and, or, not), and defined syntax for conditionals, loops, procedures, and classes. This notation is fully documented in the ETS Study Companion and must be studied independently.

The exam consists of 100 selected-response questions — some may require selecting multiple correct answers — with a 3-hour time limit. Some questions may be unscored pretest items used for future test development. Candidates are not required to know formal computer science or grammatical terminology — only the underlying concepts and the ability to apply them in the context of the pseudocode.

Exam Pseudocode Notation — Study This Before Test Day

All programming questions use ETS's proprietary pseudocode. The notation below is drawn directly from the official Study Companion. Real-language syntax (Python, Java, C++) does not apply.

ConceptNotation / ExampleNotes
Assignmentx ← 5Uses ← (arrow), not = or :=
Arithmetic operators+ - / * ^ %/ is floating point division unless stated otherwise; % is modulus (remainder)
Relational operators== < > ≤ ≥ ≠Use == (not =) for equality comparison
Logical operatorsand or notSpelled out as words, not &&, ||, !
Conditional (if)if (condition) ... end ifIndentation and end if are significant; else is optional
For loopfor (init; cond; incr) ... end forStandard C-style for loop syntax
While loopwhile (condition) ... end whileIndentation and end while are significant
Do-while loopdo ... while (condition)Also: repeat ... until (condition)
Procedure (void)void procName(arg1) ... end procNameReturn type declared in header; void if no return value
Procedure (return)int procName(arg1) ... return val ... end procNameReturn type specified (int, String, boolean, etc.)
Array declarationint[] a ← {1, 2, 3}First element is at index 0
Array referencea[0]Zero-indexed
Class definitionclass Name ... end class NameOOP keywords: extends, new, public, private
Printprint argComments indicate if line feed or blank is appended
Boolean valuestrue / falseLowercase; type declared as boolean
NullnullRepresents absence of value
Comments// single-line commentMulti-line gaps shown as /* missing code */
String concatenation+Same operator as addition — context determines use

Official Exam Blueprint: 5 Content Categories

The official ETS blueprint defines 5 content categories. Programming is the largest at 30% (~30 questions). The live page incorrectly shows 3 domains — there are 5.

Category I
Impacts of Computing
Computing as creativity, communication, and innovation; obstacles to equal access and the digital divide; beneficial and harmful effects of computing innovations; intellectual property (copyright, Creative Commons, open source); ethical and unethical computing practices; privacy and security in a digital world.
15%
~15 of 100 questions
Category II
Algorithms and Computational Thinking
Abstraction hierarchies; pattern recognition and problem decomposition; number base conversion (binary, decimal, hexadecimal); algorithm formats (natural language, flowcharts, pseudocode); algorithm analysis (linear, quadratic, exponential, logarithmic, factorial); searching and sorting algorithms; recursive algorithms; randomization and pseudorandom numbers.
25%
~25 of 100 questions
Category III ⭐ Largest Category
Programming
Control structures (sequence, selection, iteration); standard operators and precedence; variables and data types; extensibility, modifiability, and reusability; procedures with parameters and return values; event-driven programming; data structures (dictionaries/maps, stacks, queues); debugging and test cases; libraries and APIs; IDEs; object-oriented programming concepts; program compilation vs. interpretation.
30%
~30 of 100 questions
Category IV
Data
Bits as the universal medium for digital information; bit and byte calculations; encoding and decoding; lossy vs. lossless compression; data encryption and decryption; computational tools and spreadsheets for data analysis; simulation and modeling; data storage and file size measures; databases; data collection, aggregation, and crowdsourcing.
15%
~15 of 100 questions
Category V
Computing Systems and Networks
Operating systems; hardware and software components; Internet of Things (IoT); fetch-decode-execute cycle; local vs. network vs. cloud computing trade-offs; wired and wireless communication; network hardware and types; Internet and Web protocols (HTTP, IPv4/IPv6, DNS, URL structure); cybersecurity (the five pillars: confidentiality, integrity, availability, nonrepudiation, authentication); Web components.
15%
~15 of 100 questions

Content Topics by Category

All testable content topics drawn directly from the ETS Study Companion for 5652.

Category I

Impacts of Computing

15% · ~15 questions
Computing as a way of expressing creativity, solving problems, enabling communication, and fostering innovation across fields and careers
Obstacles to equal access to computing among groups defined by gender, socioeconomic status, disability/accessibility needs; the digital divide
Beneficial and harmful effects of computing innovations; social, economic, and cultural impacts; trade-offs between them
Intellectual property protection methods: copyright, Creative Commons (CC BY and variants), open source — and trade-offs between them
Ethical and unethical computing practices; identifying when a practice is ethical or legal in context
Privacy and security issues: safeguarding strategies, local vs. cloud data storage trade-offs, how digital services collect user information
Category II

Algorithms and Computational Thinking

25% · ~25 questions
Abstraction hierarchies: ordering from low to high, identifying abstractions in context, removing details to generalize
Pattern recognition and problem decomposition: identifying algorithm components, decomposition strategies, actions and actors
Number base conversion: binary, decimal, octal, and hexadecimal; analyzing and comparing representations
Developing and analyzing algorithms in multiple formats: natural language, flowcharts, and pseudocode; tracing and identifying sequencing errors
Algorithm complexity: linear, quadratic, exponential, logarithmic, factorial; recognizing unsolvable problems; heuristic solutions
Searching and sorting algorithms: tracing, predicting output, calculating comparisons for linear and binary search
Recursive algorithms: tracing, identifying base cases, completing missing steps, finding equivalent iterative algorithms
Randomization: appropriate applications, difference between random and pseudorandom numbers
Category III

Programming (Largest Category)

30% · ~30 questions
Writing and modifying programs: describing what code does, identifying missing code, placing statements in order, tracing output and variable values
Error types: syntax, runtime, compile-time, overflow, round-off, logic — identifying and correcting each type
Extensibility, modifiability, reusability: constants vs. hard-coded values, parameterization, functionally equivalent code
Three basic constructs: sequence, selection (if/else), and iteration (for, while, do-while, repeat-until)
Standard operators and precedence: assignment, arithmetic, relational, logical; Boolean algebra and De Morgan's laws
Variables and data types: int, float, double, boolean, char, String, arrays/lists; integer vs. floating point division; scope (global vs. local)
Procedures with parameters and return values: tracing nested calls, passing references to objects and arrays
Event-driven programming: responding to sensors, messages, clicks; concurrency issues from asynchronous events
Data structures: dictionaries/maps (key-value), stacks (LIFO — first-in last-out), queues (FIFO — first-in first-out)
Debugging and testing: selecting useful test cases, print statement placement, empirical testing vs. proof
Libraries and APIs: correct calls, return value use, when to use vs. write original code
OOP concepts: classes, instance variables, methods; inheritance and encapsulation benefits; overloading vs. overriding
Category IV

Data

15% · ~15 questions
Bits and bytes: calculations, determining storage size for given data, why binary is fundamental to computer systems
Encoding vs. encryption: encode/decode given a scheme, distinguish the two concepts; trade-offs in using encryption
Lossy vs. lossless compression: Huffman coding (lossless); understanding when each type is appropriate
Spreadsheet analysis: formulas, filters, sorts, charts, graphs; transforming data to discover patterns, connections, and trends
Simulation and modeling: tracing simulation code, identifying missing steps, validating models by comparing with real-world data
Data storage and management: file size measures (byte through petabyte), scale, redundancy, backup; databases and terminology
Data collection methods: surveys, sensors, crowdsourcing, citizen science; publicly available datasets and their benefits
Data processing: identifying data that needs cleaning or modification before use; appropriate collection methods for given contexts
Category V

Computing Systems and Networks

15% · ~15 questions
Operating systems: hardware and software components, OS tasks, resource issues affecting functionality
Internet of Things (IoT): embedded systems, sensors, how IoT devices communicate and function in everyday objects
Fetch-decode-execute cycle: what happens at each step, correct ordering of steps
Local vs. network vs. cloud: trade-offs in performance, cost, security, reliability, and collaboration
Internet protocols: purpose of protocols; IPv4 vs. IPv6; URL structure (protocol, subdomain, domain, port, path); DNS hierarchy; IP addressing
Network concepts: bandwidth, load, latency; network hardware devices; wired and wireless communication systems; network types
Five pillars of cybersecurity: confidentiality, integrity, availability, nonrepudiation, authentication — definitions and contexts
Web components: HTTP, HTML, browsers, servers, clients; markup language uses; digital and physical security strategies

Question Format

The exam uses a variety of selected-response question formats beyond standard single-answer multiple choice.

Standard
Single-Answer SR
Select one answer from four choices (A–D). Most questions are this type. Standard oval selection interface.
Multi-Select
Select All That Apply
Select all correct answers from a list. Uses checkboxes instead of ovals. Directions will explicitly say "Select all that apply." (e.g., sample question 1 on DDoS/AI app uses this format)
Code Trace
Pseudocode Analysis
Given pseudocode, trace execution and identify output, variable values, or errors. Uses the proprietary pseudocode notation — know the syntax before test day.
Completion
Fill Missing Code
Given incomplete pseudocode with a /* missing code */ or /* missing condition */ placeholder, identify the correct replacement from four choices.

Registration, Test Day & Scoring

Everything you need to know before and on test day.

Registration

Where to registerpraxis.ets.org
Exam fee$130
Testing formatsIn-person or remote
ID required2 forms of valid ID
Arrive (in-person)15–30 min early

Scoring

Score typeScaled score
Raw score basisCorrect answers only
Wrong answer penaltyNone
Passing scoreVaries by state
Results available~5 weeks post-test

In-Person Testing

Test centersPrometric locations
Personal itemsStored in locker
Scratch paperProvided at station
Admission ticketPrint from ETS account

Remote Testing

DeviceLaptop/desktop only
No touchscreensTablets not allowed
Browser requiredETS Secure Test Browser
Equipment neededWebcam, mic, speakers

Passing Score Requirements by State

Passing scores are set independently by each state and vary — there is no universal passing score for this exam.

Important: Passing score requirements for the Computer Science (5652) are set individually by each state or licensing agency. A score that meets requirements in one state may not meet requirements in another. Always verify the exact passing score for your state at ets.org/praxis/states before registering.

Your raw score (number of correct answers) is converted to a scaled score that accounts for minor difficulty differences between test editions. There is no penalty for incorrect answers— always answer every question, including "select all that apply" questions. Some questions are unscored pretest items that you cannot identify, so treat every question equally. The live page shows a passing score of 157 — this is not a universal requirement and should not be relied upon; always verify your specific state's requirement.

How to Prepare for the Praxis Computer Science Exam

Strategies aligned to the exam's 5-category structure, pseudocode-based programming questions, and mix of conceptual and applied CS content.

Study the ETS pseudocode notation thoroughly before attempting any programming questions.

This is the single most critical preparation step specific to this exam. The proprietary pseudocode uses ← for assignment (not =), and, or, not for logical operators (not &&, ||, !), and specific syntax for all loop types and procedures. Download the ETS Study Companion and study the Pseudocode Notation table on pages 21–23 — it documents every operator, control structure, and data type. Programming experience in Python or Java does not automatically transfer.

Programming (Category III, 30%) is the largest category — allocate the most study time here.

With approximately 30 questions, Programming is nearly one-third of the entire exam. It covers a wide range of skills: tracing code execution, identifying output, finding and fixing bugs, completing missing code, choosing equivalent statements, and working with all data structures. Practice tracing pseudocode by hand — the ability to manually step through a program and track variable values is the core skill tested here.

Master all six error types: syntax, runtime, compile-time, overflow, round-off, and logic.

The exam distinguishes between these error types and asks you to identify which one a given code segment produces. Syntax errors are caught at compile time (invalid code structure). Runtime errors occur during execution (array out of bounds, division by zero). Logic errors produce wrong output without crashing. Overflow occurs when a value exceeds the maximum representable value. Round-off errors arise from floating point representation. Know examples of each.

For data structures, know queue vs. stack vs. dictionary/map by behavior — not by implementation.

The exam tests these through scenario matching: a car wash (first-in first-out) is a queue; a tennis ball can with one opening (first-in last-out) is a stack; a contestant ID mapping is a dictionary/map. Practice the sample question 16 from the Study Companion — it directly represents the style of data structure questions on the exam.

Know the five pillars of cybersecurity: confidentiality, integrity, availability, nonrepudiation, and authentication.

Category V (15%) includes cybersecurity questions that specifically test these five terms by definition and by context. Authentication is the pillar compromised when someone logs in with stolen credentials (not confidentiality — a common wrong answer). Know the precise distinction between all five and be able to identify which pillar is violated in a given scenario.

For algorithm complexity, know the traveling salesman problem is factorial — not quadratic.

The exam's sample question 7 directly tests this: generating all possible orderings of N cities and evaluating each is a factorial-time brute-force approach (N! permutations). Linear = one pass through data; quadratic = nested loops; logarithmic = divide and conquer (binary search); exponential = doubling with each step; factorial = generating all permutations. Know which algorithms belong to each complexity class.

Study intellectual property carefully — Creative Commons, copyright, and open source are each tested differently.

Category I includes questions like sample question 2: a CC BY (Creative Commons Attribution) license allows any use — including commercial — as long as the original author is credited. Know the differences between CC BY, CC SA (share-alike), CC NC (non-commercial), open source (modifiable but license-dependent), and standard copyright (all rights reserved). These distinctions appear in classroom context questions about teaching materials.

Download the official ETS Study Companion and work through all 25 sample questions with detailed answer explanations.

The Study Companion for 5652 contains 25 sample questions spanning all five categories, with full explanations for every answer choice — including why each wrong answer is wrong. The explanations model the exact reasoning required on the exam. Working through them systematically is more valuable than any other single preparation activity.

Frequently Asked Questions

Answers sourced directly from the official ETS Praxis Computer Science (5652) Study Companion.

How many questions are on the Praxis Computer Science (5652) exam?+
The exam contains 100 selected-response questions with a time limit of 3 hours (180 minutes). Questions span 5 content categories: Impacts of Computing (~15 questions, 15%), Algorithms and Computational Thinking (~25 questions, 25%), Programming (~30 questions, 30%), Data (~15 questions, 15%), and Computing Systems and Networks (~15 questions, 15%). Some questions may be unscored pretest items.
What programming language is used on the Praxis Computer Science (5652)?+
The exam uses a proprietary ETS pseudocode notation — not Python, Java, C++, or any real programming language. The pseudocode uses ← for assignment, spelled-out logical operators (and, or, not), specific loop syntax (for, while, do-while, repeat-until), and defined procedure and class formats. This notation is fully documented in the ETS Study Companion and must be studied independently before test day.
What are the 5 content categories on the Praxis Computer Science (5652)?+
The exam covers 5 official content categories: (I) Impacts of Computing — 15%, ~15 questions; (II) Algorithms and Computational Thinking — 25%, ~25 questions; (III) Programming — 30%, ~30 questions (the largest category); (IV) Data — 15%, ~15 questions; and (V) Computing Systems and Networks — 15%, ~15 questions. The live page incorrectly shows 3 domains — there are 5.
What is the time limit for the Praxis Computer Science (5652)?+
The time limit is 3 hours (180 minutes), per the official ETS Study Companion. The live page incorrectly shows 2h 30m. With 100 questions in 180 minutes, candidates have approximately 1 minute 48 seconds per question on average.
What is the passing score for the Praxis Computer Science (5652)?+
There is no single universal passing score. Each state or licensing agency sets its own minimum scaled score requirement. The passing score shown on the live page (157) is not a universal standard. Always verify the exact requirement for your state at ets.org/praxis/states before registering.
What standards is the Praxis Computer Science (5652) aligned to?+
The exam is not aligned to any particular CS curriculum, but is consistent with the K-12 Computer Science Framework (2016), the CSTA K-12 Computer Science Standards (2017), and the ISTE Computational Thinking Competencies. These frameworks collectively define what a beginning secondary school CS teacher should know and be able to do.
Does the exam test knowledge of a specific programming language?+
No. The exam uses proprietary pseudocode only — no specific real-world programming language is required or tested. However, strong programming proficiency in any language will transfer well because the underlying concepts (variables, loops, conditionals, functions, OOP) are universal. The key is to learn the specific pseudocode syntax so you can accurately trace and analyze the code segments that appear in exam questions.
Is there a penalty for wrong answers on the Praxis Computer Science (5652)?+
No. Your score is based solely on correct answers. There is no penalty for incorrect responses. Always answer every question — never leave one blank. For "select all that apply" questions, select every choice you believe is correct — you are not penalized for selecting incorrect choices on these either, though partial credit structures may vary. When in doubt, guess.

Ready to Start Practicing?

Adaptive questions aligned to all 5 official content categories — pseudocode tracing, algorithm analysis, impacts of computing, data concepts, and network/systems knowledge. Domain-level analytics so you know exactly where to focus.

Get Free Access — No Credit Card Needed
Sources: ETS Praxis Computer Science (5652) Study Companion (official PDF, praxis.ets.org); K-12 Computer Science Framework (k12cs.org, 2016); CSTA K-12 Computer Science Standards (csteachers.org, 2017); ETS Praxis Test Schedule 2025–26. Praxis® is a registered trademark of Educational Testing Service (ETS). This site is not affiliated with or endorsed by ETS. Passing score requirements vary by state — always verify at ets.org/praxis/states. Last updated: April 2026.
Last Updated: May 10, 2026