What are the potential topics for tomorow's quiz?

• Documentation, particularly preconditions and postconditions
• The procedures with side-effects
  • drawing-render
  • image-new
  • display
• A few basic image procedures
  • image-height
  • image-show
  • image-width
  • load-image
• Procedures
  • How to write them
  • How to call them
• Drawings as values

Can we talk about procedures with side effects?

• Three models of procedures.
• One model: Arithmetic operations, drawing operations.
  • You call the operation/procedure on a value (or values) and you get a new value.

> (define x 5)
> (define y (square x))
> y
25
> x
5

> (define d (scale-drawing 10 drawing-unit-circle))
> (define d2 (hshift-drawing 20 d))
> (drawing-left d2)
15
> (drawing-left d)
-5

• Second model: image-set-pixel!
  • You call the operation/procedure on a value, and it changes that value.

> (define kitten (image-load "/home/rebelsky/Desktop/kitten.jpg"))
> kitten
1
> (image-get-pixel kitten 0 0)
3037011
> (irgb->string (image-get-pixel kitten 0 0))
"46/87/83"
> (image-set-pixel! kitten 0 0 "yellow")
> (irgb->string (image-get-pixel kitten 0 0))
"255/255/0"
> (image-show kitten)
1

• Third model: display
  • You call the operation/procedure on a value, and changes the world around you.

        > (define silly
        (lambda (name)
          (display "Hello ")
          (display name)
          (display ".")
          (newline)
          5))
    > (silly "Sam")
    Hello Sam.
    5

* Note: We see output *and* we get a value back.

* We say that the second and third models have "side effects". * What about that !? * Custom is to use the ! when you write a procedure with side effects. * But custom is not always followed. E.g., display doesn't have a !. * And then there's image-show. * It doesn't change the pixels. * But it changes the state, perhaps dangerously.

What's the relationship between image-show and drawing-render!?

• Two ways of thinking about pictures (we'll add others).
  • A picture is a collection of scaled and shifted and colored rectangles and ellipses. (drawing)
  • A picture is a grid of colored pixels. (image)
• image-show - take the grid of pixels and display it in GIMP.
• drawing-render! - takes the description, convert it to pixels, and set those pixels to the appropriate values on the image.

What about drawing->image?

• A shorthand for (drawing-render! drawing (image-new width height))

Can you talk to us about check and test and the rest?

• What's the difference between check-= and check-eq?

  • Different notions of equality in Scheme.
    • Numeric equality.
      • Complicated by inexact numbers, which approximate
      • Solution: Specify how close is close enough
      • Use check-=
    • The same, and easy to check (mostly symbols)
      • Use check-eq?
      • Don't worry about that.
    • "Naturally" the same
      • Two strings (surrounded by quotation marks)

• Example

    > (define prof "SamR")
    > (define sam (string-append "Sam" "R"))
    > prof
    "SamR"
    > sam
    "SamR"
    > (require rackunit)
    > (check-= prof sam 0)
    --------------------
    ERROR
    . . -: contract violation
      expected: number?
      given: "SamR"
      argument position: 1st
      other arguments...:
       "SamR"

    --------------------
    > (check-eq? prof sam 0)
    --------------------
    FAILURE
    actual:     "SamR"
    expected:   "SamR"
    name:       check-eq?
    location:   (unsaved-editor331 43 2 840 22)
    expression: (check-eq? prof sam)
    message:    0

    . . Check failure
    --------------------
    > (check-equal? prof sam 0)

• Moral: Use check-= for numbers and check-equal? for everything else.
• How do we combine everything into a test suite?
  • A collection of tests/checks
  • What's something we might want to test? Let's check sqrt.

 (define sqrt-tests
   (test-suite
     "Tests of the square root method"
     (test-case "If you square the square root (or vv), you get the original"
                (check-= (sqrt (square 2)) 2 0.000001)
                (check-= (square (sqrt 2)) 2 0.000001))
     (test-case "Easy test: sqrt 4.  If this doesn't work, things are broken."
                (check-= (sqrt 4) 2 0))
     (test-case "When sqrt can have an exact result, it should"
                (check-equal? (exact? (sqrt 4)) #t))
     (test-case "Check zero"
                (check-= (sqrt 0) 0 0))
     (test-case "Imaginary sqrt(-1)"
                (check-= (sqrt -1) 0+i 0.0000001))))

 (define ss-test
   (lambda (num)
     (test-suite
       "Checking square roots"
        (check-= (sqrt (square num)) num 0.000001)
        (check-= (square (sqrt num)) num 0.000001)
        (check-= (square (square (sqrt (sqrt num)))) num 0.0000001))))

 (define sqrt-tests
   (test-suite
     "Tests of the square root method"
     (test-suite
       "Roots of 2"
       (ss-test 2))
     (test-suite
       "Roots of 9273"
       (ss-test 9273))

Given documentation for a procedure, how do you write the procedure?

• Here's some documentation.

 ;;; Procedure:
 ;;;   whatever
 ;;; Parameters:
 ;;;   alpha, a number
 ;;;   beta, another number
 ;;;   image, an image
 ;;; Purpose:
 ;;;   Put a blue ellipse on image.
 ;;; ...
 ;;; Postconditions:
 ;;;   The width of the ellipse is alpha
 ;;;   The height of the ellipse is beta
 ...

• Now, let's write the start of the procedure

        (define whatever
          (lambda (alpha beta image)
            ...))

• Read the "purpose" to figure out the goal. Sometimes read the postconditions to understand exactly what is needed.
• The hard part: How do you achieve that purpose? We have heuristic strategies rather than exact formulae.
  • Find a similar problem that you've solved (or someone else has) and adapt it.
  • Look at the tools you have and think about which are most applicable.
  • Try doing it by hand and see what insight you gain.
  • See if you can break it down into simpler problems.

Will you send me my responses to the prologue?

• Yes, if you email me.