cargo-mutants VS outrun

Hi Rusty!

For a later hack in the same vein, check out https://github.com/sourcefrog/cargo-mutants

cargo-mutants got a couple of releases over the weekend, fixing some environment-triggered bugs on Windows and Linux ecryptfs, and adding a better overall progress indicator (demo: https://asciinema.org/a/481375). It is getting better at avoiding uninteresting or pointless mutations, although there's a lot more to do there, and at printing function name paths well.

While working on Conserve and cargo-mutants I felt that existing Rust progress-bar libraries like Indicatif didn't give me enough control of how the bar was drawn, or at least I was working around them to insert my own text. For example, I wanted to draw several counters into a single line, and it seems like the only way to do that is to just push in a text string.

Continuing with some fast-follow enhancements in cargo-mutants in response to user feedback: for example doctests are typically slow and in some trees not important for coverage, so you can now skip them.

I got cargo-mutants to a state where I felt I could announce it and ask for public feedback.

While it's purpose is different it can be used to do distributed compiling, so I'll leave it here.

https://github.com/Overv/outrun

Since I was just going down this rabbit hole recently, I kind of wonder if it's possible to set the filesystem on something more like the BitTorrent protocol so things like the libraries/compilers/headers that are used during compilation dont all need to come from the main pc. It probably wouldn't be useful until you reached a stupid number of computers and you started reaching the limits of the Ethernet wire, but for something stupid that can run on a pi cluster it would be a fun project.

Your mention of compile heavy workloads reminded me of a project called Outrun, it offloads work to another machine. All it seems to require is Python, Fuse3 and ssh.

Awesome! This write up is satisfyingly detailed. Prior work in this space includes Plan9 of course, as well as the python project Outrun, which has it's own RPC-based FUSE FS: https://github.com/Overv/outrun

Other approachs to deployment in particular include the functional package managers Nix and Guix, which can create lightweight application images, and could probably be cobbled together into some sort of remote environment replication even across architectures. As I read on, I thought less about how this compares with Guix in regards to application/environment packaging and more about how these things could be glued together in interesting ways, because I think the intro leads in through slightly off-label examples, if that makes sense. Application packaging isn't what this addresses at the end of the day, but it's no less fascinating for it.