acosf_finite@GLIBC_2.15 0000000000025630 i __acos_finite@GLIBC_2.15 $ nm --dynamic --defined-only /usr/lib64/libm.so.6 | wc -l 1102 Our executable however, doesn’t define any symbols: $ nm --dynamic --defined-only $(which futile) It expects symbols to be defined by other dynamic libraries it depends on, though! $ nm --dynamic --undefined-only

Rust that leverages io_uring and kTLS, named fluke — work that was sponsored by fly.io, then Shopify. I’ve also open-sourced a lightweight alternative to serde_json called merde_json, a library to enable a particular dynamic linking pattern in Rust, called rubicon, and I’m maintaining what I think is the best Rust zip implementation rc-zip

OPENSSL_DYNAMIC cargo:rerun-if-env-changed=PKG_CONFIG_ALL_STATIC cargo:rerun-if-env-changed=PKG_CONFIG_ALL_DYNAMIC cargo:rerun-if-env-changed=PKG_CONFIG_PATH_x86_64-unknown-linux-gnu cargo:rerun-if-env-changed=PKG_CONFIG_PATH_x86_64_unknown_linux_gnu cargo:rerun-if-env-changed=HOST_PKG_CONFIG_PATH cargo:rerun-if-env-changed=PKG_CONFIG

up a little) that it tries to “patch script interpreter paths”. That’s right, executables are interpreted also, sort of: dynamically-loaded ones need a.. dynamic loader! The kind we built in making our own executable packer. A simple dev shell Before we move on to the more modern stuff, let’s note that derivations aren’t the only thing a

many things. When running executables, a dynamic linker is involved, like we discussed in making our own executable packer. Here it’s definitely a “build-time linker”, but really there’s, I think: a linker driver, and the actual linker. The linker driver, by default here, is cc, which is provided by GCC. It accepts the -fuse-ld=flabazorp

0x1000 DYNAMIC 0x02fe30 0x0000000000030e30 0x0000000000030e30 0x000190 0x000190 RW 0x8 NOTE 0x0002a8 0x00000000000002a8 0x00000000000002a8 0x000040 0x000040 R 0x8 NOTE 0x0002e8 0x00000000000002e8 0x00000000000002e8 0x000024 0x000024 R 0x4 GNU_PROPERTY 0x0002a8 0x00000000000002a8 0x00000000000002a8 0x000040

well I made it play nice with tools like dylo and rubicon, solving issues like “woops, tokio thinks there’s one distinct runtime per dynamic object”. And I was able to ship the software that powers my website, which is called home and is now open-source, by the way, as a collection of dynamic libraries, which was great for fast deploys, since

Won’t that break dynamic linking? Of course it will! And that’s why what we really want, is to be able to conditionally use either static or dynamic linking. One way to do it (which I don’t love, but we make do) is with cargo features! If poppler-sys-rs had a static feature, we could have: // in `poppler-sys-rs/src/lib.rs` #[cfg_attr(feature

so that you could do dynamic dispatch instead of monomorphizing everything. That’s what you call instantiating generic types with concrete types, and that’s what can generate a lot of code and make builds reaaal slow— However, reading this today I realize I just made a shittier version of erased_serde, so… that was a waste of time. facet is

s IP address. So maybe we could figure out a system to attribute human-readable names to some of the nodes in the network. We would call them “domain names”, and the protocol would be named “DNS”, for Domain Name Service. Maybe the IP addresses wouldn’t be static, but instead dynamically assigned, so that the router makes sure every