Dependency
A software dependency is a component, resource, or prerequisite on which another software component or operation relies to function or proceed.
The Art of Unit Testing 3e
An imported or required software component on which a module relies.
- How it is used
- Uses dependencies to define test boundaries, exit points, and isolation choices.
- How deep it goes
- Defines dependency types, test doubles, injection seams, maintainability trade-offs, and flaky-test responses.
- Examples
- Uses a logger in password verification, database and network calls, file contents, clocks, and UI component tests.
- What you can do after
- Diagnose/debug with dependencies by classifying their direction, selecting stubs or mocks, and reducing flaky moving parts.
Web Components in Action
- How it is used
- Organizes how Web Components and projects obtain the components, libraries, stylesheets, or packages they need.
- How deep it goes
- Works through HTML reference lists, module imports, and package tracking; defers managing HTML and CSS with modules.
- Examples
- Uses a photo carousel with script and stylesheet references, a nested Web Harp component tree, and npm package examples.
- What you can do after
- Build from scratch a Web Harp application whose components import their JavaScript dependencies.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A requirement that one infrastructure resource be created, configured, or available in relation to another resource.
- How it is used
- Uses dependencies to sequence infrastructure changes, decouple modules, test interfaces, troubleshoot failures, and avoid unsafe deletion.
- How deep it goes
- Explains definitions, parameterization, injection, testing, refactoring, deployment sequencing, and diagnosis, but stops short of formal dependency algorithms.
- Examples
- Uses network-server provisioning, service-account authentication, module contracts, blue-green networks, monolith refactoring, and unused-resource deletion.
- What you can do after
- Diagnose with dependency graphs, parameterize infrastructure inputs, test module contracts, sequence changes, and remove resources more safely.
Data Pipelines with Apache Airflow, Second Edition
A software dependency is an external package or component required by software for installation or execution.
- How it is used
- Identifies packages and components needed by Airflow operators and task code, especially when deciding where tasks should run.
- How deep it goes
- Explains shared-environment conflicts and per-task image isolation, including image-maintenance costs; stops short of a package-installation walkthrough.
- Examples
- Uses requests for HTTP, MySQL components for database access, and pandas or scikit-learn for machine-learning tasks.
- What you can do after
- Operate/configure it by placing task requirements in shared Airflow environments or isolated Docker images while accounting for conflicts and maintenance.
Read how Data Pipelines with Apache Airflow, Second Edition explains dependency →
Statistics Every Programmer Needs
A project dependency is a relationship between activities in which one activity cannot begin until one or more preceding activities are completed.
- How it is used
- Structures project planning by sequencing activities and supporting critical-path analysis.
- How deep it goes
- Defines precedence relationships, then applies forward and backward passes, slack calculations, and programmatic validation.
- Examples
- Uses an automated reporting-tool WBS, network diagram, schedule table, and Python CPM implementation.
- What you can do after
- Apply it via pandas and NumPy to calculate schedules, slack, and critical activities.
Read how Statistics Every Programmer Needs explains dependency →
Build Python Web Apps with Streamlit
An external dependency is software or a remote service outside a component's implementation that the component relies on for functionality.
- How it is used
- Supports app features through third-party libraries and APIs while creating deployment and testing responsibilities.
- How deep it goes
- Explains library version management and dependency isolation in unit tests; leaves external-component failures to integration and end-to-end tests.
- Examples
- Uses a to-do app's requirements.txt and a movie-search component that calls requests and the TMDB API.
- What you can do after
- Operate/configure Python dependencies for deployment and diagnose/debug component behavior by mocking external dependencies in unit tests.
Read how Build Python Web Apps with Streamlit explains dependency →
Road to Kubernetes
An application dependency is an external library, service, runtime, or other component required by an application.
- How it is used
- Frames deployment as the progressive identification, isolation, packaging, and automation of application requirements.
- How deep it goes
- Defines dependency categories and demonstrates installation, tracking, and container packaging, while deferring intricate Dockerfile complexity.
- Examples
- Uses FastAPI, MoviePy, Python requirements.txt, Node.js package.json, virtual environments, and a Python Dockerfile as concrete dependency examples.
- What you can do after
- Operate/configure repeatable Python and Node.js environments, then package their system and project dependencies into Docker images.
Simple Object-Oriented Design: Create clean, maintainable applications
A dependency is a relationship in which one software component relies on another component whose changes may affect it.
- How it is used
- Frames class design as controlling coupling and change propagation over time.
- How deep it goes
- Explains dependency risks, information hiding, class decomposition, and third-party wrappers without prescribing a universal architecture.
- Examples
- Uses Basket with DiscountRules, Product, Customer, and repositories, plus a payment gateway wrapped by an adapter.
- What you can do after
- Evaluate and reshape class and external-library dependencies to contain change and improve maintainability.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A software dependency is an external component, package, or service required by a project or application to build or operate correctly.
- How it is used
- Manages libraries, provider plugins, and upstream services needed to build, start, and operate applications.
- How deep it goes
- Explains declaration, installation, version pinning, environment configuration, and service-health handling without detailing package-resolution internals.
- Examples
- Uses Node.js package files, npm commands, an Azure Terraform provider, RabbitMQ, and Kubernetes readiness and liveness probes.
- What you can do after
- Operate projects reproducibly by installing dependencies, pinning versions, configuring services, and diagnosing unavailable upstream systems.
Unit Testing Principles, Practices, and Patterns
A dependency is a component, object, service, or value that code under test relies on.
- How it is used
- Frames dependency choices as an isolation and test-maintainability decision.
- How deep it goes
- Classifies dependencies by mutability and sharing, then contrasts substitution with explicit injection.
- Examples
- Uses a mutable Store, immutable Product values, a mocked purchase collaborator, and an injected date-time service.
- What you can do after
- Apply it via explicit dependency injection and selective test doubles while preserving immutable values as real collaborators.
Read how Unit Testing Principles, Practices, and Patterns explains dependency →
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A dependency is a reliance in which one software, organizational, or architectural element requires another to function or change successfully.
- How it is used
- Uses dependencies to connect architectural change, organizational coordination, and the ability of teams to sustain fast flow.
- How deep it goes
- Explains dependency effects through coevolution and team examples, but stops short of prescribing a universal restructuring method.
- Examples
- Illustrates dependencies through self-scanning checkouts, remote collaboration, higher-order systems, and a logistics company’s multiproduct teams.
- What you can do after
- Diagnose/debug with it: identify costly dependencies, clarify shared priorities, and test whether boundary changes improve team flow.
Go in Practice, Second Edition
A dependency is a software package or module required by another package or module.
- How it is used
- Manages third-party packages during development and detects missing runtime dependencies in deployed environments.
- How deep it goes
- Defines dependencies, demonstrates runtime availability checks, and gives commands for version updates and transitive dependency inspection.
- Examples
- Demonstrates third-party packages, the fortune executable, go get, go mod tidy, and go mod graph.
- What you can do after
- Diagnose missing executables and operate Go module versions with go get, go mod tidy, and go mod graph.
Read how Go in Practice, Second Edition explains dependency →
Get Programming: Learn to code with Python
Task dependency is a relationship in which one task cannot begin until another task has completed.
- How it is used
- Organizes larger tasks into subtasks by identifying which actions must wait for others.
- How deep it goes
- Defines dependency and independence, then traces prerequisites through an online-order workflow without showing code.
- Examples
- Uses an online order to show dependent and independent subtasks, and asks readers to classify everyday situations.
- What you can do after
- Evaluate task order by identifying which subtasks require earlier tasks to finish.
Read how Get Programming: Learn to code with Python explains dependency →
Object-Oriented Software Design in C++
- How it is used
- Explains how class relationships create change risk and guides designs toward loose coupling.
- How deep it goes
- Defines dependency types, UML notation, transient duration, and coupling consequences, but stops short of external package or service management.
- Examples
- Uses Car and Driver code, Catalogue and Attributes classes, UML arrows, member variables, parameters, and local references.
- What you can do after
- Evaluate class designs by identifying dependency direction, duration, coupling, and implementation details exposed across interfaces.
Read how Object-Oriented Software Design in C++ explains dependency →
Kubernetes for Developers
An external dependency is a separately running service or resource that an application requires to perform some operations.
- How it is used
- Packages application requirements into container images and governs readiness checks for separately running services.
- How deep it goes
- Defines dependency installation and probe behavior with examples, but stops short of detailing dependency management beyond Docker builds and health checks.
- Examples
- Uses Python and Ruby images, a MariaDB client, Unicode fonts, and a database-backed readiness query.
- What you can do after
- Build it from scratch by installing required packages into an image and designing readiness checks that reflect external-service availability.
Think Like a Software Engineering Manager
A condition in which one team, system, or piece of work relies on another to proceed or function.
- How it is used
- Coordinate cross-team work by making dependencies visible in communication plans, road maps, and project timelines.
- How deep it goes
- Shows dependencies through practical scenarios involving timeline alignment, road-map negotiation, and communication planning.
- Examples
- Uses a frontend team blocked by backend work and a platform team coordinating with a royalty team.
- What you can do after
- Practice managing dependencies by aligning estimates, enabling parallel tasks, documenting decisions, and making a business case for road-map changes.
Read how Think Like a Software Engineering Manager explains dependency →
Secrets of the JavaScript Ninja, Second Edition
A module or component that another module requires in order to function correctly.
- How it is used
- Declares which modules a JavaScript module requires and supplies them for its implementation.
- How deep it goes
- Compares AMD and CommonJS dependency declarations and loading, but defers setup and project integration.
- Examples
- Uses a click-counting module that depends on jQuery, shown with AMD and CommonJS declarations.
- What you can do after
- Apply dependencies via AMD define or CommonJS require to obtain modules for use in a module.
Read how Secrets of the JavaScript Ninja, Second Edition explains dependency →
F# in Action: A Revised Edition of Get Programming with F#
An external dependency is a system or service outside an application that its code relies on, such as a database or web service.
- How it is used
- Separates business logic from databases, web services, consoles, and filesystems to improve testing and implementation flexibility.
- How deep it goes
- Explains dependency coupling through ATM and order-processing examples, but stops short of prescribing one universal abstraction technique.
- Examples
- Uses ATM messages, logging, order validation, database loading, order dispatch, and connection-string threading as concrete examples.
- What you can do after
- Apply it by separating testable logic from I/O and supplying real or substitute implementations at the application boundary.
Read how F# in Action: A Revised Edition of Get Programming with F# explains dependency →
The Art of Code
A dependency is a software component or relationship that another component relies on to function.
- How it is used
- Manages packaged application size and helps isolate failures involving external systems.
- How deep it goes
- Explains cleanup, build exclusion, tree shaking, and evidence gathering, but stops short of dependency implementation internals.
- Examples
- Uses Maven and Gradle trees, npm packages, tree shaking, and a web-form failure traced through an HTTP 500 and backend logs.
- What you can do after
- Diagnose/debug with traces and logs, and operate/configure packages by removing unnecessary dependencies and production-excluded files.
Elixir in Action, Third Edition
A dependency is a component, resource, or prerequisite that another software component relies on.
- How it is used
- Manages external libraries and application requirements while assembling production-oriented Elixir systems.
- How deep it goes
- Explains declaration, version requirements, fetching, locking, compilation, and transitive resolution without detailing resolver internals.
- Examples
- Uses Poolboy, plug_cowboy, mix.exs declarations, mix deps.get, mix compile, and mix.lock.
- What you can do after
- Operate and configure dependencies through mix.exs, Mix commands, Hex, and a committed mix.lock file.
Read how Elixir in Action, Third Edition explains dependency →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A dependency is a prerequisite relationship requiring one infrastructure action or object to exist before another can proceed.
- How it is used
- Orders Terraform resource operations and groups repeatable Make commands behind prerequisite targets.
- How deep it goes
- Defines directed acyclic dependencies, explains attribute links and cycle failures, and demonstrates target prerequisites without detailing graph algorithms.
- Examples
- Uses Terraform resource relationships and a Makefile whose chores target depends on format and document.
- What you can do after
- Diagnose Terraform cycle failures and configure Make targets that run prerequisite commands in a repeatable order.
Go by Example
A software dependency is an external component or runtime resource required by a program to function.
- How it is used
- Uses dependency injection to decouple command-line logic from operating-system globals and make behavior testable.
- How deep it goes
- Explains dependency grouping, abstraction, explicit injection, and testing, while stopping short of broader dependency-management tooling.
- Examples
- Demonstrates env, io.Writer, command-line arguments, strings.Builder, os.Exit, and a refactored run function.
- What you can do after
- Apply it via dependency injection to build Go functions that accept replaceable resources and can be tested without global state.
.NET in Action, Second Edition
A dependency is an external software component required by an application or another software component.
- How it is used
- Frames dependencies as testing constraints and as runtime requirements to specify for containerized deployment.
- How deep it goes
- Explains test substitution and container-based dependency control through practical examples, without detailing dependency implementation.
- Examples
- Uses file and console side effects, ASP.NET Core components, and a .NET Framework path-length mismatch to illustrate dependency concerns.
- What you can do after
- Evaluate testing and deployment risks arising from external dependencies and machine-specific runtime differences.
Read how .NET in Action, Second Edition explains dependency →
Learn Go with Pocket-Sized Projects
A dependency is an external component or service that a program component requires to perform its work.
- How it is used
- Separates exchange-rate retrieval from money conversion so applications can choose, replace, or test the data provider.
- How deep it goes
- Explains external resources, inversion of control, local interfaces, stubs, error propagation, and nil-pointer failure.
- Examples
- Uses a European Central Bank client, a local exchangeRates interface, a stubRate test double, and a nil-pointer panic.
- What you can do after
- Build it from scratch by defining a consumer-owned interface, injecting an implementation, stubbing it in tests, and propagating errors.
Read how Learn Go with Pocket-Sized Projects explains dependency →
Digital Twins in Action
A software dependency is a library, package, service, or runtime required by another software component.
- How it is used
- Frames libraries, cloud services, and runtimes as independently changing parts of a production digital twin.
- How deep it goes
- Explains transitive dependencies and operational safeguards, but does not provide package configuration or scanning commands.
- Examples
- Uses the Faker.js removal to illustrate build failures and a weather API to illustrate an external data source.
- What you can do after
- Operate/configure dependency safeguards using pinned versions, private repositories, SBOMs, and Dependabot or Renovate.
The Quick Python Book, Fourth Edition
A software dependency is an external software component or prerequisite that an application or package needs to build or operate.
- How it is used
- Supports extending Python programs with specialized libraries, modules, and frameworks beyond the standard library.
- How deep it goes
- Explains discovery, installation, importing, dependency resolution, version constraints, and package trade-offs without detailing dependency internals.
- Examples
- Demonstrates installing, upgrading, and version-pinning requests with pip, including Colaboratory command syntax.
- What you can do after
- Apply dependencies via pip by installing packages, upgrading them, and specifying acceptable or exact versions.
Read how The Quick Python Book, Fourth Edition explains dependency →
Rust in Action: Systems programming concepts and techniques
A dependency is an external software package required by a project.
- How it is used
- Uses external crates to extend a Rust project beyond its built-in code.
- How deep it goes
- Explains declaration, downloading, compilation, and build artifacts, but stops short of dependency-resolution internals.
- Examples
- Demonstrates dependencies through the regex crate in the grep-lite project and Cargo's compilation output.
- What you can do after
- Apply it via Cargo by adding a crate, building the project, and using the third-party functionality.
Read how Rust in Action: Systems programming concepts and techniques explains dependency →
Related concepts
- Django Debug Toolbarincludes · Django Debug Toolbar is a Django add-on that displays diagnostic information about request processing, performance, and resources used to generate a response.
- artificial intelligenceincludes · Artificial intelligence is the field concerned with creating computational systems that perform tasks associated with human intelligence, such as learning, reasoning, perception, or decision-making.
- transitive dependencyincludes · A transitive dependency is a dependency reached indirectly through one or more intermediate dependencies rather than declared or connected directly.
- mockingused by · Mocking is a testing technique that replaces a real dependency with a controlled substitute to simulate behavior or inspect interactions.
- couplingaddressed by · Coupling is the degree of dependency between software components, including how their behavior, availability, or changes affect one another.
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.