Programmer Humor

When a basic dynamic library needs to be updated because, for instance, there is a big security issue, then all your statically linked binaries will have to be updated. Which means every one of those developer teams need to keep track of all the security fixes, release a new version of the binary and push it, and every user will have to download gigabytes and gigabytes of data.

While if you have dynamic libs you only have to download that one, and the fix will be pushed earlier and all the apps will benefit from it.

Did you,... hrm,... did you even take classes about this stuff. Ffs, this is why this career pays well: you have to understand complicated things.

Maybe your issue is with Windows. I suggest moving away from that platform.

Dynamic libraries are essential to computing, and allow us to partition out pieces of the code. One giant library would have to be recompiled with every change.

Shared libraries are not a theoretical good, they have been the backbone of computers for decades and many vendors have successfully maintained ABIs for decades.

Modern languages do the statically compiled solution and it has its own downsides. Makes language bindings hard, no stable ABI means no binary platforms exist (other than awkward C wrappers), rebuilds are slow and OS wide results in a lot of churn, reasoning about security fixes is very hard.

Another advantage: enforced compartmentalization. If you have a single binary, someone will always give in to the temptation to bypass whatever honor policy is keeping your code from becoming spaghetti.

Honestly, I love statically compiled binaries for their simplicity. I was writing a small utility in Rust today and I wanted to share it with a colleague on windows.

One command to cross compile my Linux version to windows version and it worked on first attempt on his computer. To me it's worth giving up a lot of the advantages of shared libraries for that kind of simplicity.

There is no install. There is only run.

Cause statically linked libs can be very large. I agree though , rather have statically linked then dynamic.

No one seems to mention license considerations when talking about static linking. Even if your app is open source, your particular license may not be legally compatible with the GPL, for example. 3BSD, MIT, and Apache most likely don't change in a single binary but it's kind of a new thing that no one was really thinking of before when mixing licenses together.

I think this default okay assumption comes from most developers having a cloud-centric view where there's technically no "distribution" to trigger copyright.

From Ellen Ullman's Close to the Machine:

"The project begins in the programmer's mind with the beauty of a crystal. I remember the feel of a system at the early stages of programming, when the knowledge I am to represent in code seems lovely in its structuredness. For a time, the world is a calm, mathematical place. Human and machine seem attuned to a cut-diamond-like state of grace.

...

Then something happens. As the months of coding go on, the irregularities of human thinking start to emerge. You write some code, and suddenly there are dark, unspecified areas. All the pages of careful documents, and still, between the sentences, something is missing.

Human thinking can skip over a great deal, leap over small misunderstandings, can contain ifs and buts in untroubled corners of the mind. But the machine has no corners. Despite all the attempts to see the computer as a brain, the machine has no foreground or background. It cannot simultaneously do something and withhold for later something that remains unknown[1]. In the painstaking working out of the specification, line by code line, the programmer confronts all the hidden workings of human thinking.

Now begins a process of frustration.

[1] clarifies how multitasking typically works, which was usually just really fast switching at the time of the book.

Because programmers find a good way to do something then apply it to everything. It becomes the one true way, a dogma, a rule. Like how OOP was the best thing ever for everything, and just now 30 years later is proven to be actually bad. At least appimage is more like DOS-s "just unzip and run it" then "download another 500MB of useless stuff because the program depends on 1 20kB file in it".

That said, well made libraries are good. As in those that have a stable API so versions don't matter that much.

Windows shared libs could do with having an rpath equivalent for the host app. I tried to get their manifest doohickeys working for relative locations but gave up and still just ~~splat~~ install them in the exe directory.

Aside from that shared libraries are great. Can selectively load/reload functions from them at runtime which is a fundamental building block of a lot of applications that have things like plugin systems or wrappers for different hardware etc. Good for easier LGPL compliance as well.

There is one case I can think of where statically linked binaries make sense: games. They're almost always closed-source even on otherwise open-source systems, and so cannot be recompiled against newer library versions, and (for smaller indies especially) it isn't unusual for the people who do have the code to close up shop and vanish off the face of the Internet. For those, it honestly is better for them to carry all their libraries around with them, even if it results in some binary bloat.

For open-source software, dynamic linking isn't usually an issue until some piece of software goes unmaintained for so long that it catches bit-rot.

For software not in one of those two categories . . . well, maybe you ought to move off Windows?