Am 17.02.21 um 23:40 schrieb L A Walsh:
Back when disks were sized in MB, I was more
concerned about that.
However it doesn't seem to be an issue on today's disks.
You might not be concerned, but others perhaps don't want to carry every
version of every library that ever existed.
Why would 1 program load two or more versions?
Transitive dependencies: libraries might load other libraries. That's a
real thing, especially in packaging ecosystems where version-locked
dependencies are the norm.
In Tumbleweed I sometimes had issues with KDevelop after major LLVM
updates: the application itself uses libLLVM.so via libclang-cpp.so, but
since it's a GUI program it also uses Mesa, which will (depending on
your graphics card) also sometimes load libLLVM.so. Now if KDevelop and
Mesa were compiled against different versions of LLVM you'd observe
strange behavior right up to crashes.
The program binds with the lib it was built against in
a similar way as
binding with a static lib, but if that library is already installed, on a
given machine, it can be shared with other programs that use the same
Which sadly is unlikely to happen if everybody just happens to link with
the library that was current when they started writing their code.
Ultimately MS uses GUID's for describing uniq
libraries. I've never
heard of a program binding to 2 different libraries, but that seems like
some sort of quantum binding where something can be 2 things at once. But
once the program binds, it decays into 1 fixed state, no?
In all fairness, Windows has a much smaller set of "system" libraries.
Many libraries are just vendored into applications, so every application
has their private version of them. The application itself and the
libraries it uses are then typically build against a consistent snapshot
of the system libraries, so you probably don't need to mix versions.
Satisfying dependencies within 1 daily TW release is 1
thing, but I'm
talking about satisfying dependencies for all programs the user has built
or installed during the life of the OS's installation on the machine.
If you're installing something, you're hopefully doing so via zypper and
then you'll get updates. (As long as the package is maintained.)
If you build something yourself, then indeed required libraries could
one day disappear from the repositories. But not necessarily from your
system. The soname of a library is often part of the package name and so
multiple versions can happily coexist, and you should be able to keep
them as long as you need.
I shouldn't have to wipe my machine's OS
during it's lifetime
unless there is a problem, but given that I build my own packages and
rebuild my own versions of some from included sources, that means there
are dependencies on my machine for some library versions that wouldn't
be listed in a repository's manifest.
Perhaps you should use "osc build" for your own packages? That builds in
a chroot making sure you're only using the packages you have declared.