Tag
dependency-resolution
- Oct 16, 2026 Minimal Version Selection and Its Compatibility Assumption How Go chooses the maximum of declared minimum versions, why that rule needs no backtracking, and what an ecosystem gives up when its requirement language has no upper bounds. developer tools
- Jul 27, 2026 Resolution as Constraint Search: Why Dependency Solving Is NP-Hard How a resolver chooses versions for a whole graph at once, why the general problem resists polynomial algorithms, and which practical strategies keep real graphs solvable. software engineering
- Jul 21, 2026 Vendored Source Trees and Offline Artifact Mirrors How copying dependencies into the repository changes the resolution problem, what it costs in update latency and duplication, and how mirrors extend the same idea to binary artifacts. language runtimes
- May 16, 2026 Lockfiles: Recording the Resolved Graph Without Re-Resolving It What a lockfile stores beyond version numbers, how it stays consistent with the manifest, and why regeneration is a different operation from installation. software engineering
- Dec 19, 2025 Conflict-Driven Backtracking in Dependency Resolution How a resolver learns from failure instead of retrying every combination, using incompatibilities, unit propagation, and backjumping to the decision that actually caused the conflict. developer tools
- Dec 5, 2025 How Dependency Resolvers Turn Version Ranges into a Fixed Graph A manifest states constraints, not versions. Resolution is a search over the version space, and the lockfile is the memoized answer that makes a build repeatable. security
- Oct 6, 2025 Dependency Resolution as Backtracking Search Over Version Sets Why choosing the newest version of each dependency in turn fails, how resolvers represent partial assignments, and what conflict-driven backjumping buys over chronological backtracking. language runtimes
- Jul 29, 2025 Lockfiles and How a Version Range Becomes a Tree Why a range in a manifest is not a pin, what a lockfile records that the manifest cannot, and how resolvers settle or fail on conflicting requirements. devops
- Feb 14, 2025 Diamond Dependencies and Duplicate Versions What happens when two packages require incompatible versions of a third, why some installers keep both copies, and what duplication costs in type identity, disk space, and patch coverage. developer tools
- Nov 14, 2024 Lockfiles, Hash Pinning, and Reconstructed Environments How a resolved dependency graph is recorded with content hashes, what the installer guarantees on a rebuild, and where the reconstruction stops being faithful. scientific computing
- Sep 26, 2024 Dependency Resolution and Partial Upgrades Why installing one package can remove another, how versioned dependencies and library sonames constrain an upgrade, and what differs between upgrade commands. devops
- Aug 12, 2024 Version Precedence and the Semantics of Range Operators How version strings are ordered, why caret and tilde ranges expand the way they do, and where precedence rules diverge between ecosystems badly enough to change an install. language runtimes
- Feb 3, 2024 Lockfiles as Reproducibility Contracts and Why They Drift What a lockfile must record to make an install repeatable, which inputs it cannot capture, and how lockfiles fall out of sync with manifests without either side being wrong. language runtimes
- Nov 7, 2023 Peer Requirements and the Problem of Straddling Two Majors Why some dependencies must be singletons supplied by the consumer, what happens when a package is asked to support two incompatible majors at once, and how the constraint is expressed. software engineering
- Sep 27, 2023 Version Ranges as Sets of Versions How a constraint such as ^1.2.3 becomes an explicit set of admissible versions, how two constraints intersect, and why prerelease rules stop that set from being an interval. developer tools
- Aug 4, 2023 Dependency Resolution as a Satisfiability Problem How version selection encodes into boolean clauses, why the decision problem is NP-complete, and what that bound predicts about real installs and about optimisation criteria. developer tools
- Jul 11, 2023 Registry Index Metadata and Resolution Without Downloading Artifacts How registries expose version lists, dependency metadata, and hashes as separate resources, and why fetching full archives during resolution is a design error. language runtimes
- Jun 23, 2023 What a Lockfile Records and What It Leaves Out How a lockfile turns one resolution result into an artifact the installer can consume without a solver, which facts it must store, and how an install checks that it still matches the manifest. developer tools
- Jan 27, 2023 When One Graph Contains Several Copies of the Same Package How flat installation trees force duplicate versions into a single directory, what breaks when two copies coexist, and how hoisting decides which copy a require call finds. software engineering
- Dec 15, 2022 Building the Dependency Graph from Manifests Why a manifest describes requirements rather than edges, how node identity is decided, which dependency kinds the walk follows, and why the graph only exists after versions are chosen. developer tools