liveBook · Manning

Dependency

A dependency is a component, resource, or prerequisite that another software component or activity relies on to function, build, or proceed.

How 35 Manning books explain it

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.

Read how The Art of Unit Testing 3e explains dependency →

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.

Read how Web Components in Action explains dependency →

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.

Read how Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform explains dependency →

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.

Read how Road to Kubernetes explains dependency →

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.

Read how Simple Object-Oriented Design: Create clean, maintainable applications explains dependency →

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.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains dependency →

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.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains dependency →

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.

Read how Fast by Default explains dependency →

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.

Read how Kubernetes for Developers explains dependency →

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.

Read how The Coder Cafe 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 →

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.

Read how Vanilla Web 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.

Read how The Art of Code explains dependency →

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.

Read how Vibe Engineering explains dependency →

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.

Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains dependency →

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.

Read how Go by Example explains dependency →

.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.

Read how Digital Twins in Action explains dependency →

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

What to know first

Related concepts

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.