Transcript side effects

CS 201
Computer Systems Programming
Chapter 9
Side Effects
Herbert G. Mayer, PSU
Status 6/28/2015
1
Syllabus
 Side Effects
 Language and Side Effect
 Sample Side Effect
 References
2
Side Effects
Side Effects in imperative programs are:





Actions performed by a function
Changing the program state
In a way that is generally surprising
Due to their unexpected, even unnatural, location or time!
As a consequence, side effects are hard to track, their
impact difficult to account for, and programs generating
them are hard to maintain
What Side Effects are NOT!



These unexpected changes are not caused by mystery
agents; instead they are caused by the programmer, by
you, who put them there for a reason, sometimes even
good reasons
Side effects are not bad per se!
Functional languages are designed to be Side Effect-free!
3
Side Effects
Why do Side Effects occur? Why are they practiced?

For convenience lumped together with action proper of a function

For efficiency, to avoid invoking another, separate function

Fair to say: They are frequently short-cuts
How to avoid Side Effects?

Either use a functional language, or

Assuming the impact of the Side Effect is needed:

Separate the Side Effect out in an imperative language, thus
simulating the behaviour/constraint of a functional language
Why avoid Side Effects?

A program written with Side Effects, no matter how well designed,
is more difficult to read --harder to maintain– than a program
without Side Effects

But watch out for ‘snake-oil’ propaganda  : The programmatic
result of the Side Effect has to be accomplished somehow
4
Language and Side Effect
Imperative languages (e.g. C++) generally encourage
side effects






Underlying compute model is Turing Machine
Side Effect means: a change in machine/program state
Enabled by references to, and changes of, global objects
Imperative languages can change globals directly, or
indirectly via reference parameters or pointers
Can change files, state, condition code, machine resource
Languages prone to side effects include: Fortran, PL/I,
Pascal, Ada, C, C++
5
Language and Side Effect
Can be worse (more obscure) in languages other than C/C++


More complex languages with nested procedural scope offer even
more chances for side effects; C has no lexically nested functions
But see other languages, e.g. PL/I, Ada, Pascal, Modula-2, Algol-68 …
Functional languages



Underlying compute model generally is Lambda Calculus
One goal of functional languages is to eliminate side effect
E.g. Haskell, ML, Prolog, …
Caveat



Watch out for PR! Language proponents generally have an agenda,
maybe even a noble one, but can stretch the truth in one direction or
another without telling you, often without being aware: Never
underestimate the power of self-deception!
Functional language are not inherently better, just because they
reduce chances for side effects; they are different and have different
shortcomings
Imperative languages with nested procedural scope are not inherently
better, just because they allow better data sharing
6
Sample1 Side Effect
#include <stdio.h>
#define MAX 10
// arbitrary array bound for sample
int global_i = 5;
// arbitrary number within array bounds
int arr[ ] = { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 };
int one()
{ // one
global_i++;
return 1;
} //end one
// suspect function with side effect
void print()
{ // print
for ( int i = 0; i < MAX; i++ ) {
printf( "arr[%d] = %2d\n", i, arr[ i ] );
} //end for
} //end print
int main()
{ // main
arr[ one() + global_i ] = arr[ one() + global_i ];
print();
} //end main
7
Sample1 Side Effect, Output Start
arr[0]
arr[1]
arr[2]
arr[3]
arr[4]
arr[5]
arr[6]
= 0
= 1
= 4
= 9
= 16
= 25
= 36
. . . And more, but what exactly?
8
Sample1 Side Effect, Output
arr[0]
arr[1]
arr[2]
arr[3]
arr[4]
arr[5]
arr[6]
arr[7]
arr[8]
arr[9]
=
=
=
=
=
=
=
=
=
=
0
1
4
9
16
25
36
64  element arr[ 7 ] overridden with arr[ 8 ]
64
81
9
Sample2 Side Effect, Output
For the following modified assignment of sample1,
what will be output?
// Sample 1 modified: Sample 2:
int main()
{ // main
arr[ one() + global_i ]
= arr[ one() + global_i ]
= arr[ one() + global_i ];
print();
} //end main
10
Sample Side Effect, Output
arr[0]
arr[1]
arr[2]
arr[3]
arr[4]
arr[5]
arr[6]
arr[7]
arr[8]
arr[9]
=
=
=
=
=
=
=
=
=
=
0
1
4
9
16
25
36
81  element arr[ 7 ] overridden with arr[ 9 ]
81  element arr[ 8 ] overridden with arr[ 9 ]
81
11
Sample Side Effect
Was the correct element overridden?
Was the right element referenced?
Which language rule should apply?
Must left-hand side of assignment operator = be
evaluated first? Or the right-hand side? And every
part of it?
Should the function main() be allowed to change
global_i or any other global?
Did the programmer do something wrong?
12
References
1. Side effect:
http://en.wikipedia.org/wiki/Side_effect_(computer_s
cience)
2. Functional language:
http://en.wikipedia.org/wiki/List_of_programming_la
nguages_by_category#Functional_languages
3. Turing Machine:
http://plato.stanford.edu/entries/turing-machine/
4. Functional vs Imperative:
http://msdn.microsoft.com/enus/library/bb669144.aspx
13