CS 51 Week 1, L1: The Best Laid Scheme

• Introduction to Scheme
  • History
  • Parts of the Language (primitives, combination, abstraction)
  • The Interpreter's point of view
  • Special Forms
  • Recursion
  
  
• Reading: SICP 1.1

• Asst 0 and Sectioning are due Friday 5pm.
• URL (also on CS51 webpage): http://www.fas.harvard.edu/~lib51/files/section.pdf

Abstraction And Design

• Good programming is the systematic control of complexity
  
  
• Ideas for abstractions and design and problem-solving transcend programming languages.
  
  
• These ideas were invented by someone.
  (You too can, and will, invent ideas of your own.)
  
  

Introduction to Scheme

The Goal of Week 1 is to learn everything you need to know about writing simple programs in the Scheme programming language.

What exactly is Scheme?

Scheme is

• Small and powerful language
• An interpreted language
• A functional language, but
• Can explore alternate ways of programming
• And ...

History of Scheme

• Scheme was invented (designed) by Guy L. Steele Jr and Gerald J Sussman. They wrote their first paper on it in 1975. In fact at the time Guy Steele was an UNDERGRAD IN APPLIED MATH AT ______________ UNIVERSITY.
  
  
• Steele and Sussman used Scheme to show that show that programming languages can be implemented efficiently without constraining the programmers by arbitrary rules. They wrote a series of influential papers between 1975-1978 called "Lambda: The Utimate Papers".
  
  
• Scheme is a minimalist dialect of Lisp. Lisp is the second oldest high-level programming language, invented by McCarthy in 1957. (Fortran is the oldest, invented in 1950). The name Lisp is derived from "List Processing" since lists are the main data structure in Lisp and Lisp source code is itself made of lists. Lisp is based on a mathematical model of computation called lambda calculus by Alonzo Church (1930s).
  
  
• Sussman is a professor at MIT and one of the authors of the Structure and Interpretation of Computer Programs (SICP) textbook. Steele is a distinguished engineer at Sun Microsystems and has co-designed many languages, such as Common Lisp, *Lisp, and Java.

Parts of the Language

Every powerful language has

• PRIMITIVES (the simplest entities)
• MEANS OF COMBINATION (to create complex entities)
• MEANS OF ABSTRACTION (treat complex entities as if they were primitives)

In Scheme we have:

Primitives

• Self-evaluating primitives
  - Numbers, booleans, symbols, strings
  - e.g. 3, 5.2, 5/6, #t, #f, 'hello-world, "hello-world"
  
  
• Primitive procedures
  - arithmetic procedures, type-checking (number? string?..)
  - e.g. + - = equal?
  

Means of combination

We can combine the primitives to create expressions (function arg1 arg2 arg3...)

And this is really our only means of combination. Everything in Scheme looks like this applying a FUNCTION to a set of ARGUMENTS.

For example

              (- (+ 3 3 50) 5)
	      (equal? 5 'hello)

Means of abstraction

How do we create new primitives (data and procedures)?

We can name variables

      	 (define a 51)
      	 (define b (+ 25 26))
      	 (define c (equal? a 3)) <--- we can pretend a is just another simple entity

We can create named procedures

      	 (define (square x) (* x x))
	 (define (hello? x) (equal? x 'hello))
	 (square 51)            <--- we can pretend square is another primitive procedure

The interpreter's point of view

What is an interpreter and what does it do?

• [R] Reads an expression
• [E] EVALUATES it to produce a value
• [P] Prints the value
• [L] Loop

Interpreter vs Compiler

• Advantages: debugging, interactive
• Disadvantages: can be less efficient

So you can think of the interpreter as reading expressions in your program and evaluating it piece by piece. Here's a simple (but somewhat meaningless) scheme program.

  51
  #t
  (- 54 3)
  (+ (- 54 3) 101)
  foo
  (define  foo 3)
  (+ foo 48)

How does the interpreter evaluate this?

Lets do some examples (from the interpreter's point of view)

>  51

>  (- 54 3)

>  (+ (- 54 3) 101)

>  (+ foo 48)

>  (define  foo 3)

>  (+ foo 48)

Questions:

• The interpreter does not have any particular order. Why not?
  
  
• Does order ever matter?
  
  
• How would I test whether my interpreter uses a particular order?
  
  

Special Forms

Special Form: IF

  (if predicate then-expression else-expression)

Evaluation Rules

• Evaluate predicate
• If #t, the evaluate and return then-expression
• Otherwise, evaluate and return else-expression

Examples

>  (define a 3)
>  (if (= a 5) 'five 'notfive)

Challenge Problem:

I'd like to create a new version of if, that always has false for the else-expression. What is wrong with this? (Illustrate with an EXAMPLE)

  	(define (newif predicate then-expression) 
	     (if predicate then-expression #f))

Special Form: DEFINE

  (define name expression)

Evaluation rules

• name is not evaluated, expression is evaluated
• Creates an association from name to the value in the interpreter environment associated with a value (somewhere the interpreter is remembering something)
• returns NO VALUE

Some Examples:

> (define a (+ 2 3))              <------ returns no value! binds a-->5

> a
5

> (+ (define a 3) 3)              <------ interpreter returns an error
error:: define: not allowed in an expression context

> (define (square x) (* x x))     <------ binds square--> [PROC (n) (* n n)]

> square
#

> (square 3)
9

What happens when we apply a procedure created using define?

Example:

Other Special Forms

There are a number of special forms, some of which you will see in section and others that you will only see in later lectures.

Special Forms:

• if/cond
• define/lambda/let
• begin, display

     (function subexpression subexpression ...)

There is really not much more!

  (+ 2 3)
  (define a 3)
  (+ 2 (if (> a 10) 5 6))  <-- lots of parens but VERY SIMPLE STRUCTURE

Recursion

How do we create loops in this language? We can create loops by having a function call itself, i.e. by writing a recusrive procedure.

Example 1: Factorial

  n! = n * (n-1) * (n-2) ....* 1


  fact(n) =  | n * (n-1)!       if n > 0
             | 1                if n <= 0

In Scheme

  (define (fact n) 
	(if (<= n 0)
	    1
	    (* n (fact (- n 1))) 
	    ))

Lets look at this from the interpreter's point of view

> (define (fact n) .....)
...
> (fact 3)

Example 2: Counting

Print a row of numbers seperated by " : ", representing the axis of a graph or the heading for a table.

> (print-row 4 10)
4  :  5  :  6  :  7  :  8  :  9  :  done

In Scheme,

(define (print-row start end)
    (if (>= start end)
	'done
	(begin (display start) (display "  :  ")
	       (print-row (+ start 1) end))
	))

From the interpreter's point of view

> (print-row 4 10)

Recursion is a very natural and powerful idea, that comes up alot.

• Binary tree
• Population growth
• Proof by induction in mathematics
• Game solvers
• Art, like Escher's circle-limit and square-limit woodcuts

The Escher Recurse Painter
----------------------------
(define (escher-recurse-image ntimes img)
  (if (<= ntimes 0)
      (make-four-image img img img img)    ; return an image tiled with 4 of given image
      ; otherwise let the topleft be the given image, but "escherize" the rest
      (make-four-image img
                       (escher-recurse-image (- ntimes 1) (half-image img))
                       (escher-recurse-image (- ntimes 1) (half-image img))
                       (escher-recurse-image (- ntimes 1) (half-image img)))
      ))