cargo-script-mvs VS config

The eRFC was intentionally light on details so the Pre-RFC / IRLO thread and the demo best reflect what we hope to accomplish which are pretty detailed as-is.

> A) is easy to write one off scripts that do a job fast, with minimal thinking and effort. I am thinking of Python and Ruby. For me I can write code with high velocity in these languages.

Once I wrap up some other projects, I plan to explore this space a little bit within Rust.

imo the biggest bang for the buck is just having good `#!` support. Probably mid-year I expect to have a Pre-RFC up for single-file cargo packages. See https://github.com/epage/cargo-script-mvs/discussions/15.

A bigger effort is a batteries included, non-zero cost stdlib. I've started writing up my thoughts at https://github.com/ergo-rs/ergo.

For more background on why I think these are important, see https://epage.github.io/blog/2021/09/learning-rust/.

Would love feedback on these ideas and other ways to make Rust easy to use without sacrificing what makes Rust it is.

This is something I'm interested. Every time I write a bash or Python script, I think "why didn't I do this in Rust?". The first barrier is in the same line as your thoughts which is why I've been investigating the various cargo-script spin-offs and working towards an MVP for a Pre-RFC.

Something I've been thinking a lot about for Rust is what can and should a REPL experience be for a compiled language (ie what are reasonable compromises).

There seem to be two repls that haven't gotten much traction:

- https://github.com/google/evcxr/blob/main/evcxr_repl/README....

- https://github.com/sigmaSd/IRust

There have been little and big nits that have held me back from wanting to push these further, including

- Bad defaults (having to opt-in to panic handling)

- Command syntax feeling out of place and likely not beginner friendly

- Limits on variable preservation

- Lack of introspection (at least irust as `:type`)

So far I've been punting on wanting to improve this area by instead focusing on polishing up a rust script solution in the hopes of getting it merged: https://github.com/epage/cargo-script-mvs

rust-script is the most up-to-date version I could find. See https://github.com/epage/cargo-script-mvs/discussions/15

cargo-script has been forked or reimplemented several times.

cargo-script: I've done some initial analysis and recorded my thoughts on what cargo-script in Rust should look like. If people are interested in this or other individual / company on-boarding improvements, I'd love to talk!

Fully agree with this though I also feel there is room for experimentation and improvement in this area. I've previously blogged on this and have started researching cargo-script. Hopefully later I'll get to my standard-adjacent library.

I actually quite like the config, seems intuitive! Though, I am comparing it to this abomination, so I might have low expectations here :-)

4) For scripts you put for everyday use in ~/bin, I've found busybox style multipurpose binary invaluable. You put all your scripts into a single Rust binary, and than hard-link this binary under different names in PATH, so that the first argv is actually the name of subcommand. Here's how the infra works for my scripts, and here's an example script.

1) Invest into application-level profiling, using tracing::span! for collection and something like tracing_tracy or tracing_span_tree for visualization. This should give you high-level logical profile. 2) If on Linux, learn a bare minimum of perf for collecting data (the extent of my knowledge about perf is basically this script https://github.com/matklad/config/blob/master/tool/src/prf.rs). Use neither flamegraph.pl nor cargo flamegraph for visualization, use https://profiler.firefox.com/ instead.

And, while a spam links, here’s a link with more links: https://github.com/matklad/config/blob/master/links.adoc