Answer.

History of the Question

In many popular programming languages, such as C or JavaScript, variables are mutable by default. In Rust, the authors of the language made an important choice in favor of immutability for variables by default: this decision is related to code safety and reducing errors associated with unexpected changes in variable states.

The Problem

The main problem with mutable variables is the complexity of debugging and finding errors related to implicit changes in values. It is particularly difficult to understand the behavior of the code when variables change in different parts of the program, and control over their changes is lost. This can lead to bugs and unexpected results, especially when writing multithreaded applications or when there are complex interdependencies in the code.

The Solution

In Rust, variables are immutable by default using the let keyword. To make a variable mutable, you must explicitly specify mut. This increases code reliability, makes immutability a conscious choice, and reduces the likelihood of accidental changes.

Code Example:

let x = 5;        // immutable variable
let mut y = 10;   // mutable variable
y += 1;           // correct
x += 1;           // compilation error!

Key features:

Immutability by default — for safety.
Explicit indication of mutability via mut.
The compiler prevents modifications of immutable variables at compile time.

Trick Questions.

Can you change the field of a struct if the struct variable itself is declared as immutable?

No, if the struct variable is declared as immutable, its fields are also immutable. To modify the fields, you need to declare the variable with mut.

Code Example:

struct Point { x: i32, y: i32 }
let mut p = Point { x: 0, y: 0 };
p.x = 5; // ok
let p2 = Point { x: 1, y: 2 };
p2.x = 3; // compilation error!

If a variable is mut, can you reference it through multiple mutable references at the same time?

No, in Rust, there can only be one mutable reference to an object at a time. This rule prevents data race conditions.

Can you declare an array of immutable objects as mutable and change its contents?

Yes. If the array variable is declared as mut, its elements can be changed, but if the contents of the array type do not support mutability, then the elements remain immutable.

Typical Mistakes and Anti-Patterns

Using mut unnecessarily, which makes the code less safe.
Attempting to modify the contents of a variable without declaring mut.
Misunderstandings about the mutability of nested structures.

Real-Life Example

Negative Case

In a project, variables are declared mutable by habit, even when it is unnecessary. As a result, one of the variables is accidentally modified in the middle of the program by another method, causing a hard-to-trace bug in production.

Pros:

Speed of writing code without needing to monitor mutability.

Cons:

Complexity of debugging and a high risk of bugs related to unnecessary changes.

Positive Case

In a team project, the rule is followed: by default, variables are immutable, and mutability is used only where absolutely necessary, always adding comments explaining the reason.