main() { payload, err := ioutil.ReadFile("/etc/hosts") if err != nil { panic(err) } fmt.Printf("%s\n", string(payload)) } It sure works, but it doesn’t seem to link against libc: $ go build main.go $ ./main | head -3 127.0.0.1 localhost 127.0.1.1 sonic $ ldd main not a dynamic executable ldd is a tool that

rid of dynamic range by taking anything above a certain level and progressively making it smaller: We can apply gain to the resulting signal without clipping, making the whole thing louder. That gain is called “make-up” gain, because it makes up for the loud bits that were made quieter by the compression. I can’t believe that just clicked for

show you how I did it! Nix, but this time for real More nix usage. I still want to do dynamic linking — a debug build of futile sits at >400MB right now. Stripping helps, a lot (so would compressing debug info), and release builds are smaller, especially with opt-level = "s", this is probably more on the C libraries I statically link against

0000000000002000 002000 0001ca 00 A 0 0 16 [ 8] .eh_frame_hdr PROGBITS 00000000000021cc 0021cc 00003c 00 A 0 0 4 [ 9] .eh_frame X86_64_UNWIND 0000000000002208 002208 0000d8 00 A 0 0 8 [10] .tdata PROGBITS 0000000000003f18 002f18 000008 00 WAT 0 0 4 [11] .dynamic DYNAMIC

happening here. So, a compiler like rustc would: need the proc-macro crate to be compiled to a dynamic library before hand (a .so / .dylib / .dll): cargo or some equivalent build tool usually drives that part open the dynamic library find the “registrar symbol”, in our case it was __rustc_proc_macro_decls_e4a0d4906233add5__ cast it to a

the quality output? Does it require dynamic linking? Does it build on all the target platforms that rustdoc supports? The HTML markup for syntax highlighted code is bigger than for non-syntax highlighted code By how much? Can we even afford that? Who’s gonna implement all this? Well! tree-sitter, 96 of them by popular vote, yes, no, yes, not

play nice with each other), and I could link dynamically against libraries, which might speed up the link step and trim down the final executable quite a bit. Also, apparently you can generate Docker images with nix, which sounded great. Success (but at what cost?) with crane So I started learning nix! I learned there’s quite a few ways to build

naughtiest things we did back in Dynamic linker speed and correctness is introduce the Name enum: // in `elk/src/name.rs` #[derive(Clone)] pub enum Name { FromAddr { addr: delf::Addr, len: usize }, Owned(Vec<u8>), } So far it has been… wildly unsafe. The constructor for the FromAddr variant was unsafe: pub unsafe fn from_addr(addr

Rust, they matter very much. You see, the crux of the problem is… You’re smarter than Rust I’m not kidding! This is especially true if you’ve done a lot of dynamic typing / weak typing work. Coming from a language such as Python, Ruby, or JavaScript, you’re used to writing functions that look like this: // (not actually valid Rust) fn

b u fg-cyn"></i> <i class="b fg-red">inet</i> 192.168.1.100/24 brd 192.168.1.255 scope global dynamic noprefixroute enp3s0 <i class="b fg-red">inet6</i> 2a01:e0a:de8:a760:bf51:36ff:d905:1432/64 scope global temporary dynamic <i class="b fg-red">inet6</i> 2a01:e0a:de8:a760:7656:3cff:fe28:5746/64 scope global dynamic mngtmpaddr