Study guide

10.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization

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.4 Extensibility, Modifiability, and Reusability: Constants and Parameterization

Key Takeaways Explain This Topic AI

Extensibility is how easily new features or cases can be added; modifiability is how easily existing behavior can be changed correctly; reusability is how easily code can be used again in other places or programs.

Replace a hard-coded value with a named constant or variable when it appears more than once, is likely to change, or has a meaning that the bare number hides.

Parameterization turns a value that is fixed inside a procedure into a parameter, so one procedure handles many cases.

A procedure that returns a result is more reusable than one that prints it, because callers can print, store, or combine the result.

Two code segments can produce identical output yet differ greatly in how easy they are to extend, modify, or reuse.

Last updated: September 2026

What this competency asks

ETS asks you to know the concepts of extensibility, modifiability, and reusability :

Identify the meaning of the terms.

Identify functionally equivalent statements or code segments that differ in one of these three ways.

Identify situations where constants or variables would be preferred over hard-coded values.

Identify opportunities for parameterization.

Choose code that improves on given code by making it more extensible, modifiable, or reusable.

Identify changes that would improve a given code segment.

These questions often show two segments that produce the same output and ask which is better. That makes this a design topic, not a correctness topic.

The three qualities

Quality Question it answers Improved by

Extensibility How easily can we add a new feature or case? Data-driven designs (lists and tables instead of long if-chains), procedures, classes, inheritance

Modifiability How easily can we change existing behavior without breaking it? Named constants, one place for each fact, clear names, small procedures

Reusability How easily can this code be used again elsewhere? Parameters instead of fixed values, returning results instead of printing, no reliance on global variables

  • Constants and variables vs. hard-coded values
  • A hard-coded (or "magic") value is a literal written directly into the logic. // Hard-coded
  • double total1 ← price1 + price1 * 0.07
  • double total2 ← price2 + price2 * 0.07
  • if ( numStudents > 30 )
  • print "Class is over capacity"
  • end if // Named constants
  • double TAX_RATE ← 0.07
  • int MAX_CLASS_SIZE ← 30
  • double total1 ← price1 + price1 * TAX_RATE
  • double total2 ← price2 + price2 * TAX_RATE
  • if ( numStudents > MAX_CLASS_SIZE )
  • print "Class is over capacity"
  • end if

Both segments behave identically today. When the tax rate changes, however, the first version must be edited in several places, and missing one creates a bug. The second changes in one place, which improves modifiability . The names also document meaning: 30 could be anything, but MAX_CLASS_SIZE says what it is.

Prefer a named constant or a variable when the value:

  • Appears more than once
  • Is likely to change , such as rates, limits, sizes, and thresholds
  • Has a meaning the bare number hides

Depends on the data . Loop over n or the array's length, not a literal 10, so the code still works when the data size changes

Values such as 0 or 1 used as starting points, or the 2 in n % 2 , are usually fine as literals.

Parameterization

Parameterization turns a fixed value inside a procedure into a parameter. Look for duplicated code that differs only in a value : // Before: three near-copies

  • void printRowOf5Stars ( )
  • for ( int i ← 0; i < 5; i ← i + 1 )
  • print "*"
  • end for
  • end printRowOf5Stars
  • // … and printRowOf8Stars, printRowOf10Stars … // After: one reusable procedure
  • void printRow ( String symbol, int count )
  • for ( int i ← 0; i < count; i ← i + 1 )
  • print symbol
  • end for
  • end printRow

Now printRow ( "*", 5 ) , printRow ( "#", 8 ) , and any future variation use the same tested code, which improves reusability and extensibility .

Opportunities for parameterization show up as:

  • Procedures whose names contain a specific value, such as drawSquare50 or taxForOhio
  • Copy-and-paste blocks that differ in a number or string
  • A procedure that reads a global variable that could be passed in instead
  • Return, don't print // Less reusable: the procedure decides how the result is used
  • void showAverage ( int[ ] a, int n )
  • …
  • print sum / n
  • end showAverage
  • // More reusable: the caller decides
  • double average ( int[ ] a, int n )
  • …
  • return sum / n
  • end average

average can be printed, stored, compared, or passed to another procedure. showAverage is only good for printing. Separating computation from input and output is one of the most common "which improves the code" answers.

Designing for extension

A long chain of if tests that must be edited whenever a new case appears is hard to extend: if ( code == "A" ) … else if ( code == "B" ) … else if ( code == "C" ) …

Storing the cases as data, for example in a dictionary that maps codes to values (Section 9.3), lets you add a case by adding an entry, without rewriting logic. In object-oriented design, adding a new subclass that overrides a method (Section 12.4) extends behavior without editing the existing classes.

Choosing the improvement

When asked which change improves a segment, look for the option that:

Removes duplication , using a loop or a procedure.

Replaces magic numbers with named constants or with data-derived values such as the array's length.

Adds parameters so the code handles more cases.

Returns values rather than printing them.

Avoids global variables in favor of parameters and return values.

Uses meaningful names .

Beware of choices that change the output. An "improvement" must stay functionally equivalent unless the question says the behavior should change.