Held: Friday, 5 September 2003
Today we begin our investigations of the core language for the course,
Scheme. Scheme is a simple functional language with many imperative
features and very little syntax.
- Are there any questions on Homework 1?
- Lots of arts events this weekend, including the Grinnell Festival of the Arts and the opening of Roots of Renewal. Extra credit for attending Roots of Renewal this weekend (provided it's open).
- Advance warning: September 16 is Talk Like a Pirate Day. At least one member of this class has asked that we follow the guidelines. Let me know via email if you object.
- Scheme is generally used in an interactive environment:
You type syntactically-valid expressions and Scheme returns
- Later this semester, we'll see how to use Scheme in different
- Scheme's syntax is fairly simple: Since almost everything in
Scheme involves the application of a function to some arguments,
- an open parenthesis;
- the name of the procedure;
- a space;
- the parameters to the procedure (separated by spaces); and
- a close parenthesis.
- For example,
(+ 2 3 4)
(expt 2 3)
- If you remember this basic syntactic structure, you'll rarely get
syntactic errors from Scheme.
+: Sum its parameters.
*: Compute the product of its parameters.
-: Subtract the second parameter from the first.
(sqrt val): Compute the square root of val.
(expt v p): Compute vp.
(absabs v): Compute the absolute value of v.
- Scheme is a variant of Lisp (the List processing language).
- Lisp is one of the oldest high-level programming languages in
- It's from about the time of the invention of Cobol and only a few
years after the invention of Fortran.
- John McCarthy (of MIT and then Stanford) designed Lisp to provide a
language for programming in artificial intelligence.
- At the time, many people believed that intelligence was grounded
in symbolic processing.
- Lisp added many things to languages of the day:
- Symbolic values
- Dynamic lists as built-in data structures
- Automatic memory managment for those built-in data structures
- Functions as values (we'll return to this in a few weeks)
- In later reflection, McCarthy indicated that some of these things
were just luck. For example, the
lambda that you'll
learn about soon was just a "hmmm ... that sounds interesting, I'll
put it in" fluke.
- Scheme was designed in the early 1980's (or maybe late 1970's) as
a variant of Lisp more appropriate for teaching computer science
(and doing many other things; it's more elegant).
- Scheme has a slightly clearer semantics than Lisp (and a formal
semantics, which is important).
- Scheme adds some nifty features for advanced programmers.
- But, at least for 151, you're doing Lisp-like programming.
- You'll need to figure out DrScheme before you can write any Scheme, so start
with The DrScheme Lab.
- After a little while of playing with DrScheme, you should be ready for the
Beginning Scheme lab.
- I hope to spend the last few minutes of class giving you a chance to reflect
on your first experiences with Scheme.
Thursday, 28 August 2003 [Samuel A. Rebelsky]