In computer science, a function is said to produce a side effect if it modifies some state other than its return value. For example, a function might modify a global or "static" variable, modify one of its arguments, write data to a display or file, or read some data from other side-effecting functions. Side effects often make a program's behavior more difficult to understand. Computer science is the study of the theoretical foundations of information and computation and their implementation and application in computer systems. ... In computer science, a subroutine (function, method, procedure, or subprogram) is a portion of code within a larger program, which performs a specific task and is relatively independent of the remaining code. ... In computer science, there are several precise meanings of static variable, depending upon the use and context. ...

Imperative programming is known for employing side effects to make programs function. Functional programming in turn is known for its minimization of side effects. In computer science, imperative programming, as opposed to declarative programming, is a programming paradigm that describes computation in terms of a program state and statements that change the program state. ... Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions. ...

Referential transparency

A function that uses side effects is referred to as referentially opaque, and one that doesn't is called referentially transparent. For simplicity's sake, we say that a referentially transparent function is one that, given the same parameters, will always return the same result. Another term for a referentially transparent function is a deterministic function.

A function can have no side effects but yet be referentially opaque. For instance, any function which measures the external world is referentially opaque. For instance, a function which reads the current time from the computer's clock must return different values given the same parameters, even though it does not change any global state -- because it depends on a piece of changing global state, namely the time.

Example

As an example, let's use two functions, one which is referentially opaque, and the other which is referentially transparent:

 globalValue = 0; integer function rq(integer x) begin globalValue = globalValue + 1; return x + globalValue; end 

 integer function rt(integer x) begin return x + 1; end 

Now, rt is referentially transparent, which means that rt(x) = rt(x) as long as x is the same value. For instance, rt(6) = rt(6) = 7, rt(4) = rt(3+1) = 5, and so on. However, we can't say any such thing for rq because it uses a global value which it modifies.

So, how is this a bad thing? Well let's say we want to do some reasoning about the following chunk of code:

 integer p = rq(x) + rq(y) * (rq(x) - rq(x)); 

Now, right off-hand, one would be tempted to simplify this line of code to:

 integer p = rq(x) + rq(y) * (0) = integer p = rq(x) + 0 = integer p = rq(x); 

However, this will not work for rq() because rq(x) does not equal rq(x)! Remember, that the return value of rq is based on a global value which isn't passed in and which gets modified all over the place. This goes against common sense since anything minus itself should be zero.

This however will work for rt, because it is a referentially transparent function.

Therefore we can reason about our code which will lead to more robust programs, the possibility of finding bugs that we couldn't hope to find by testing, and even the possibility of seeing opportunities for optimization. It has been suggested that Loop optimization be merged into this article or section. ...