Laboratory: Input, Output, and Side Effects

Predict the order in which operations are done in each of the following cases. After you've made each prediction, check your answer experimentally. (It's important to make the prediction first so that you think about order of evaluation.)

a. (add (multiply 1 2) (multiply 3 4))

b. (multiply (add 1 2) (add 3 4))

c. (divide (add 1 2) (add 3 4))

d. (add (multiply 1 (multiply 2 3)) (multiply 4 5))

e. (add (multiply 1 2) (multiply 3 (multiply 4 5)))

a. Look at the code for irgb-redder_* and irgb-lighter_*. Explain in your own words what each procedure does.

b. What output do you expect for the following expression?

> (irgb-redder_* (irgb 220 0 150))

c. Check your answer experimentally.

d. What output do you expect for the following expression?

> (irgb-lighter_* (irgb-redder_* (irgb 220 0 150)))

e. Check your answer experimentally.

a. Look at the code for yield and irgb-yield. Explain why we need irgb-yield in addition to yield.

b. Rewrite irgb-redder_* to use yield instead of irgb-yield.

c. Rerun the example from above.

> (irgb-redder_* (irgb 200 0 150))

d. Restore the call to irgb-yield in irgb-redder_*.

e. Given this additional information, revisit your answer to part a of this exercise.

As you may have noted, we're using the _* suffix to indicate that we have an “annotated” version of a procedure, one that tells us what we're doing.

a. Write your own irgb-darker_* procedure using irgb-lighter_* as a pattern.

b. Write your own irgb-average_* procedure.

Here's a sample call to irgb-average_*.

> (irgb-average_* (color->irgb "red") (color->irgb "green"))
Averaging 255/0/0 and 0/128/0 yields 127/63/0
8339200

Sometimes it's helpful to see the construction of a new color step by step. In a recent laboratory, we had to write a procedure to swap the red and blue components of a color. Here's how we might have written that procedure.

(define irgb-swap-rb
  (lambda (color)
    (irgb (irgb-blue color)
          (irgb-green color)
          (irgb-red color))))

What happens in this procedure? Let's use annotated versions of the various procedures to figure out just what's happening.

a. Add the following procedure to your definitions pane. (This procedure is just the one above, but with the annotated versions of the various procedures it's calling.)

(define irgb-swap-rb 
  (lambda (color)
    (irgb_* (irgb-blue_* color)
            (irgb-green_* color)
            (irgb-red_* color))))

b. Predict the output you will get when you enter the following in the interactions pane.

> (irgb-swap-rb (irgb 200 50 100))

c. Check your answer experimentally.

Consider the following procedure definition.

> (define fun6 (compose irgb-darker_* irgb-lighter_*))

a. What output do you expect for the following expressions?

> (fun6 (irgb 50 100 150))
> (fun6 (irgb 0 0 0))
> (fun6 (irgb 255 255 255))
> (fun6 (irgb 300 300 300))

b. Check your answer experimentally.

Consider the following procedure definitions.

> (define fun7a (section irgb-average_* <> (irgb 100 100 100)))
> (define fun7b (section irgb-average_* (irgb 200 0 200) <>))
> (define fun7c (compose fun7a fun7b))
> (define fun7d (compose fun7b fun7a))

a. What output do you expect for each of the following expressions? (You need not give exact numbers; just indicate what order you things to be averaged.)

> (fun7a (irgb 0 100 200))
> (fun7b (irgb 0 100 200))
> (fun7c (irgb 0 100 200))
> (fun7d (irgb 0 100 200))

b. Check your answers experimentally.

While the read procedure may seem straightforward, it has some subtleties that may take a bit of exploration to understand.

a. Add the following procedure to your definitions pane.

(define get-number
  (lambda ()
    (display "Please enter a number: ")
    (read)))

b. What do you think will happen when you enter the following expression? (Assume that you type 5 in response to the prompt.)

> (get-number)

c. Check your answer experimentally.

d. What do you think will happen when you enter the following expression? (Assume that you type 5 10 in response to the prompt.)

> (get-number)

e. Check your answer experimentally.

f. What do you expect to happen if you call (get-number) one more time? (Assume that you answer 5 in response to the prompt.)

g. Check your answer experimentally.

h. What, if anything, did you learn from this exercise?

As we noted in the reading, one of the complications of operations with side effects is that the order in which we do those operations can have significant impact. Let's check a particular example.

a. Add yet another subtraction procedure to your definitions pane.

(define sub
  (lambda (x y)
    (- x y)))

b. What result do you expect to get from the following expression? Assume that you answer 5 and then 10 when prompted for numbers.

> (sub (get-number) (get-number))

c. Check your answer experimentally.

What do you expect to happen if you enter 5 10 in response to the first prompt?

d. Check your answer experimentally.

a. Here are the two programs from the reading.

#lang racket
(display "Please enter your name: ")
(define name (read-line))
(display "Hello, ")
(display name)
(newline)

#lang racket
(display "Please enter a number: ")
(define val (read))
(display val)
(display " cubed is ")
(display (* val val val))
(newline)

a. Save the first as /home/username/Desktop/hello.rkt.

b. Save the second as /home/username/Desktop/cube.rkt.

c. Open a terminal window and type the following instruction (without the dollar-sign prompt).

$ cd /home/username/Desktop

d. Type the following instruction and observe what happens. (Once again, don't type the dollar-sign prompt.)

$ racket hello.rkt

e. Type the following instruction and observe what happens. (We think you know what belongs in this parenthetical remark.)

$ racket cube.rkt

Consider the following program.

#lang racket
(require gigls/unsafe)
(display "Input image: ")
(image-show (image-variant (image-load (read-line)) irgb-complement))

a. What do you expect to happen when you run this program in DrRacket? (You can type the file name /home/rebelsky/Desktop/kitten.jpg.)

b. Check your answer experimentally.

c. Save the file on your desktop and run it from the terminal.

a. Save the following program as /home/username/Desktop/invert.rkt.

#lang racket
(require gigls/unsafe)
(display "Input image: ")
(define infile (read-line))
(display "Output image: ")
(define outfile (read-line))
(image-save (image-variant (image-load infile) irgb-complement) outfile)

b. Predict what this program does.

c. Check your answer experimentally.

Right now, we get a lot of output from the annotated arithmetical procedures. For example,

> (add 2 4)
add 2 and 4
  yields 6

Rewrite the procedures so that we get much more concise, one-liner, output in normal mathematical form. For example,

> (add 2 4)
2 + 4 = 6

Write a program that prompts the user for the red, green, and blue components of a color, and also for an image. Your program should build a color from the three numbers, load the image, and then make a new image by averaging every color in the image with that newly built color.

$ racket extra2.rkt
What is the red component of your favorite color? 200
What is the green component of your favorite color? 50
What is the blue component of your favorite color? 240
Please enter the full path to an image:  /home/rebelsky/Desktop/kitten.jpg
Thanks!  In a minute, you'll see a new version of that image.

Using the input and output techniques we've started to explore, write a simple Mad Libs game. If you've never played Mad Libs, it involves taking a fixed set of text and prompting the user for certain parts of speech that get filled in. Here's a fairly lame example.

Give me some words and I'll tell you a story.
Animal:  Heffalump
Another Animal:  Bandersnatch
City:  Grinnell
Color:  blue
Month:  May
Adjective:  frumious
Exclamation:  Wicked Neat!
-ing form of verb:  excavating
verb:  program

Here's your story ...

One day in May, Winnie the Heffalump was excavating through
the wilds of Grinnell.  Winnie thought "The month of May is so blue. I
wish I could program."  Winnie felt very frumious.  As Winnie continued
excavating, Grinnell's famous Bandersnatch appeared.  "Wicked Neat!" thought
Winnie.

As you might guess, the code for this is fairly straightforward.

#lang racket
(display "Give me some words and I'll tell you a story.") (newline)
(display "Animal: ")
(define animal (read-line))
...
(display "One day in ")
(display month)
(display ", Winnie the ")
(display animal)
...