How deeply does Learn Go with Pocket-Sized Projects cover coupling?

Defines coupling through code that changes together and explains its maintenance tradeoff; it gives no metric for measuring it.

Coupling

As explained in Learn Go with Pocket-Sized Projects

Coupling is the degree to which software components depend on one another and therefore must change together.

Coupling describes how strongly pieces of code depend on one another. Structures and functions that must be updated together are coupled. Spreading them across packages can make code quality harder to maintain, even when the package layout looks tidy. section 8.2.1

> tree
.
├── go.mod
├── internal
│   ├── api
│   │   ├── doc.go
│   │   └── http.go
│   └── handlers
│       ├── doc.go
│       ├── newgame
│       │   └── handler.go
│       └── router.go
└── main.go

The project tree separates the HTTP API, endpoint handler, and router. Use it to ask which files are likely to change together as the new-game endpoint grows. section 8.2.1

There is no fixed rule to put every function in one package or give every function its own. Keep related logic together where practical, consider how each package will grow, and refactor the layout when later changes reveal a poor fit. section 8.2.1

How Learn Go with Pocket-Sized Projects covers it

Cover of Learn Go with Pocket-Sized Projects

liveBook manning.com

Read Learn Go with Pocket-Sized Projects on liveBook Get the book at manning.com

Also explained in

liveBook manning.com

Architecture Modernization: Socio-technical alignment of software, strategy, and structureLoosely coupled software architecture is an architecture in which components or services have limited dependencies and can change with minimal impact on one another.
liveBook manning.com

Practices of the Python ProLoose coupling is a design property in which software components have limited interdependence.
liveBook manning.com

Functional Design and Architecture: Examples in HaskellDecoupling is the reduction of dependencies between software components or language modules so they can change more independently.
liveBook manning.com

Object-Oriented Software Design in C++Loose coupling is a design property in which classes have few dependencies on one another's implementations.
liveBook manning.com

Simple Object-Oriented Design: Create clean, maintainable applicationsCoupling is the degree to which one software component depends on another component.
liveBook manning.com

Software Design for Python ProgrammersLoose coupling is a relationship between software components in which each has few dependencies on the implementation of the others.
liveBook manning.com

ASP.NET Core in Action, 3eLoose coupling is a software design property in which components have limited knowledge of and dependence on one another.
liveBook manning.com

Building User-Friendly DSLsA dependency relationship in which changes to one software component can require corresponding changes to another component.
liveBook manning.com

The Art of CodeCoupling is the degree of interaction or dependency between software components, modules, layers, or classes.
liveBook manning.com

Amazon Web Services in Action, Third Edition: An in-depth guide to AWSDecoupling is the architectural separation of components so they communicate through an intermediary or interface rather than depending directly on each other.
liveBook manning.com

100 Go Mistakes and How to Avoid ThemA software design technique that reduces direct dependencies between components so implementations can change independently.
liveBook manning.com

API Design PatternsLoose coupling is a design property in which components depend on one another through limited, stable contracts and can change independently.
liveBook manning.com

Unit Testing Principles, Practices, and PatternsTight coupling is a design condition in which software components depend strongly on one another.
liveBook manning.com

Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and TerraformCoupling is the degree of dependency between software components or services.
liveBook manning.com

Effective Platform EngineeringLoose coupling is an architectural property in which components or domains interact with minimal dependency on one another's internal details.
liveBook manning.com

Python How-ToLoose coupling is a software design condition in which components have minimal dependencies on one another's implementation details.

Compare how 17 books explain coupling →

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.
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 design principle in which high-level policy and low-level implementation depend on abstractions rather than directly on each other.
encapsulationaddressed by · Encapsulation is a software design principle that contains state and implementation details behind a controlled interface, limiting direct access from outside.

This explainer was generated by Manning's knowledge graph from the text of Learn Go with Pocket-Sized Projects. The section links point to the parts of the book it draws on.