Held: Wednesday, 9 September 2015

Back to Outline 07 - Transforming Images. On to Outline 09 - Writing Your Own Procedures, Continued.

Summary

We continue to consider how you can write your own procedures and why you might do so.

Related Pages

• Reading: Writing Your Own Procedures
• Reading: How Scheme Evaluates Expressions (v2)
• Lab: Writing Your Own Procedures
• EBoard 8 (Source 8)

Overview

• Sequencing operations in Scheme.
• Why define your own procedures?
• How to define your own procedures.
• Evaluating expressions in Scheme.

Administrivia

• New partners!
  • Grab a card from the stack.
  • Identify the location of the new computer.
  • Drop the card in the jar.
  • When both of you are at the computer, introduce yourselves.
• Mentor sessions Wednesday and Thursday at 8pm in the Commons.
• Sam review session Thursday at 10am in our classroom.
• We'll spend the start of class going over some of the key ideas from the past week. I hope you've brought lots of questions.
• Mechanisms for working on CSC 151 outside of Noyce will be discussed on Friday.
• Today's lab will continue into Friday's class.

Upcoming Work

• Review today's readings for Friday: Procedures How Scheme Evaluates Expressions (take 2)
• Assignment 3 due Tuesday @ 10:30 p.m.
  • Your partner is the person who you are working with today and Friday.
• Quiz Friday!
  • RGB Colors, including functions on RGB colors
  • Basic image functions
  • Composition with o
  • Sectioning with section
  • No lambdas
• Lab writeup (due before class Monday)
  • Email to grader-151-01@cs.grinnell.edu
  • Subject: CSC 151 Lab Writeup Class 8 (Your Names)
  • Exercise:

Extra Credit Opportunities

Academic

• Don't Forget Convocation Tomorrow! Convocation, Thursday, 11am, JRC 101, Global Health.
• Tuesday, noon, CS Table, JRC 224C. Hacking Cars.

Peer Support

• Pals of PALS, pals@grinnell.edu, normally Saturday at 1:30 and Mondays at 4:45. Requires sign up in advance.
• Pun Club, Saturdays, 4pm, Way over Younker.
• Singers concert on Family weekend! Sept. 26, 2pm., place TBD
• Orchestra concert on Family weekend! Sept. 26, 2pm., place TBD

Review

• What are the components of algorithms?
• Which of those have we learned so far?
• What things don't make sense?

Sequencing Operations

• We noted that the sequence of operations is an important aspect of an algorithms. (You want a jar open before you put the knife in the jar.)
• Different languages have different approaches to sequencing operations.

• In Scheme, we often write compound expressions, expressions that include subexpressions.

  (sqrt (+ (square x) (square y)))
  

• Which is done first, square, +, or sqrt?

  • Scheme (usually) works from the inside-out, so we do the square operations first, then the addition, then the sqrt.
• Which of the square operations is done first?
  • The Scheme standard says that the interpreter can do them in either order.
• Do we have other ways of sequencing operations?
  • A series of definitions provides one mechanism for doing so.

User-Defined Procedures

• It's clear that programmers often want to (and need to) define their own procedures.
• By "their own procedures", we mean collections of Scheme commands that are parameterized and referred to be a single name, just like the built-in procedures, such as square and +, or the DrFu procedures, such as hshift-drawing.
• Procedures take inputs (which we call parameters) and may produce a result.
• Some procedures modify their parameters:
  • An "open jar" procedure changes the state of the jar.
  • (We'll see some in Scheme a bit later.*
• Some procedures create new values, without modifying their parameters:
  • sqrt
• User-defined procedures can add clarity to a program.
  • Rather than looking at how code does something, the user of a procedure can focus on what the code does.
  • A reader of the program is much more likely to understand a procedure call than the body of the procedures.
• Programmers can avoid repetitive (and, therefore, error prone) code.
  • Rather than retyping the same code again and again, just changing a few values, a programmer can give a name to the same code.

• How do you define your own procedures? Using the following template:

  (define your-procedure (lambda (param₁ ... param_n) expression₁ ... expression_m))

• For example,

  (define square (lambda (val) (* val val)))

• You can (and should) document your procedures so that others can understand what they are supposed to do. We'll come back to this issue soon.

• When the body of a procedure has multiple expressions (as in the template), only the value of the last expression is returned.
• When you call a procedure, it's like you do a define for each parameter as the corresponding sent value.

• So (square 5) is a lot like

  (define val 5) (* 5 5)

Evaluation in Scheme

• Two main issues:
  • Table that associates names and values.
  • Where we are in the expression we are evaluating.
• General process
  • Evaluate from inside out
  • If you see a name, look it up in the table
  • If you see a value, leave it as is
• Complication from procedures
  • We also look up procedures in the table.
  • When we run a procedure, we temporarily update the table, associating the values of parameters for their names.

Labs

• Begin the lab on procedures
• Be prepared to reflect (e.g., to describe the most important or most confusing thing you dealt with today). (And no, you can't say "Sam is the most confusing thing I dealt with today.")