Coupling
Coupling is the degree of interdependence between software components, including their dependencies on one another’s structure, behavior, or availability.
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.
Grokking Software Architecture
Coupling is the degree of dependency between software components, with tight coupling requiring extensive knowledge of another component's operations or internal structure.
- How it is used
- Uses coupling to assess separation of concerns and identify dependencies that hinder change, testing, or service availability.
- How deep it goes
- Defines tight and loose coupling, demonstrates a dependency-injection refactor, and provides a four-question audit of class interactions.
- Examples
- Uses LEGO bricks, a database-backed report generator, and a synchronous order-processing chain to illustrate coupling.
- What you can do after
- Diagnose tight coupling by inspecting class interactions, change impact, and difficulty substituting dependencies in tests.
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
- Uses low coupling to manage complexity across component, subsystem, module, and embedded-language design.
- How deep it goes
- Works through dependency problems and refactorings using interfaces, service handles, module boundaries, and parameterized algebraic data types.
- Examples
- Contrasts a thermometer observer with interface-based alternatives and separates vendor assets from a device implementation.
- What you can do after
- Apply decoupling through interfaces, service handles, and parameterized algebraic data types to make components easier to change and test.
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 organization by weighing coupled changes against future growth.
- How deep it goes
- Explains the maintenance tradeoff and suggests refactoring, without a method for measuring coupling.
- Examples
- Uses a game service with separate API, router, and new-game handler files.
- What you can do after
- Evaluate package boundaries by considering which structures and functions change 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
- Uses coupling to motivate dependency injection and separation of concerns in web applications.
- How deep it goes
- Explains manual construction, parameter injection, and interface substitution; defers configuring injection for application classes.
- Examples
- Contrasts email-sender construction with injected interfaces and recounts a business-class rename that broke HTML generation.
- What you can do after
- Evaluate how construction responsibilities, interfaces, and component boundaries affect change and testability.
The Coder Cafe
Loose coupling is a software design condition in which components have limited dependencies and changes to one have minimal impact on the others.
- How it is used
- Uses coupling to assess whether dependencies make changes spread between components and raise maintenance costs.
- How deep it goes
- Defines tight and loose coupling, traces practical consequences, and distinguishes control from temporal coupling without prescribing a redesign procedure.
- Examples
- Illustrates dependency with shared household plumbing and a class that directly modifies another class’s internal data.
- What you can do after
- Evaluate/understand how a specific dependency could propagate changes or obstruct isolated testing.
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.
Build High Value Software Systems
A dependency relationship in which one software component relies on another component's structure, behavior, or availability.
- How it is used
- Uses coupling to assess how easily code can be removed and to identify design risks during code review.
- How deep it goes
- Contrasts implicit global-state dependence with an explicit parameter and links scattered behavior to deletion effort, without formal coupling metrics.
- Examples
- Uses a caching-layer deletion comparison, a function dependent on global configuration, and prompts tied to model behavior.
- What you can do after
- Diagnose deletion risk by tracing implicit dependencies and checking whether behavior is isolated or scattered across files.
Read how Build High Value Software Systems explains coupling →
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.
Microservices Patterns, Second Edition
Coupling is a dependency between software elements in which changes, failures, or shared resources in one element can affect another.
- How it is used
- Frames coupling as an architectural concern affecting ease of change, development flow, availability, and latency.
- How deep it goes
- Defines coupling and distinguishes four forms, linking them to development-time or runtime effects.
- Examples
- Uses cross-team change coordination and a shared database to illustrate coupling concerns.
- What you can do after
- Understand four coupling forms and relate them to development or runtime effects.
Read how Microservices Patterns, Second Edition explains coupling →
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.
Data-Oriented Programming in Java
A dependency relationship in which one software component or test relies on the implementation details or behavior of another.
- How it is used
- Diagnoses why shared test helpers make suites fragile and recommends randomized, explicitly specialized test data.
- How deep it goes
- Explains coupling through Account factory examples, consequences, randomization, overloads, and Withers, without descending into framework internals.
- Examples
- Uses Account factories, enterprise segments, regions, spend thresholds, randomized attributes, and fluent Wither calls.
- What you can do after
- Apply randomized test data and Withers to make test assumptions explicit and prevent dependencies on hidden values.
Read how Data-Oriented Programming in Java explains coupling →
Also covered in
- Tech Startup Toolkit
- ActiveMQ in Action
- Software Architecture Decision-MakingIn early access (MEAP)
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
- MongoDB 8.0 in Action, Third Edition
- .NET MAUI in Action
- Data-Oriented Programming: Reduce software complexity
- Get Programming: Learn to code with Python
- The Cloud at Your Service: The when, how, and why of enterprise cloud computing
- Decision EngineeringIn early access (MEAP)
- Grokking Simplicity
- Go by Example
What to know first
- classA class is a programming-language construct that defines a type’s structure and behavior and provides a basis for creating or representing objects.
- refactoringRefactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
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 dependency is a component, resource, or prerequisite that another software component or activity relies on to function, build, or proceed.
- dependency injectionaddressed by · Dependency injection is a software design technique in which a component receives its dependencies from outside rather than creating or locating them internally.
- dependency inversionaddressed by · Dependency inversion is a software design principle in which high- and low-level components depend on abstractions rather than directly on implementation details.
- encapsulationaddressed by · Encapsulation is a software design principle that contains data and implementation details behind a controlled interface, restricting direct access to internal state.
Questions about coupling
What is coupling?
Coupling is the degree of interdependence between software components, including their dependencies on one another’s structure, behavior, or availability.
Which Manning books explain coupling?
Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Grokking Software Architecture, Practices of the Python Pro, Functional Design and Architecture: Examples in Haskell, Learn Go with Pocket-Sized Projects, Object-Oriented Software Design in C++, Simple Object-Oriented Design: Create clean, maintainable applications, Software Design for Python Programmers and 14 more.
What should I know before learning coupling?
Manning books that teach coupling usually introduce class, refactoring, software testing and contract first.
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.





















