Coupling
Coupling is the degree of dependency between software components, including how their behavior, availability, or changes affect one another.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
Loosely coupled software architecture is an architecture in which components or services have limited dependencies and can change with minimal impact on one another.
- How it is used
- Uses coupling to judge whether domain boundaries and software architecture allow teams to deliver changes independently.
- How deep it goes
- Explains change coupling, classifies four integration strengths, and offers flow mapping and cost heuristics without prescribing one universally optimal boundary.
- Examples
- Contrasts three-team and one-team loyalty changes and describes airline subdomains whose similar terminology concealed different models.
- What you can do after
- Evaluate/understand it by mapping cross-subsystem flows, comparing coupling strength, and reconsidering costly domain boundaries.
Practices of the Python Pro
Loose coupling is a design property in which software components have limited interdependence.
- How it is used
- Frames loose coupling as a foundation for maintainability, independent change, and extensibility.
- How deep it goes
- Explains coupling as a continuum, contrasts rigid and flexible designs, and applies interfaces, encapsulation, and separated concerns.
- Examples
- Uses conditional mappings, query cleaning, and Bark’s commands, database layer, menu, and multitier architecture.
- What you can do after
- Apply it by separating concerns, hiding implementation details, and introducing shared abstractions between collaborating components.
Functional Design and Architecture: Examples in Haskell
Decoupling is the reduction of dependencies between software components or language modules so they can change more independently.
- How it is used
- Guides separation of responsibilities when designing subsystems, modules, architectures, and embedded languages.
- How deep it goes
- Explains coupling through refactorings, module-layer dependencies, service handles, and parameterized ADTs rather than formal metrics.
- Examples
- Contrasts a temperature observer, vendor-dependent device construction, Service Handle values, and parameterized Hdl and LogicControl languages.
- What you can do after
- Apply it via interfaces, handles, module boundaries, and dependency direction to make implementations replaceable and testable.
Read how Functional Design and Architecture: Examples in Haskell explains coupling →
Learn Go with Pocket-Sized Projects
Coupling is the degree to which software components depend on one another and therefore must change together.
- How it is used
- Guides package boundaries while organizing an HTTP endpoint.
- How deep it goes
- Defines coupling through code that changes together and explains its maintenance tradeoff; it gives no metric for measuring it.
- Examples
- Uses a new-game endpoint split among API definitions, a handler, and a router.
- What you can do after
- Evaluate/understand package boundaries by checking which structures and functions will need updates together.
Read how Learn Go with Pocket-Sized Projects explains coupling →
Object-Oriented Software Design in C++
Loose coupling is a design property in which classes have few dependencies on one another's implementations.
- How it is used
- Uses minimal implementation dependencies to guide class design, delegation, encapsulation, and pattern-based refactoring.
- How deep it goes
- Explains definitions, change leaks, delegation, Law of Demeter rules, and pattern applications through concrete C++ designs.
- Examples
- Demonstrates Catalogue and Attributes, TeamReport and collections, ticket-machine states, strategies, iterators, visitors, and observers.
- What you can do after
- Apply it via delegation, encapsulation, polymorphism, and design patterns to isolate changes between collaborating classes.
Read how Object-Oriented Software Design in C++ explains coupling →
Simple Object-Oriented Design: Create clean, maintainable applications
Coupling is the degree to which one software component depends on another component.
- How it is used
- Guides dependency decisions that keep object-oriented systems maintainable as classes and modules evolve.
- How deep it goes
- Explains change propagation, stable abstractions, module boundaries, enforcement tools, and pragmatic exceptions without prescribing a universal design.
- Examples
- Uses Basket dependencies, hidden caching, configuration files, payment libraries, Hibernate repositories, Excel adapters, and JUnit internals.
- What you can do after
- Apply it by isolating volatile dependencies, protecting module internals, and monitoring dependency graphs for harmful growth.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains coupling →
Software Design for Python Programmers
Loose coupling is a relationship between software components in which each has few dependencies on the implementation of the others.
- How it is used
- Uses loose coupling to assign class responsibilities, contain change, and select patterns that keep collaborators independent.
- How deep it goes
- Explains dependencies, least knowledge, delegation, and refactoring examples, while deferring formal measurement of coupling.
- Examples
- Demonstrates book catalogues, team reports, baseball subscribers, ticket-machine states, and interchangeable algorithms.
- What you can do after
- Apply it via encapsulation, delegation, Iterator, Observer, State, Strategy, and Template Method refactorings.
Read how Software Design for Python Programmers explains coupling →
ASP.NET Core in Action, 3e
Loose coupling is a software design property in which components have limited knowledge of and dependence on one another.
- How it is used
- Frames dependency injection and separation of concerns as ways to keep application components easier to change and test.
- How deep it goes
- Defines coupling and works through handler dependencies, interfaces, and testing; defers application-class dependency injection configuration.
- Examples
- Uses an email-sending registration handler, alternative test implementations, and a website broken by a business-class rename.
- What you can do after
- Apply it via dependency injection and interfaces to reduce handler dependencies and substitute implementations during tests.
Building User-Friendly DSLs
A dependency relationship in which changes to one software component can require corresponding changes to another component.
- How it is used
- Uses coupling charts to predict how changes to a DSL or its components propagate through a DSL-based approach.
- How deep it goes
- Explains dependency categories, directional strength, structural change types, version checks, and migration, but does not provide implementation code.
- Examples
- Uses DSL component diagrams, coupling arrows, generic AST structures, Domain IDE parts, and categorized DSL structural changes.
- What you can do after
- Evaluate change impact by classifying code, charting dependencies, checking versions, and selecting migration actions.
The Art of Code
Coupling is the degree of interaction or dependency between software components, modules, layers, or classes.
- How it is used
- Guides separation of concerns and durable design by limiting dependencies between components, modules, layers, and classes.
- How deep it goes
- Defines interaction strength, explains change ripple effects, and demonstrates responsibility separation without detailing coupling metrics or implementation internals.
- Examples
- Contrasts an OrderTools class mixing pricing and email communication with separate PricingService and NotificationService classes.
- What you can do after
- Evaluate design dependencies, localize likely change impact, and separate unrelated responsibilities into more focused components.
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
Decoupling is the architectural separation of components so they communicate through an intermediary or interface rather than depending directly on each other.
- How it is used
- Uses intermediaries to reduce dependencies and build fault-tolerant AWS architectures.
- How deep it goes
- Explains synchronous and asynchronous patterns through ELB, SQS, health checks, redundancy, and failure replacement.
- Examples
- Uses redundant EC2 instances behind ELB and asynchronous EC2 workers consuming SQS messages.
- What you can do after
- Apply it via Elastic Load Balancing or SQS to separate components and continue serving through instance failures.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains coupling →
100 Go Mistakes and How to Avoid Them
A software design technique that reduces direct dependencies between components so implementations can change independently.
- How it is used
- Reduces dependencies between Go components by substituting focused interfaces for concrete implementations and controlling error visibility.
- How deep it goes
- Explains interface selection through concrete cases and traces error-wrapping consequences, without developing broader coupling theory.
- Examples
- Uses sort.Interface, CustomerService storage, restricted configuration getters, and fmt.Errorf with %w or %v.
- What you can do after
- Apply it via Go interfaces and deliberate error handling to replace implementations or hide unstable error details.
Read how 100 Go Mistakes and How to Avoid Them explains coupling →
API Design Patterns
Loose coupling is a design property in which components depend on one another through limited, stable contracts and can change independently.
- How it is used
- Separates storage access from resource processing in import and export APIs.
- How deep it goes
- Demonstrates separate interfaces and configurations, stopping before detailed behavioral consistency rules.
- Examples
- Uses Amazon S3 globs and prefixes, CSV message resources, and input/output configuration interfaces.
- What you can do after
- Apply it by designing independent storage contracts that support changing import and export behavior.
Unit Testing Principles, Practices, and Patterns
Tight coupling is a design condition in which software components depend strongly on one another.
- How it is used
- Uses testability to expose coupling problems and evaluates interfaces as possible dependency abstractions.
- How deep it goes
- Defines tight and loose coupling, contrasts testability with quality, and stops short of detailed refactoring procedures.
- Examples
- Uses message-bus and repository interface pairs plus a controller depending on a database and message bus.
- What you can do after
- Diagnose suspected coupling through unit-test difficulty and reject single-implementation interfaces that provide no substantive abstraction.
Read how Unit Testing Principles, Practices, and Patterns explains coupling →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
Coupling is the degree of dependency between software components or services.
- How it is used
- Guides microservice boundaries and communication choices so services can evolve without application-wide ripple effects.
- How deep it goes
- Defines loose and tight coupling, explains their operational consequences, and stops short of specifying indirect-messaging implementation details.
- Examples
- Uses video streaming, video storage, storage-provider changes, and a direct “Viewed” message to illustrate coupling.
- What you can do after
- Evaluate service boundaries and communication paths for unnecessary dependencies before changes cause cascading problems.
Effective Platform Engineering
Loose coupling is an architectural property in which components or domains interact with minimal dependency on one another's internal details.
- How it is used
- Supports self-service engineering-platform domains that interact with little friction and evolve with autonomy.
- How deep it goes
- Explains boundary design, dependency ordering, and autonomy, but stops short of specifying implementation protocols or internal mechanics.
- Examples
- Uses platform-domain maps, dependency ordering, self-service boundaries, and subdomain handoffs between independently organized teams.
- What you can do after
- Apply it by designing measurable domain boundaries and evolving platform ownership as user demand and business value increase.
Python How-To
Loose coupling is a software design condition in which components have minimal dependencies on one another's implementation details.
- How it is used
- Guides class design toward maintainable relationships where related components cooperate without depending heavily on one another.
- How deep it goes
- Explains the design rationale, contrasts forwarding methods and specialized classes, and stops short of formal coupling metrics.
- Examples
- Uses Student, Account, and Demographics classes, including direct attribute access and an alternative forwarding-method design.
- What you can do after
- Build it from scratch by separating class concerns and avoiding methods that unnecessarily expose another class’s implementation.
Related concepts
- error wrappingproduced by · Error wrapping adds contextual information to an error while preserving access to the underlying error for later propagation or inspection.
- dependencyaddresses · A software dependency is a component, resource, or prerequisite on which another software component or operation relies to function or proceed.
- abstractionaddressed by · Abstraction is a simplified representation that exposes relevant properties or behavior while omitting lower-level details unnecessary for a given purpose.
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.