Dependency
A dependency is a component, resource, or prerequisite that another software component or activity relies on to function, build, or proceed.
The Art of Unit Testing 3e
An imported or required software component on which a module relies.
- How it is used
- Identifies outside reliance that affects test control, repeatability, and how a unit’s observable effects are verified.
- How deep it goes
- Defines incoming and outgoing roles, then details stubs, mocks, and several injection approaches; treats dependency control as a testing choice.
- Examples
- Uses logger calls, database results, network responses, and a replaceable module-logger object to distinguish effects from supplied inputs.
- What you can do after
- Apply it via Jest or dependency injection to control incoming data, verify required outgoing calls, and judge when real dependencies are worthwhile.
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 →
Build High Value Software Systems
A software component or package that another component requires to build or operate.
- How it is used
- Frames library reuse as a lifetime maintenance decision rather than an automatic shortcut to faster delivery.
- How deep it goes
- Works through value lenses and surface-area trade-offs, then offers specification and review heuristics rather than package-management mechanics.
- Examples
- Contrasts an email-check library with local code and an AI-suggested styling package with existing CSS modules.
- What you can do after
- Evaluate/understand it by justifying package reuse against user benefit, maintenance burden, security exposure, and existing implementation patterns.
Read how Build High Value Software Systems 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
- Uses dependencies to add library and service functionality while addressing deployment consistency and test isolation.
- How deep it goes
- Explains version specifications, installation and mocking rationale, with a distinction between unit and broader tests.
- Examples
- Uses a movie-search backend relying on requests and the TMDB API, plus a requirements.txt listing requests and Streamlit.
- What you can do after
- Apply it via requirements.txt and pip to manage library versions, and use unittest.mock to isolate dependencies in 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 →
Data-Oriented Programming in Java
A dependency is a relationship in which one software element relies on another element's data, behavior, or availability.
- How it is used
- Uses dependency analysis to separate domain decisions from external data retrieval, submission, and infrastructure constraints.
- How deep it goes
- Traces dependencies through inputs, outputs, read/write sources, wrappers, and integration tests rather than treating them as simple object references.
- Examples
- Uses draft building, invoice assessment, billing submission, database access, and task storage as dependency examples.
- What you can do after
- Evaluate dependency behavior by mapping interactions and exercising real databases or services through integration tests.
Read how Data-Oriented Programming in Java 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.
Fast by Default
A dependency is an external software component that another software component requires to build or operate.
- How it is used
- Uses dependency analysis to control build artifact size and distinguish production requirements from development tooling.
- How deep it goes
- Explains accumulation, indirect dependencies, classification, measurement, and removal, but does not detail dependency resolution internals.
- Examples
- Uses a checkout API audit, pipreqs, requirements files, container images, and dependency-size inspection.
- What you can do after
- Diagnose/debug with pipreqs and package-manager reports, remove unused dependencies, and reduce production artifact size.
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 →
The Coder Cafe
A dependency is a requirement that one task, item, or component be completed or available before another can proceed.
- How it is used
- Organizes task execution and evaluates whether service relationships remain safe under failure and changing load.
- How deep it goes
- Explains graph-based ordering, in-degree processing, operational classification, failure modes, and dependency evolution.
- Examples
- Uses job graphs, REST endpoints, databases, RPC calls, caches, traffic growth, and deliberate network failures.
- What you can do after
- Apply topological sort to produce task order and diagnose dependencies that become operationally blocking.
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 →
Vanilla Web
A dependency is an external software component required by an application or another software component to build or operate.
- How it is used
- Frames dependency choice as a trade-off in frontend security, build complexity, and long-term maintenance.
- How deep it goes
- Explains operational consequences of large dependency trees, but does not provide package-selection or auditing procedures.
- Examples
- Uses a malicious or buggy npm dependency, large node_modules caches, package-upgrade demands, and an aging build chain as examples.
- What you can do after
- Evaluate/understand the security and maintenance costs of dependencies when choosing between external packages and browser-native implementations.
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.
Vibe Engineering
A software dependency is a component, package, library, or other resource that another component requires to function correctly.
- How it is used
- Guides dependency review and context preparation before accepting AI-generated code into production.
- How deep it goes
- Traces dependency risks through vulnerabilities, licenses, maintenance, supply chains, necessity, and invisible application context.
- Examples
- Uses npm packages, Snyk, Dependabot, npm audit, license-checker, package registries, and an authentication refactor.
- What you can do after
- Diagnose/debug with it by tracing hidden dependencies and validating necessity, security, licensing, existence, and maintenance.
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 dependency management as production maintenance for digital twins built from independently evolving software and services.
- How deep it goes
- Defines transitive dependencies and gives safeguards for pinning, repositories, inventories, and automated scanning.
- Examples
- Illustrates package disappearance with Faker.js and external data dependence with rainfall forecasts for irrigation.
- What you can do after
- Operate/configure dependency safeguards by pinning versions, using private repositories, maintaining an SBOM, and enabling automated scans.
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 →
Secrets of the JavaScript Ninja, Third Edition
A software component or package that another component requires in order to build or run.
- How it is used
- Supplies reusable third-party functionality to JavaScript projects, commonly managed with Node.js and npm.
- How deep it goes
- Explains npm installation, recursive downloads, and project records; version-range details are deferred.
- Examples
- Installs Express 5 and imports it to serve a greeting at localhost:3000.
- What you can do after
- Apply it via npm to install Express, import it, and run a local HTTP server.
Read how Secrets of the JavaScript Ninja, Third Edition explains dependency →
Grokking Software Architecture
A relationship in which one software component relies on another.
- How it is used
- Uses dependency direction to separate UI commands from business-layer references and dependency injection to improve testability.
- How deep it goes
- Defines dependencies and injection, then works through a database refactor and test using a fake object.
- Examples
- Contrasts a report generator with a hard-coded database connection against one tested with an injected fake database.
- What you can do after
- Apply constructor injection to replace a hard-coded database connection with a fake for isolated tests.
Read how Grokking Software Architecture explains dependency →
Also covered in
- Crack Any Codebase with AIIn early access (MEAP)
- Modern Angular
- Snowflake Data Engineering
- AI for Everyday IT
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
- Cloud Observability in Action
- Pro Angular 16
- Grokking AI Applications
- Julia as a Second Language
- Grokking Web Application Security
- Essential TypeScript 5, Third Edition
- Logs and Telemetry
What to know first
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- moduleA module is a cohesive unit of code or computation that groups related functionality within a larger system and defines a scope or boundary for organizing or sharing it.
Related concepts
- artificial intelligenceincludes · Artificial intelligence is the field of computing concerned with creating systems that perform tasks associated with intelligence, such as learning, reasoning, perception, and decision-making.
- 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.
- transitive dependencyincludes · A dependency is transitive when one item depends on another indirectly through an intermediate item rather than directly.
Questions about dependency
What is dependency?
A dependency is a component, resource, or prerequisite that another software component or activity relies on to function, build, or proceed.
Which Manning books explain dependency?
The Art of Unit Testing 3e, Web Components in Action, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform, Data Pipelines with Apache Airflow, Second Edition, Build High Value Software Systems, Statistics Every Programmer Needs, Build Python Web Apps with Streamlit, Road to Kubernetes and 27 more.
What should I know before learning dependency?
Manning books that teach dependency usually introduce contract, Python, container and module first.
What kinds of dependency are there?
Kinds of dependency include collaborator, artificial intelligence, Django Debug Toolbar, malicious dependency, native dependency and transitive dependency.
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.


































