Dynamic Linking

I tend to think the drawbacks of dynamic linking outweigh the advantages for many (most?) applications.” – John Carmack

All the purported benefits of dynamic linking (aka., ‘shared libraries’, which is a misnomer as static linking also shares libraries) are myths while it creates great (and often ignored) problems.

Both performance and security are seriously harmed by dynamic linking, but the damage caused by the huge complexity created by dynamic linking is extensive in almost all areas (the term ‘dll hell’ is just one example of the many hells created in dynamic linking environments).

And versioning symbols only bring you to a deeper level of hell.

From: Rob Pike <robpike@gmail.com>
Subject: mmap and shared libraries
Date: Wed, 5 Nov 2008 17:23:54 -0800

When Sun reported on their first implementation of shared libraries,
the paper they presented (I think it was at Usenix) concluded that
shared libraries made things bigger and slower, that they were a net
loss, and in fact that they didn't save much disk space either.  The
test case was Xlib, the benefit negative. But the customer expects us
to do them so we'll ship it.

So yes, every major operating system implements them but that does not
mean they are a good idea.  Plan 9 was designed to ignore at least
some of the received wisdom.

-rob

From: Geoff Collyer <geoff@collyer.net>
To: 9fans
Subject: Virtual memory & paging
Date: Mon, 4 Feb 2002 02:38:16 -0800

There isn't a copy of the entire C library in every binary.  There is
a copy of each library routine called, directly or indirectly, by the
program in question.

Sharing of instructions is done at the granularity of process text
segments, as in V6 or V7 Unix.  The text segment of a process that
forks is shared between parent and child by page mapping.  Also,
running (via exec) a program multiple times concurrently causes the
(pure) text segment to be shared by page mapping across those
processes.  So all copies of rc and on a machine should share a text
segment.

Given that degree of sharing, the low cost of RAM, and the increase in
OS complexity, slowness and insecurity in the implementations of
dynamic libraries that I've seen, I don't see a need for dynamic
libraries.  (Remember that the real impetus for adding them to Unix
was X11 and its big and badly-factored libraries, which most of us
aren't blessed with.)  My terminal has 115 processes; all but 4 of
them share their text segment with at least one other process, usually
more.  74 of them are instances of rio, Mail, rc, acme, listen,
plumber and samterm.  A CPU server has 141 processes; all but 2 share
text.  80 of them are listen, another 21 are rc, exportfs, kfs, dns
and consolefs.  A quick sampling suggests that Plan 9 programs are
typically smaller than FreeBSD/386 programs even with shared
libraries.  Here are some FreeBSD sizes:

: unix; size /bin/cat /bin/ed /usr/bin/awk /usr/X11/bin/sam
   text    data     bss     dec     hex filename
  54188    4324    9760   68272   10ab0 /bin/cat
 122835    8772   81920  213527   34217 /bin/ed
 135761    4772   15756  156289   26281 /usr/bin/awk
  52525    1412   53448  107385   1a379 /usr/X11/bin/sam

Of those, awk and sam use shared libraries.  The corresponding Plan 9
sizes are:

; cd /bin; size cat ed awk sam
15996t + 2208d + 944b = 19148   cat
45964t + 4212d + 41232b = 91408 ed
114731t + 35660d + 12040b = 162431  awk
86574t + 7800d + 66240b = 160614    sam

and the Plan 9 programs cope with Unicode and UTF.

<btdn> I never, for the life of me, understand why people like dynamic linking.
<aiju> btdn: for the very same reason they believe in god

vadaszi:

            I request dlopen() to be added to the 'harmful' list, since it
            breaks the assumptions of static linking (e.g. you expect the
            binary to be portable across linux distributions, but by using
            dlopen() some weird assertion break the binary when using a
            differeng glibc version).  Happened to me when using the ghc
            haskell compiler, even statically linked binaries won't work
            across linux distributions or glibc versions.

Links