[dmm]

> in healthy projects build times are dwarfed by the time it takes to run tests

I don't doubt that's often true but many Rust projects may be outliers here. A full, non-incremental build of a Rust project involves building all of its dependencies. This can add significant amounts of time if a project uses a big framework like Actix-web, which adds many dependencies.

My tests however run very quickly, ~1ms each. So running thousands of tests only takes a few seconds, even on relatively slow gitlab runners.

[kevincox]

You should be caching the builds of your dependencies. This is very easy with cargo and GitLab. I think encouraging people to optimize this is a reasonable cost to push onto the free users.

[papaf]

To add to your point, the caching is done by adding a cache entry to .gitlab-ci.yml :

  variables:
    CARGO_HOME: $CI_PROJECT_DIR/cargo

  cache:
    key: "$CI_JOB_NAME"
    untracked: true
    paths:
      - cargo/
      - target/

[snovv_crash]

Is there an equivalent of `ccache` for Rust? For C++ it's been a total lifesaver, I've introduced it in multiple organizations for massively reducing (average) build times, even by sharing the cache on an NFS drive between multiple machines.

[Camas]

https://github.com/mozilla/sccache

[IshKebab]

Note the caveats though. In particular it can't cache Serde, which is easily the slowest popular crate to compile. Also the heavy use of static dispatch and LTO in Rust means a lot of the actually compilation happens in the final crate which is usually the one you modified.

It definitely helps but not as much as in C++.

[oehtXRwMkIs]

Plus Rust by design avoids all sorts of bugs leading to less tests imo. Python for example you really want a lot of testing, maybe even contracts, but with Rust I find that many of those tests are irrelevant.

[rumanator]

> Plus Rust by design avoids all sorts of bugs leading to less tests imo.

This assertion on the amount to tests makes no sense at all. Tests are not about language features. Tests are about checking invariantes, checking input and output bounds, and checking behavior. Tests focus on the interface, not the implementation. Tests only work if test coverage is high.

[IshKebab]

It makes total sense. Rust statically enforces many things you'd have to explicitly test for in other languages, for example types. So you don't need to write as many tests.