1 / 22

Mutation in Programming Languages: Exploring its Benefits and Challenges

This lecture explores mutation in programming languages, discussing mutation primitives, evaluation rules, and the advantages and disadvantages of using mutation in programming. It also provides examples and discusses how mutation can be used in functional and imperative programming. Join us to gain a deeper understanding of mutation in computer science.

saundersa
Download Presentation

Mutation in Programming Languages: Exploring its Benefits and Challenges

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. David Evans http://www.cs.virginia.edu/~evans M. C. Escher, Day and Night Lecture 18: Mutation CS200: Computer Science University of Virginia Computer Science

  2. Menu • Mutation Primitives • PS 5 CS 200 Spring 2002

  3. From Lecture 3: Evaluation Rule 2: Names If the expression is a name, it evaluates to the value associated with that name. > (define two 2) > two 2 CS 200 Spring 2002

  4. Names and Places • A name is not just a value, it is a place for storing a value. • define creates a new place, associates a name with that place, and stores a value in that place (define x 3) x: 3 CS 200 Spring 2002

  5. Bang! set! (“set bang”) changes the value associated with a place > (define x 3) > x 3 > (set! x 7) > x 7 x: 3 7 CS 200 Spring 2002

  6. set! should make you nervous > (define x 2) > (nextx) 3 > (nextx) 4 > x 4 Before set! all procedures were functions (except for their side-effects). The value of (f) was the same every time you evaluate it. Now it might be different! CS 200 Spring 2002

  7. Defining nextx (define (nextx) (set! x (+ x 1)) x) (define nextx (lambda () (begin (set! x (+ x 1)) x)))) syntactic sugar for CS 200 Spring 2002

  8. Evaluation Rules > (define x 3) > (+ (nextx) x) 7 or 8 > (+ x (nextx)) 9 or 10 DrScheme evaluates application sub-expression left to right, but Scheme evaluation rules allow any order. CS 200 Spring 2002

  9. set-car! and set-cdr! (set-car! p v) Replaces the car of the cons p with v. (set-cdr! p v) Replaces the cdr of the cons p with v. These should scare you even more then set!! CS 200 Spring 2002

  10. > (define pair (cons 1 2)) > pair (1 . 2) pair: 1 2 CS 200 Spring 2002

  11. > (define pair (cons 1 2)) > pair (1 . 2) > (set-car! pair 0) > (car pair) 0 > (cdr pair) 2 > (set-cdr! pair 1) > pair (0 . 1) pair: 1 0 2 1 Any reason to be afraid yet? CS 200 Spring 2002

  12. > pair (0 . 1) > (set-cdr! pair pair) > (car pair) 0 > (car (cdr pair)) 0 > (car (cdr (cdr pair))) 0 > pair #0=(0 . #0#) pair: 1 pair 0 2 1 CS 200 Spring 2002

  13. Functional Programming • Programming without mutation • Side-effects like printing and drawing on the screen are really mutations (of the display, printer, bell, etc.) • If an expression has a value, it is always the same – order of evaluation doesn’t matter • Substitution mode of evaluation works fine CS 200 Spring 2002

  14. Imperative Programming • Programming with mutation (assignment) • Value of an expression might be different depending on when it is evaluated • Substitution model of evaluation doesn’t work anymore! CS 200 Spring 2002

  15. Why Substitution Fails? (define (nextx) (set! x (+ x 1)) x) > (define x 0) > ((lambda (x) (+ x x)) (nextx)) 2 Substitution model: (+ (nextx) (nextx)) (+ (begin (set! x (+ x 1)) x) (begin (set! x (+ x 1)) x)) (+ (begin (set! 0 (+ 0 1)) 0) (begin (set! 0 (+ 0 1)) 0)) (+ 0 0) 0 CS 200 Spring 2002

  16. Why would a programming language allow mutation? • Does it allow us to express computations we couldn’t express without it? No! We can express all computations without mutation. (We’ll see why before the end of the course…) • Mutation allows us to express some computations more naturally and efficiently CS 200 Spring 2002

  17. Example • Count uses of letters in a message > (count-letters "this sentence does not have six esses") ((#\a . 1) (#\b . 0) … (#\r . 0) (#\s . 7) … (#\z . 0)) CS 200 Spring 2002

  18. Constructing the Tally List (define (make-letter-tallys) (for (char->integer #\a) (char->integer #\z) (lambda (accum cno) (append accum (list (cons (integer->char cno) 0)))) null)) CS 200 Spring 2002

  19. Imperative Solution (define (count-letters msg) (let ((letter-uses (make-letter-tallys))) (map (lambda (c) (insertlg (lambda (thisletter foundit) (if foundit foundit (if (eq? (car thisletter) c) (begin (set-cdr! thisletter (+ (cdr thisletter) 1)) #t) #f))) letter-uses #f)) (string->list msg)) letter-uses)) CS 200 Spring 2002

  20. Functional Solution • Need to keep making new lists! • If you are not sure mutation is a good thing (and you shouldn’t be), try writing this yourself CS 200 Spring 2002

  21. PS5 • Make a primosaic • Photomosaic that avoids reusing tiles • Change the tile selection to favor tiles that have not been used much • Keep track of how many tiles each tile is used • Mutate the list of tiles each time a tile is selected as the best tile CS 200 Spring 2002

  22. Charge • PS5 • You know everything you need to do it after today, so start early! • More open ended than previous problem sets • Thursday, 3:30 in Wilson 402 • Talk by Steven Pinker, The Blank Slate, the Noble Savage, and the Ghost in the Machine • Friday • A model of computation and evaluation rules that work with mutation CS 200 Spring 2002

More Related