liveBook · Manning

Coupling

Coupling is the degree of interdependence between software components, including their dependencies on one another’s structure, behavior, or availability.

How 22 Manning books explain it

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.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains coupling →

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.

Read how Grokking Software Architecture explains coupling →

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.

Read how Practices of the Python Pro explains coupling →

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.

Read how ASP.NET Core in Action, 3e explains coupling →

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.

Read how The Coder Cafe explains coupling →

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.

Read how Building User-Friendly DSLs explains coupling →

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.

Read how The Art of Code explains coupling →

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.

Read how API Design Patterns explains coupling →

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.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains coupling →

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.

Read how Effective Platform Engineering explains coupling →

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.

Read how Python How-To explains coupling →

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

What to know first

Related concepts

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.