Flexibility
Flexibility is the capacity of a system, design, or process to adapt to changing requirements or conditions without extensive restructuring.
Object-Oriented Software Design in C++
Software flexibility is the ease with which a software system can accommodate new features or changed requirements.
- How it is used
- Uses flexibility to manage changing requirements, added features, and runtime behavior without spreading modifications through the system.
- How deep it goes
- Explains trade-offs, change isolation, and strategy refactoring through examples, but stops short of a general measurement method.
- Examples
- Demonstrates flexibility with sports strategies, runtime venue replacement, and hardcoded ticket enhancements.
- What you can do after
- Apply it via design principles and the Strategy Design Pattern to isolate variation and substitute behavior at runtime.
Read how Object-Oriented Software Design in C++ explains flexibility →
Practices of the Python Pro
Flexibility is the capacity of software to be adapted to related or similar tasks.
- How it is used
- Uses flexibility to guide design choices for adapting software, adding features, and changing existing behavior.
- How deep it goes
- Defines resistance to change and demonstrates decomposition, refactoring, mappings, and extension, without descending into implementation internals.
- Examples
- Demonstrates conditional-to-dictionary refactoring, feature addition, and reuse of core logic across command-line and mobile interfaces.
- What you can do after
- Apply it by refactoring rigid conditionals, separating responsibilities, and preparing existing code for localized changes or new behaviors.
Data-Oriented Programming: Reduce software complexity
The degree to which a software system can adapt to changing requirements without requiring changes to its design.
- How it is used
- Guides data-oriented design toward systems that accommodate changing requirements without changing their overall design.
- How deep it goes
- Explains flexibility through code-data separation, heterogeneous maps, stateless functions, and explicit safety tradeoffs.
- Examples
- Uses Watchmen records, JavaScript and Java maps, member database insertion, and Lodash _.at.
- What you can do after
- Apply it via maps and stateless functions to adapt data representations and select database fields flexibly.
Read how Data-Oriented Programming: Reduce software complexity explains flexibility →
Machine Learning System Design
Flexibility is the capacity of a system to accommodate changes in models, processing steps, features, interfaces, or implementation technologies.
- How it is used
- Guides inference-system design when models, pipelines, interfaces, and production requirements are expected to evolve.
- How deep it goes
- Defines flexibility through concrete change categories and architecture guidance, but stops short of implementation details.
- Examples
- Uses framework conversion, added preprocessing and postprocessing, new features, and additional APIs as flexibility cases.
- What you can do after
- Operate/configure inference systems that accommodate model and framework changes while preserving existing functionality.
Read how Machine Learning System Design explains flexibility →
Think Like a Software Engineering Manager
Flexibility is the capacity to adapt arrangements, behavior, or decisions to changing needs and circumstances.
- How it is used
- Adapts working arrangements and leadership practices to employee needs while preserving communication, collaboration, and shared goals.
- How deep it goes
- Demonstrates flexibility through a workplace scenario and practical measures, stopping short of formal frameworks or technical implementation.
- Examples
- Uses revised core hours, adjusted manager schedules, work-from-home support, rampback programs, and no-meeting days.
- What you can do after
- Practice/perform it by gathering feedback, revising rigid policies, and balancing employee choice with collaboration requirements.
Read how Think Like a Software Engineering Manager explains flexibility →
Software Design for Python Programmers
Flexibility is the ability of software to change its behavior or accommodate new requirements without modifying its core implementation.
- How it is used
- Handles changing requirements and run-time behavior through encapsulation, interfaces, composition, and delegation.
- How deep it goes
- Explains hardcoding, change isolation, strategy replacement, and complexity tradeoffs through a worked sports refactoring.
- Examples
- Uses baseball, football, and volleyball strategies, including replacing volleyball’s open-field venue with a stadium.
- What you can do after
- Apply it via the Strategy Design Pattern to add, modify, or replace algorithm variants with localized code changes.
Read how Software Design for Python Programmers explains flexibility →
API Design Patterns
Flexibility is the property of an interface that allows users or client code to accommodate changes without losing functionality.
- How it is used
- Frames API design around how safely interfaces can change for their users.
- How deep it goes
- Defines flexibility through API and GUI contrasts, stopping short of implementation techniques or detailed compatibility strategies.
- Examples
- Uses an API field rename, GUI button changes, and a comparison of private and public interfaces.
- What you can do after
- Evaluate/understand why API changes are more brittle than comparable GUI changes.
Shipping Go: Develop, deliver, discuss, design, and go again
Flexibility is the ability of a software system or development process to adapt to changing requirements, inputs, or operating conditions.
- How it is used
- Guides runtime configuration, incremental delivery, customer learning, and infrastructure adjustment after initial launch.
- How deep it goes
- Defines configurable behavior, feature hiding, remote settings, and testing practices, but omits implementation mechanics.
- Examples
- Uses default values, database endpoints, hidden features, digital dashboards, load, special-character inputs, Selenium, and Cypress.
- What you can do after
- Operate/configure applications remotely, hide unfinished features, and test behavior under changing inputs and conditions.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains flexibility →
Simple Object-Oriented Design: Create clean, maintainable applications
The capacity of a software design to accommodate variation or alternative implementations without requiring extensive structural changes.
- How it is used
- Uses abstractions and extension points to absorb feature variation while allowing modules and teams to evolve independently.
- How deep it goes
- Explains rationale, maintenance consequences, examples, and tradeoffs, but defers implementation details and design-pattern instruction.
- Examples
- Shows discount extension points, conditional-branch refactoring, payment APIs, and registration APIs as concrete flexibility mechanisms.
- What you can do after
- Evaluate where abstractions or extension points will reduce future rewrites, then balance their maintenance benefits against added complexity.
Related concepts
- hardcodingcontrasts with · Hardcoding is embedding fixed values, rules, configuration, or behavioral choices directly in a program or its implementation rather than supplying or deriving them separately.
- factoryused by · A factory is a function, method, class, or component that creates and returns objects or other values while encapsulating construction details or selection.
- inversion of controlproduced by · Inversion of control is a design principle that delegates application flow, object creation, or dependency selection from application components to an external mechanism or caller.
- shotgun surgerycontrasts with · Shotgun surgery is a code smell in which one logical change requires many separate modifications across a software system.
- decorator design patternproduced by · The decorator design pattern is a structural pattern that dynamically adds responsibilities or behavior to an object by wrapping it with objects that preserve its interface.
- designproduced by · Design is the process of planning and specifying an artifact’s structure, behavior, or presentation, and the resulting arrangement, to meet intended purposes and constraints.
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.