Extensibility
Extensibility is the capacity of a software system to accommodate additional capabilities or behaviors with limited changes to its existing structure.
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 API design and evolution when new capabilities, feedback, or contextual constraints may otherwise force disruptive changes.
- How deep it goes
- Explains extensibility through concrete representation patterns, compatibility assessment, versioning policy, and modification documentation.
- Examples
- Uses account pagination, transfer representations, ISO 8601 durations, grouped events, and the category-to-categories breaking-change scenario.
- What you can do after
- Apply extensible API patterns, evaluate modification effects, and document versioned changes for consumers.
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.
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 →
Related concepts
- breaking changeaddresses · A breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes.
- OpenAPI specificationused by · The OpenAPI Specification is a standard, machine-readable format for describing HTTP APIs, including their operations, inputs, outputs, data structures, and security requirements.
- arraycontrasts with · An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
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.