liveBook · Manning

Extensibility

Also called extensible

Extensibility is the capacity of a software system to accommodate additional capabilities or behaviors with limited changes to its existing structure.

How 8 Manning books explain it

The Design of Web APIs, Second Edition

The capacity of an API to accommodate future capabilities or changes without requiring disruptive redesign.

How it is used
Guides initial API design so later capabilities are less likely to disrupt consuming applications.
How deep it goes
Works through representation patterns and consumer-dependent compatibility, while leaving unavoidable breaking changes to impact assessment and versioning.
Examples
Uses account pagination, transfer responses, owner identifiers, ISO 8601 recurrence periods, status arrays, and product categories.
What you can do after
Practice/perform extensible API design by choosing adaptable representations and checking proposed changes against consumer behavior.

Read how The Design of Web APIs, Second Edition explains extensibility →

Practices of the Python Pro

The property of a software system that permits new functionality to be added without fundamentally modifying its existing structure.

How it is used
Guides developers toward adding features to existing applications without disrupting established behavior.
How deep it goes
Defines the property, contrasts isolated additions with shotgun surgery, and demonstrates function-and-configuration extension.
Examples
Uses browser plugins, Bark feature additions, and response-format functions selected through configuration mappings.
What you can do after
Build extensible Python features by isolating behavior and adding implementations plus configuration rather than scattered conditionals.

Read how Practices of the Python Pro explains extensibility →

Effective Platform Engineering

Extensibility is the ability of a system to accept additional capabilities or behaviors without modifying its core implementation.

How it is used
Positions extensibility as a platform capability for adding cloud-native behaviors through standardized APIs.
How deep it goes
Explains extensibility through APIs, orchestration standardization, sidecars, pipelines, and integration patterns rather than detailed implementation mechanics.
Examples
Uses Kubernetes orchestration, a vault-refreshing pod sidecar, lifecycle pipelines, and adapter patterns as concrete extension forms.
What you can do after
Apply it via platform APIs, sidecars, lifecycle pipelines, adapters, and event-driven integrations.

Read how Effective Platform Engineering explains extensibility →

Functional Design and Architecture: Examples in Haskell

Extensibility is the ease with which a software system can accommodate new capabilities, types, or variations.

How it is used
Uses extensibility to shape typed key–value persistence and to frame maintainability as a software-quality requirement.
How deep it goes
Defines data and behavior extensibility, contrasts object-oriented and functional approaches, and names type-level mechanisms without developing their internals.
Examples
Uses typed key–value persistence for Meteor and Comet records, with raw storage representations converted into domain values.
What you can do after
Evaluate how typed designs accommodate new data types and methods while preserving business-logic safety.

Read how Functional Design and Architecture: Examples in Haskell explains extensibility →

Just Use Postgres!

Extensibility is the capability of a database system to add or customize data types, operators, access methods, and other functionality.

How it is used
Uses extensions to adapt Postgres for specialized workloads and capabilities beyond the core database engine.
How deep it goes
Explains design rationale and integration mechanisms, but stops short of showing extension-specific installation or implementation commands.
Examples
Demonstrates JSON, time-series, full-text, vector similarity, administrative, and development extensions as workload examples.
What you can do after
Evaluate/understand how Postgres extensions add capabilities, intercept database behavior, and support specialized workloads.

Read how Just Use Postgres! explains extensibility →

High Performance Unity Game Development

The property of software that allows new capabilities or content to be added with limited changes to existing code.

How it is used
Uses data-oriented design to keep the architectural effort of adding gameplay features more predictable as games grow.
How deep it goes
Explains feature changes through required data and transformations, while noting that integration and testing still add cost.
Examples
Contrasts tile behaviors such as merging, duplication, explosions, and teleportation, and cites feature work on Nova Legends.
What you can do after
Apply data-oriented design by identifying a feature’s data, transformations, and flow instead of extending behavior-object relationships.

Read how High Performance Unity Game Development explains extensibility →

Data-Oriented Programming: Reduce software complexity

Extensibility is the capacity of software to accommodate new functionality with minimal changes to existing code.

How it is used
Frames extensibility as the main practical benefit of polymorphism when adding new animal behavior.
How deep it goes
Contrasts switches, separate functions, classes, and multimethods, but stops short of explaining multimethod implementation.
Examples
Uses dog, cat, and cow greetings implemented through classes, maps, switches, and separate functions.
What you can do after
Evaluate whether a design lets new animal types extend behavior without modifying existing dispatch code.

Read how Data-Oriented Programming: Reduce software complexity explains extensibility →

Software Testing with Generative AI

The capacity of a system to be expanded with additional capabilities or adapted to new requirements.

How it is used
Evaluates LLM platforms by how well they integrate with systems and adapt to specific requirements.
How deep it goes
Distinguishes API access, instruction adjustment, further training, and deployment infrastructure without detailing implementation.
Examples
Contrasts OpenAI’s paid API and instruction feature with Meta’s downloadable, further-trainable Llama models.
What you can do after
Evaluate LLM platforms by matching integration, adaptation, and deployment options to the intended use.

Read how Software Testing with Generative AI explains extensibility →

Also covered in

What to know first

Related concepts

Questions about extensibility

What is extensibility?

Extensibility is the capacity of a software system to accommodate additional capabilities or behaviors with limited changes to its existing structure.

Which Manning books explain extensibility?

The Design of Web APIs, Second Edition, Practices of the Python Pro, Effective Platform Engineering, Functional Design and Architecture: Examples in Haskell, Just Use Postgres!, High Performance Unity Game Development, Data-Oriented Programming: Reduce software complexity and Software Testing with Generative AI.

What should I know before learning extensibility?

Manning books that teach extensibility usually introduce contract, attribute, method and OpenAPI specification first.

What is the difference between extensibility and expression problem?

Extensibility is the capacity of a software system to accommodate additional capabilities or behaviors with limited changes to its existing structure. The expression problem is the difficulty of designing a typed data model that can be extended with both new data variants and new operations.

What is extensibility also called?

Extensibility is also called extensible.

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.