Unlike most other languages, Rust has a very strong emphasis on correctness and maintainability.
Basically, that means making it easy to avoid bugs, and making it easy to understand the code, and making it easy to refactor the code.
Because mutability is a major source of bugs, Rust tries to prevent unnecessary mutability.
That also aids with refactoring, because you know whether something is mutated or not.
This can also improve performance, because if the Rust compiler knows that something won’t be mutated, it can do some extra optimizations on it.
Rust takes the viewpoint that programs are read and run much more often than they are written, so it’s better for the programmer to spend a little extra effort (adding
mut) if it benefits people who are reading the code, or who are running the program.
Also, I would like to mention that because Rust has such a strong emphasis on correctness, the compiler is very good at catching mistakes (much more so than most other languages).
So it’s very common to just write Rust code in a fairly loose style, and then fix up any compiler errors afterwards.
This removes a lot of stress from programming, because you no longer need to worry about many things: the compiler will catch it!
So don’t worry about making your program perfect right away, instead take a more exploratory approach. Rely on the compiler, trust the compiler, it is your friend!