no-param-reassign eslint rule. 
Can you show an example why this rule is useful
The `no-param-reassign` rule in ESLint is designed to prevent the reassignment of function parameters. This rule is useful for several reasons:

1. **Clarity**: Reassigning parameters can make the code less readable and harder to understand, as it can be unclear whether the original value of the parameter is still needed or if it has been changed.

2. **Side Effects**: If parameters are reassigned, it can lead to unintended side effects, especially if the parameter is an object or an array that is passed by reference. This can cause bugs that are difficult to trace.

3. **Immutability**: Encouraging the use of immutability can lead to more predictable code. By not allowing parameter reassignment, it promotes practices that avoid mutation, which can lead to fewer bugs.

### Example

Here’s an example to illustrate the usefulness of the `no-param-reassign` rule:

#### Without `no-param-reassign`

```javascript
function updateUser(user) {
    user.name = 'Alice'; // Mutating the user object
    user = { ...user, age: 30 }; // Reassigning the parameter
    return user;
}

const originalUser = { name: 'Bob', age: 25 };
const updatedUser = updateUser(originalUser);
console.log(originalUser); // { name: 'Alice', age: 25 } - original object is mutated
console.log(updatedUser); // { name: 'Alice',
 The `no-param-reassign` rule in ESLint is used to prevent developers from reassigning the parameters of a function. This rule is useful because reassigning function parameters can lead to confusing and unexpected behavior, especially when working with objects or arrays.

Here's an example to illustrate why this rule is useful:

Suppose you have a function that takes an array as a parameter and modifies it in some way:
```javascript
function addOneToArray(arr) {
  arr = arr.map(num => num + 1);
  return arr;
}

const numbers = [1, 2, 3];
const newNumbers = addOneToArray(numbers);

console.log(numbers); // [1, 2, 3]
console.log(newNumbers); // [2, 3, 4]
```
At first glance, this code might seem like it does what you expect: it creates a new array with each element incremented by one. However, if you look more closely, you'll notice that the `numbers` array is not actually modified by the `addOneToArray` function. This is because the `arr` parameter is reassigned with the result of the `map` method, rather than modifying the original array.

Now, suppose you intended to modify the