liveBook · Manning

Maintainability

Also called maintainable

Maintainability is the degree to which software can be understood, modified, corrected, tested, or kept operational with reasonable effort over time.

How 10 Manning books explain it

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.

Read how "Looks Good to Me" explains maintainability →

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.

Read how Python How-To explains maintainability →

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.

Read how Practical Automation with PowerShell: Effective scripting from the console to the cloud explains maintainability →

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.

Read how Decision Engineering explains maintainability →

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.

Read how The Well-Grounded Python Developer: How the pros use Python and Flask explains maintainability →

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

What to know first

Related concepts

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.