Loose coupling
A design property in which components have limited direct dependencies and can change or operate more independently of one another.
Microservices Patterns, Second Edition
An architectural property in which software elements have limited dependencies on one another, allowing them to change more independently.
- How it is used
- Uses loose coupling to support fast delivery, team autonomy, and reliable runtime behavior.
- How deep it goes
- Defines four coupling types and develops API design, build organization, and service-boundary trade-offs.
- Examples
- Uses Customer Management and Order Management to illustrate change localization, and compares direct API calls with event publication.
- What you can do after
- Evaluate and understand coupling across design, build, runtime, and infrastructure, and choose dependency arrangements that localize change.
Read how Microservices Patterns, Second Edition explains loose coupling →
Event Processing in Action
Decoupling is the independence of event-producing and event-consuming applications, which need not know of one another.
- How it is used
- Uses events to notify applications of resource changes without requiring continual polling.
- How deep it goes
- Defines mutual producer-consumer independence and contrasts it with request-response, without detailing implementation mechanics.
- Examples
- Uses a temperature sensor and monitoring application to illustrate event notification without polling.
- What you can do after
- Understand how producers and consumers can remain independent while events connect them.
Read how Event Processing in Action explains loose coupling →
Secrets of the JavaScript Ninja, Second Edition
A design property in which interacting components know little or nothing about one another's internal details or control flow.
- How it is used
- Uses custom DOM events to let shared code announce conditions without naming the code that reacts.
- How deep it goes
- Defines loose coupling, contrasts global callbacks, and demonstrates independent handlers and custom-event signaling.
- Examples
- Demonstrates an AJAX operation whose start and completion events control a spinner and carry URL data.
- What you can do after
- Apply it via CustomEvent, dispatchEvent, and addEventListener to signal operation state to independent listeners.
Read how Secrets of the JavaScript Ninja, Second Edition explains loose coupling →
Spring Start Here, Second Edition
Decoupling is the reduction of direct dependencies between software components so that one component's implementation can change independently of another's.
- How it is used
- Uses interfaces to let one component rely on a service without depending on its specific implementation.
- How deep it goes
- Develops the idea through a Java sorting example and Spring injection choices, without detailing interface internals.
- Examples
- Uses a ride-sharing analogy and a delivery printer whose sorting strategy changes from destination address to sender name.
- What you can do after
- Build Java components that depend on an interface and receive an implementation through Spring dependency injection.
Read how Spring Start Here, Second Edition explains loose coupling →
Learn Docker in a Month of Lunches, Second Edition
Decoupling is a design technique that separates communicating components so they do not depend directly on one another.
- How it is used
- Uses a message queue to let senders and receivers communicate asynchronously without direct dependencies.
- How deep it goes
- Demonstrates asynchronous publishing and subscription through Redis containers, including messages sent before a subscriber listens.
- Examples
- Uses a Redis publisher and subscriber on channel21 to demonstrate messages passing through a queue.
- What you can do after
- Apply decoupling by publishing and subscribing through a Redis message queue so components can operate independently.
Read how Learn Docker in a Month of Lunches, Second Edition explains loose coupling →
Microsoft Azure in Action
Decoupling is an architectural pattern that reduces direct dependencies between software components so they can operate and scale independently.
- How it is used
- Buffers incoming orders for asynchronous processing so producers and consumers can operate independently.
- How deep it goes
- Explains queue-based separation, steady processing, ordered retrieval, and message retention when retrieval fails.
- Examples
- Uses Banning Books orders queued during busy sales periods for processing by a separate service.
- What you can do after
- Apply it via Azure Queue Storage to separate order creation from processing and accommodate changing input rates.
Read how Microsoft Azure in Action explains loose coupling →
Grokking Concurrency
Decoupling is a design technique that separates components or responsibilities to reduce their dependencies on one another.
- How it is used
- Uses concurrency as a strategy for dividing functionality and managing complex systems.
- How deep it goes
- Defines component separation and outlines its benefits, but gives no implementation steps.
- What you can do after
- Apply divide and conquer by grouping related code and separating unrelated components.
Also covered in
- ActiveMQ in Action
- The Cloud at Your Service: The when, how, and why of enterprise cloud computing
- Data-Oriented Programming in JavaIn early access (MEAP)
- Simple Object-Oriented Design: Create clean, maintainable applications
- Spring Microservices in Action
- Apache Kafka in Action
- Effective Behavior-Driven DevelopmentIn early access (MEAP)
- Building User-Friendly DSLs
- Prompt Engineering in Practice
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Financial AI in Practice
- Digital Twins in Action
What to know first
- componentA software component is a modular part of a software system that encapsulates related functionality and interacts with other parts through defined boundaries.
- dependencyA dependency is a component, resource, or prerequisite that another software component or activity relies on to function, build, or proceed.
- interfaceAn interface is a contract or boundary that specifies the operations, members, or data shape a type or component exposes, without prescribing its complete implementation.
- business ruleA business rule is a domain-specific constraint, policy, or decision criterion that governs valid data, behavior, decisions, or processes.
Related concepts
- tight couplingcontrasts with · Tight coupling is a design condition in which components have substantial dependencies on one another, such that changes or failures in one can affect others.
- messagingaddressed by · Messaging is a communication approach in which software components exchange information by sending and receiving messages.
- interfaceaddressed by · An interface is a contract or boundary that specifies the operations, members, or data shape a type or component exposes, without prescribing its complete implementation.
- atomicityproduces · Atomicity is the property that an operation or group of operations takes effect as an indivisible whole, without observable partial effects.
- autonomyproduces · Autonomy is the capacity or degree to make decisions and act independently within defined responsibilities and constraints.
- Azure Storage Queuesaddressed by · Azure Storage Queues is a Microsoft Azure service that stores messages in queues for asynchronous communication and processing between application components.
Questions about loose coupling
What is loose coupling?
A design property in which components have limited direct dependencies and can change or operate more independently of one another.
Which Manning books explain loose coupling?
Microservices Patterns, Second Edition, Event Processing in Action, Secrets of the JavaScript Ninja, Second Edition, Spring Start Here, Second Edition, Learn Docker in a Month of Lunches, Second Edition, Microsoft Azure in Action and Grokking Concurrency.
What should I know before learning loose coupling?
Manning books that teach loose coupling usually introduce component, dependency, interface and business rule first.
What is the difference between loose coupling and tight coupling?
A design property in which components have limited direct dependencies and can change or operate more independently of one another. Tight coupling is a design condition in which components have substantial dependencies on one another, such that changes or failures in one can affect others.
What is loose coupling also called?
Loose coupling is also called decoupling or decoupled.
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.






