Study guide
10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
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
10.5 Documentation, Code Reviews, Peer Feedback, and End-User Feedback
Key Takeaways Explain This Topic AI
Good documentation explains a procedure's purpose, parameters, return value, and preconditions, and uses comments to explain why the code does something rather than restating what it does.
Poor documentation practices include comments that repeat the code, outdated comments that contradict it, cryptic variable names, and leftover commented-out code.
Code reviews, in which other developers read code before it is merged, find defects, enforce standards, and spread knowledge across a team.
Peer feedback, such as pair programming or classmates reviewing a draft, is especially useful while learning and early in a project.
End-user feedback from usability tests, surveys, beta releases, and bug reports reveals whether software meets real users' needs, which developers often cannot judge themselves.
Last updated: September 2026
What this competency asks
Two related ETS competencies:
Be familiar with characteristics of well-documented computer programs that are usable, readable, and modular. Identify characteristics of good documentation, and identify good and poor documentation practices in context.
Be familiar with techniques to obtain and use feedback to produce high-quality code (for example, code reviews, peer feedback, and end-user feedback). Identify situations in which each technique is useful.
Why documentation matters
Code is read far more often than it is written: by teammates, by future maintainers, by students, and by the original author months later. Documentation makes programs usable (people know how to run and call them), readable (people understand the logic), and modular (each part's contract is clear, so parts can be used and changed independently).
Characteristics of good documentation
Element What it contains Example
Header comment for each procedure Purpose, parameters, return value, preconditions and postconditions See the example below
- Explanatory comments Why a non-obvious choice was made // start at 1: a[0] is already the initial max
- Meaningful names Self-describing variables and procedures studentCount , computeAverage , not x2 or doIt
Consistent formatting Indentation and spacing that reveal structure Required in ETS pseudocode, where indentation is significant
External documentation README or user guide: what the program does, how to install and run it, examples A README explaining the inputs a grading tool expects
API documentation Generated reference for libraries (Javadoc, Python docstrings) Documents each public method's contract
Change history Clear version-control commit messages "Fix off-by-one in findMax loop bound" // Returns the average of the first n values in scores.
- // precondition: n > 0
- // postcondition: returns a double; scores is unchanged
- double average ( int[ ] scores, int n )
- int sum ← 0
- for ( int i ← 0; i < n; i ← i + 1 )
- sum ← sum + scores[i]
- end for
- return sum / n // assume floating-point division (see notation note)
- end average
- Good vs. poor practices
- Poor practice Why it hurts Better practice
- i ← i + 1 // add 1 to i Restates the code and adds noise Comment only what is not obvious
A comment says "returns the minimum" but the code returns the maximum Outdated comments mislead, which is worse than no comment Update comments with every code change
Variables named a , b , temp2 , data Readers must reverse-engineer meaning Descriptive names
Large blocks of commented-out old code Clutters the file and confuses readers Rely on version control for history
No statement of preconditions Callers misuse the procedure (for example, pass an empty array) State preconditions in the header comment
- One enormous procedure with no structure Hard to read, test, or document Split into well-named procedures
- Documentation written only at the end Details are forgotten or wrong Document while writing code
The goal is not "as many comments as possible." Clear names and structure reduce the need for comments, and the comments that remain should add information the code cannot express.
- Feedback techniques
- Code reviews
In a code review , other developers examine code before it is accepted, often through a pull request (Section 2.1).
Most useful for:
- Finding defects, security problems, and unhandled edge cases that the author overlooked
- Enforcing team conventions for style, naming, and documentation
- Spreading knowledge, so more than one person understands each part of the system
- Checking design decisions before they become hard to change
- Peer feedback
Peer feedback is informal feedback from people at a similar level: classmates, a partner, or teammates.
Most useful for:
- Learning: students explaining and critiquing code deepen their own understanding
- Early drafts: catching confusing logic or naming before a full review
Pair programming: a "driver" types while a "navigator" reviews each line in real time and suggests alternatives; the partners switch roles regularly
- Building a classroom culture where code is discussed, not hidden
- End-user feedback
End-user feedback comes from the people the software is for.
Most useful for:
Judging whether the program meets real needs, and whether it is usable and accessible (Section 11.2)
Finding confusing interfaces, unclear messages, and missing features that developers, who know how the program "should" be used, do not notice
Discovering problems that appear only with real data or real devices
Methods: usability testing (watching users attempt tasks), surveys and interviews, beta releases, analytics, and bug-report forms.
Matching the technique to the situation
- Situation Best technique
- Before merging a change to a shared codebase Code review
- A novice class is learning to write loops Peer feedback or pair programming
- A school app is finished, but teachers find it confusing End-user feedback (usability testing)
- Checking that code follows the team's naming standards Code review
- Deciding which features a new app should include End-user feedback (interviews, surveys)
The techniques complement one another. Reviews find code-level problems, peers support learning and early improvement, and end users tell you whether you built the right thing.