Dependency hell, however, can result from installing a package directly via a package installer (e.g. This is the case with current releases of Debian and major derivatives such as Ubuntu. APT), but this is unlikely since major package managers have matured and official repositories are well maintained. Package manager dependencies It is possible for dependency hell to result from installing a prepared package via a package manager (e.g. The usual solution is to download and deploy both applications, sometimes from within a temporary environment. Due to incorrect library (B) version, the package manager (A) is now broken- thus no rollback or downgrade of library (B) is possible. ![]() Its impact can be quite heavy, if it affects core systems or update software itself: a package manager (A), which requires specific run-time library (B) to function, may brick itself (A) in the middle of the process when upgrading this library (B) to next version. Circular dependencies If application A depends upon and can't run without a specific version of application B, but application B, in turn, depends upon and can't run without a specific version of application A, then upgrading any application will break another. If this happens, the user will be prompted to uninstall all those packages. the GNU C Library), on which thousands of packages depend. A problem on Linux systems with installing packages from a different distributor (which is not recommended) is that the resulting long chain of dependencies may lead to a conflicting version of the C standard library (e.g. ![]() Alternatively, the existing dependency, along with all software that depends on it, must be uninstalled in order to install the new dependency. When possible, this is solved by allowing simultaneous installations of the different dependencies. If app1 depends on libfoo 1.2, and app2 depends on libfoo 1.3, and different versions of libfoo cannot be simultaneously installed, then app1 and app2 cannot simultaneously be used (or installed, if the installer checks dependencies). Conflicting dependencies Solving the dependencies for one software may break the compatibility of another in a similar fashion to whack-a-mole. Other than being a hassle (to resolve all the dependencies manually), manual resolution can mask dependency cycles or conflicts. ![]() These long chains of dependencies can be solved by having a package manager that resolves all dependencies automatically. Sometimes, however, during this long chain of dependencies, conflicts arise where two different versions of the same package are required (see conflicting dependencies below). This is distinct from "many dependencies" if the dependencies must be resolved manually, e.g., on attempting to install app, the user is prompted to install liba first and on attempting to install liba, the user is then prompted to install libb, and so on. Long chains of dependencies If app depends on liba, which depends on libb. This is a particular problem if an application uses a small part of a big library (which can be solved by code refactoring), or a simple application relies on many libraries. This is partly inevitable an application built on a given computing platform (such as Java) requires that platform to be installed, but further applications do not require it. It can also be difficult to locate all the dependencies, which can be fixed by having a repository (see below). Many dependencies An application depends on many libraries, requiring lengthy downloads, large amounts of disk space, and being very portable (all libraries are already ported enabling the application itself to be ported easily). This, in turn, may break other dependencies and push the problem to another set of packages. If the shared package or library can only be installed in a single version, the user may need to address the problem by obtaining newer or older versions of the dependent packages. ![]() The dependency issue arises when several packages have dependencies on the same shared packages or libraries, but they depend on different and incompatible versions of the shared packages. Colloquial term for software requiring many conflicting dependenciesÄependency hell is a colloquial term for the frustration of some software users who have installed software packages which have dependencies on specific versions of other software packages.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |