Compiles times annoy me, but more than that, I think they cripple certain workflows.
Specifically, I've introduced Rust to several people who've all had large compile time complaints. In two particular cases, it boiled down to them having gotten used to a workflow that just doesn't work with Rust. Think about this TDD (test-driven development) workflow for writing new software:
- write tests for small portion of a feature
- implement that small portion of feature (15 line change max, preferably 3-5 lines)
- run tests (fix bugs, run tests again)
- repeat steps 1-3 maybe 20-50 times per hour
When writing JavaScript or Python, this cycle is 100% reasonable, and quite nice to use. You get immediate feedback, you get full tests for everything you're writing, and you get good feedback from the compiler. The whole cycle takes less than 5 minute for small additions. Swapping steps 1&2 is also reasonable.
When writing Rust, though, step 3 takes over a minute. Not even a 50% reduction in compile times would fix this: this workflow is impossible using Rust, and will be as long as we have a compiler which takes more than ~5 seconds on a large project. Something needs to change to make this workflow function - otherwise, you end up incredibly unproductive, writing 10 lines of code every 10 minutes. If you're used to thinking in terms of tests and getting that kind of immediate feedback on your logic, rust's compiles times can break your workflow in the worst way.
I've tried to help people I've introduced to rust by getting them to adopt slightly different workflows, but it can be a hard pill to swallow, especially if you've become invested in methodologies which support this kind of thing. The worst part is that several people who I've tried to talk into using Rust originally liked the idea for the exact same reason they like TDD: both make code more correct! So adopting Rust for it's correctness-focused design can be a lot less appealing if it means having to discard TDD, one of your best existing tools for making code correct.
With that said, I imagine a lot of new rustaceans can avoid this barrier - either because they come from C++, or because they don't have entrenched beliefs / habits. I personally learned Rust before I had strong opinions about any "right way" to write code, and so I formed my workflow around the Rust compiler. It usually ends up something like the following when writing new projects:
- plan & write a large batch of code, maybe about 5, 6 big functions
- check code (work out bugs from that one compilation, repeat until compiling)
- write 1-2 tests (run tests, work out bugs, repeat until well tested)
- repeat steps 1-3 once every 1-2 hours
I don't advocate for adopting this exact workflow, as it really isn't the best one. But I think that how much compile times matter to a person really does depend on that person's workflow, and I hope this comparison can give light to that. Compile times still annoy me, but they don't cripple my typical method of writing code.