bacon VS cargo-geiger

Probably one of the biggest speed ups to your inner loop writing / running code is to use something like https://github.com/Canop/bacon/. I used a combination of the docs and GPT chats to increase my learning speed a lot.

Nice, I'll have a look. I miss having bacon in a tmux split, wish TS had something like that.

As a macOS user, it boils my brain whenever I've to type in something like ~/Library/Application Support/org.rust-lang.Cargo/config.toml. macOS users have been begging CLI tools to support XDG variables on macOS too. Setting defaults is a strong indication to the community what should be the "preferred" locations. The defaults defined in your article will invariably lead to some authors saying that if that path is good enough for cargo, then it is good enough for their tool. Even the latest draft RFC acknowledges that macOS should use XDG variables too. I've written more about this here.

bacon + nvim-bacon

bacon

I love cargo-watch and still it use it situationally, but as a companion to my editor workflow I mostly switched to bacon. Being able to switch with one keystroke to another cargo subcommand is delightful.

Try bacon for checks & test!

Was it bacon perhaps?

Instead of looking at the crates themselves, you might want to check your (or others') Rust application with https://github.com/rust-secure-code/cargo-geiger to get a sense of effective prevalence. I also dispute that the presence of unsafe somewhere in the dependency tree is an issue in itself, but that's a different discussion that many more had in other sub-threads.

There's still plenty. Run cargo geiger on any of your projects and see for yourself.

On point 2, the answer is cargo geiger, and judging how much memory safety you need for a given project.

You can use cargo-geiger or cargo-crev to check for whether people you trusted (e.g. u/jonhoo ) trust this crate.

The amount of unsafe code is also a factor. cargo geiger is a handy tool for measuring it.

We have cargo-geiger that does just that.

For that, I believe you need to use cargo-geiger[0] and audit the results.

[0] - https://github.com/rust-secure-code/cargo-geiger

cargo-geiger is a subcommand you can install which will check all the crates in your dependency graph for unsafe blocks and print out a report (which also shows if a crate has #![forbid(unsafe_code)] or not). You can then inspect those crates' sources to judge their use of unsafe for yourself. I don't think it has a "check" mode that simply errors if your dependency graph contains unsafe though, it's more about just collecting that information.

wrt to memory safety, keep in mind that many rust crates use "unsafe" internally. There are tools available that can find these such as cargo-geiger. So I would suggest to avoid unsafe deps as much as possible. Since they cannot be avoided entirely, it is a good idea to keep a list of unsafe deps.