Dependency management
Dependency management is the practice of declaring, resolving, versioning, obtaining, updating, and controlling the software components required by a project.
Go in Practice, Second Edition
Dependency management is the process of declaring, resolving, obtaining, and maintaining software components required by an application.
- How it is used
- Supports application development by managing packages and local or external dependencies within the Go toolchain.
- How deep it goes
- Explains import names, grouping, package prefixes, and compile-time motivation, but does not detail dependency version resolution or maintenance.
- Examples
- Uses fmt.Println, grouped standard-library and external imports, and the `go get ./...` command.
- What you can do after
- Apply it via go mod and package imports to work with standard-library, local-module, and external packages.
Read how Go in Practice, Second Edition explains dependency management →
Spring in Action, Sixth Edition
Dependency management is the practice of declaring, resolving, and controlling the external libraries required by an application.
- How it is used
- Declares and controls application libraries in a Maven-based Spring Boot project.
- How deep it goes
- Explains parent-managed versions, declared dependencies, and starter transitivity without detailing conflict-resolution procedures.
- Examples
- Uses a generated pom.xml containing Web, Thymeleaf, DevTools, and testing dependencies.
- What you can do after
- Operate Maven dependency configuration by declaring starters and inheriting versions from Spring Boot’s parent POM.
Read how Spring in Action, Sixth Edition explains dependency management →
Simple Object-Oriented Design: Create clean, maintainable applications
Dependency management is the discipline of controlling relationships among software components so that changes remain localized and maintainability is preserved.
- How it is used
- Frames maintainability work around limiting coupling and preventing changes from rippling through object-oriented systems.
- How deep it goes
- Explains coupling, transitive change effects, information hiding, and practical questions for choosing stable abstractions.
- Examples
- Uses Basket, Product, Customer, DiscountRules, and DiscountRepository to illustrate direct and transitive change propagation.
- What you can do after
- Apply it to reduce unnecessary dependencies, conceal volatile details, and assess the change risk of class relationships.
Go in Action, Second Edition
Dependency management is the process of declaring, resolving, versioning, and obtaining software components required by a project.
- How it is used
- Organizes separately managed Go modules so shared definitions and implementations can support services without tight coupling.
- How deep it goes
- Explains module initialization, requirement updates, version selection, transitive dependencies, and checksum verification without detailing resolver internals.
- Examples
- Uses go mod init, go get, go mod tidy, go.mod requirements, and go.sum checksum entries.
- What you can do after
- Operate Go's module tooling to declare, fetch, update, verify, and reproduce project dependencies.
Read how Go in Action, Second Edition explains dependency management →
Code Like a Pro in Rust
Package and dependency management is the practice of declaring, resolving, retrieving, and maintaining software packages and their dependencies.
- How it is used
- Uses Cargo to declare and obtain third-party crates instead of manually integrating libraries and build systems.
- How deep it goes
- Explains registry rationale, Cargo.toml declarations, cargo add, and SemVer ranges, but does not detail lockfiles or resolution internals.
- Examples
- Demonstrates rand through Cargo.toml, cargo add, and a SemVer operator comparison table.
- What you can do after
- Operate/configure Cargo by declaring crates and selecting compatible dependency version ranges.
Read how Code Like a Pro in Rust explains dependency management →
Related concepts
- container imageaddressed by · A container image is a packaged filesystem and configuration artifact from which a container can be created and run.
- dependencyuses · A software dependency is a component, resource, or prerequisite on which another software component or operation relies to function or proceed.
- lock fileuses · A lock file records resolved dependency versions and related metadata so a package manager can reproduce a project's dependency installation.
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.