CS 201 Computer Systems Programming Chapter 9 “ Side Effects ” - PowerPoint PPT Presentation

herbert g mayer psu cs status 7 15 2014 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CS 201 Computer Systems Programming Chapter 9 “ Side Effects ” PowerPoint Presentation
Download Presentation
CS 201 Computer Systems Programming Chapter 9 “ Side Effects ”

play fullscreen
1 / 13
CS 201 Computer Systems Programming Chapter 9 “ Side Effects ”
188 Views
Download Presentation
serina-shepard
Download Presentation

CS 201 Computer Systems Programming Chapter 9 “ Side Effects ”

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Herbert G. Mayer, PSU CS Status 7/15/2014 CS 201Computer Systems ProgrammingChapter 9“Side Effects”

  2. Syllabus • Side Effects • Language and Side Effect • Sample Side Effect • References System programmer must be keenly aware of side-effects, particularly in Imperative Languages

  3. 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!

  4. 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 just 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

  5. 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++

  6. 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

  7. Sample1 Side Effect #include <stdio.h> #define MAX 10 // arbitrary array bound for sample intglobal_i = 5; // arbitrary number within array bounds intarr[ ] = { 0, 1, 4, 9, 16, 25, 36, 49, 64, 81 }; int one() // suspect function with side effect { // one global_i++; return 1; } //end one void print() { // print for ( inti = 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

  8. Sample1 Side Effect, Output Start • arr[0] = 0 • arr[1] = 1 • arr[2] = 4 • arr[3] = 9 • arr[4] = 16 • . . . And more, but what exactly?

  9. Sample1 Side Effect, Output • arr[0] = 0 • arr[1] = 1 • arr[2] = 4 • arr[3] = 9 • arr[4] = 16 • arr[5] = 25 • arr[6] = 36 • arr[7] = 64  element arr[ 7 ] overridden with arr[ 8 ] • arr[8] = 64 • arr[9] = 81

  10. 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

  11. Sample Side Effect, Output • arr[0] = 0 • arr[1] = 1 • arr[2] = 4 • arr[3] = 9 • arr[4] = 16 • arr[5] = 25 • arr[6] = 36 • arr[7] = 81  element arr[ 7 ] overridden with arr[ 9 ] • arr[8] = 81  element arr[ 8 ] overridden with arr[ 9 ] • arr[9] = 81 Key point: Order of evaluation of components of assignment!

  12. 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?

  13. References • Side effect: http://en.wikipedia.org/wiki/Side_effect_(computer_science) • Functional language: http://en.wikipedia.org/wiki/List_of_programming_languages_by_category#Functional_languages • Turing Machine: http://plato.stanford.edu/entries/turing-machine/ • Functional vs Imperative: http://msdn.microsoft.com/en-us/library/bb669144.aspx