Maintainability
Maintainability is the degree to which software can be understood, modified, corrected, tested, or kept operational with reasonable effort over time.
The Art of Unit Testing 3e
The degree to which software or tests can be understood, modified, corrected, or evolved efficiently over time.
- How it is used
- Judges whether tests remain worth keeping as production code changes and guides test reviews.
- How deep it goes
- Defines maintenance pain through forced test changes, then identifies false failures and avoidable coupling rather than prescribing a numerical threshold.
- Examples
- Uses a partial-string assertion, database-query verification, and a pilot comparing implementation time, release time, and production bugs.
- What you can do after
- Practice/perform test reviews that reduce false failures, avoid assertions about incidental internals, and balance maintenance cost against confidence.
Read how The Art of Unit Testing 3e explains maintainability →
"Looks Good to Me"
Code maintainability is the ease with which software code can be understood, modified, debugged, and extended safely.
- How it is used
- Uses code reviews as a team goal for producing stable, readable, extensible, and safer-to-change codebases.
- How deep it goes
- Defines practical review criteria and improvement steps, but stops short of code-level implementation internals.
- Examples
- Uses code reviews, unit tests, edge-case checks, coding conventions, code-smell detection, and pull-request context as concrete practices.
- What you can do after
- Apply it through a team code-review process by prioritizing stability, iterating practices, and resolving disagreements toward maintainable solutions.
Python How-To
Maintainability is the degree to which software can be understood, modified, corrected, or extended with reasonable effort.
- How it is used
- Uses maintainability as an ongoing criterion for practical Python work, from short scripts to team projects.
- How deep it goes
- Provides self-checks and refactoring rationale, then illustrates maintainability through specific Python and project-organization choices.
- Examples
- Illustrates maintainability with shared unittest setup, named functions in tracebacks, and instance attributes initialized in __init__.
- What you can do after
- Practice evaluating and improving Python code through naming, comment cleanup, refactoring, and clearer implementation choices.
Grokking Software Architecture
Maintainability is the degree to which software can be understood, corrected, modified, or extended efficiently over time.
- How it is used
- Frames maintainability as a quality to prioritize against delivery speed, simplicity, scalability, and cost.
- How deep it goes
- Defines the quality and develops design questions, concrete tradeoffs, and refactoring outcomes rather than a quantitative measure.
- Examples
- Compares favorites storage options and illustrates an order-process refactor and an injected logger.
- What you can do after
- Evaluate design options and apply a checklist to spot fragile assumptions, tight coupling, and difficult-to-test boundaries.
Read how Grokking Software Architecture explains maintainability →
Unit Testing Principles, Practices, and Patterns
The ease with which software or tests can be understood, executed, changed, and kept operational.
- How it is used
- Evaluates automated tests as liabilities whose value depends partly on readability and operational simplicity.
- How deep it goes
- Defines maintainability through readability and operational dependencies, then connects it to refactoring and feedback trade-offs.
- Examples
- Uses a trivial property test and an exact-SQL repository assertion to contrast readable tests with implementation-coupled tests.
- What you can do after
- Evaluate tests, reject low-value cases, and prefer assertions that verify observable results over implementation steps.
Read how Unit Testing Principles, Practices, and Patterns explains maintainability →
Practical Automation with PowerShell: Effective scripting from the console to the cloud
Automation maintainability is the ease with which an automated system can be understood, modified, and kept operational as requirements change.
- How it is used
- Frames automation design by weighing the future effort of changing goals, triggers, actions, and building blocks.
- How deep it goes
- Defines maintainability and illustrates its procedural consequences through provisioning and configurable log-retention scenarios.
- Examples
- Uses a failed user-provisioning workflow and a web-server log cleanup retention change.
- What you can do after
- Evaluate/understand whether an automation can adapt to changing requirements without costly repeated edits or manual workarounds.
Decision Engineering
The degree to which a software system can be understood, corrected, adapted, and enhanced over time.
- How it is used
- Frames maintainability as a long-term trade-off in architecture choices and a distinct signal when evaluating open-source dependencies.
- How deep it goes
- Provides repository and community checks for dependency evaluation, but no numerical threshold or guaranteed prediction of future support.
- Examples
- Uses a widely downloaded but unmaintained styling library beneath older Material UI projects to challenge popularity as a maintenance signal.
- What you can do after
- Evaluate/understand it by checking maintainer activity, releases, issues, and community response, with diligence proportional to the dependency’s impact.
Troubleshooting Java, Second Edition
A maintainability problem is a condition in which software is harder to understand, modify, or support because of its structure or implementation.
- How it is used
- Uses logging review to identify instructions that make source code harder to read.
- How deep it goes
- Contrasts concise and crowded implementations, but does not develop broader maintainability measurements or refactoring procedures.
- Examples
- Compares two Java extractDigits implementations, one concise and one crowded with per-step log messages.
- What you can do after
- Evaluate logging instructions for their effect on source-code readability.
Read how Troubleshooting Java, Second Edition explains maintainability →
The Well-Grounded Python Developer: How the pros use Python and Flask
Maintainability is the degree to which software can be understood, modified, corrected, and extended efficiently.
- How it is used
- Guides developers toward code that remains readable, flexible, and changeable as applications and requirements evolve.
- How deep it goes
- Explains conventions, naming, comments, flexibility, and function separation through a worked refactoring, without detailing testing or deployment.
- Examples
- Uses a calculation-formatting-output function example and a MyBlog application configuration improvement.
- What you can do after
- Apply coding conventions and refactor coupled functions into clearer, more reusable components.
Effective Behavior-Driven Development
Maintainability is the ease with which software can be understood, modified, corrected, or enhanced.
- How it is used
- Uses maintainability to motivate lasting behavior documentation and clearer test-data defaults.
- How deep it goes
- Explains executable verification and one default-data pattern, without detailing broader maintenance practices.
- Examples
- Uses automated behavior examples and a pizza-ordering test with a centralized Medium size default.
- What you can do after
- Understand how persistent behavior examples and centralized test defaults can support maintainability.
Read how Effective Behavior-Driven Development explains maintainability →
Also covered in
- The Creative Programmer
- Simple Object-Oriented Design: Create clean, maintainable applications
- Software Design for Python Programmers
- Practices of the Python Pro
- Build Financial Software with Generative AI (From Scratch)
- Grokking Simplicity
- Test Driven: Practical TDD and Acceptance TDD for Java Developers
- Go by Example
- Object-Oriented Software Design in C++
- The Art of Code
- Rust Servers, Services, and Apps
- Architecting an Apache Iceberg Lakehouse
What to know first
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- bugA software bug is a defect that can cause software to behave incorrectly or differently from its intended or specified behavior.
Related concepts
- refactoringproduced by · Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- false positivemeasured by · A false positive is a positive result that incorrectly indicates a target condition is present when it is absent.
- performancecontrasts with · Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.
- scalabilitycontrasts with · Scalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
Questions about maintainability
What is maintainability?
Maintainability is the degree to which software can be understood, modified, corrected, tested, or kept operational with reasonable effort over time.
Which Manning books explain maintainability?
The Art of Unit Testing 3e, "Looks Good to Me", Python How-To, Grokking Software Architecture, Unit Testing Principles, Practices, and Patterns, Practical Automation with PowerShell: Effective scripting from the console to the cloud, Decision Engineering, Troubleshooting Java, Second Edition and 2 more.
What should I know before learning maintainability?
Manning books that teach maintainability usually introduce software testing, function, Python and bug first.
What is the difference between maintainability and performance?
Maintainability is the degree to which software can be understood, modified, corrected, tested, or kept operational with reasonable effort over time. Performance is a measure of how effectively a person, process, model, or system achieves its objectives, including qualities such as output quality, speed, and resource efficiency.
What is maintainability a kind of?
Maintainability is a kind of code review goal. An intended outcome that a team selects to guide and evaluate its code review process.
What is maintainability also called?
Maintainability is also called maintainable.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.









