concept state mutation in category functional programming

This is an excerpt from Manning's book Functional Programming in C#: How to write better C# code.
If we follow the functional paradigm, we should refrain from state mutation altogether: once created, an object never changes, and variables should never be reassigned. The term mutation indicates that a value is changed in-place—updating a value stored somewhere in memory. For example, the following code creates and populates an array, and then it updates one of the array’s values in place:
State mutation is when memory is updated in-place, and an important problem with it is that concurrent access to shared mutable state is unsafe. You’ve already seen examples demonstrating loss of information due to concurrent updates in chapters 1 and 2; let’s now look at a more object-oriented scenario.

This is an excerpt from Manning's book Functional Programming in Java: How functional techniques improve your Java programs.
What functional programming may be opposed to is the imperative programming paradigm. In imperative programming style, programs are composed from elements that “do” something. “Doing” something generally implies an initial state, a transition, and an end state. This is sometimes called state mutation. Traditional imperative-style programs are often described as a series of mutations, separated with condition testing. For example, an addition program for adding two positive values a and b might be represented by the following pseudo code:
In this chapter, you’ll learn how to handle state in a purely functional way. In the previous chapters, state mutation was avoided as much as possible, and you might have come to believe that state mutation is incompatible with functional programming. This isn’t true. In functional programming, it’s perfectly possible to handle state mutation. The only difference from what you may be used to is that you have to handle state mutation functionally, which means without resorting to side effects.
For a programmer, there are many reasons for handling state mutations. One of the simplest examples is the random number generator. A random number generator is a component with a method that returns a random number. If the random number generator had no state (which means, in reality, no changing state), it would always return the same number. This is not what you expect.