This outline is also available in PDF.
Held: Monday, 28 January 2008
Today we begin your exploration of the Scheme programming language and
the environment in which you will be devleoping algorithms in Scheme.
- Sorry, my weekend got eaten by statistics. Expect responses to assignment 1 later this week.
- Are there questions on assignment 2? If you work in a group, you should just turn in one assignment for the group, with everyone's name at the top.
- Why use programming languages?
- Scheme basics.
- Scheme history.
- Computer scientists often express their algorithms in programming
languages, languages designed by other computer scientists to
- Most programming languages can also be
understood by computers.
- In this class, you will express your algorithms in the programming
- Some people wonder why we need artificial languages like Scheme, Pascal,
C, Java, and the ilk, given that we should be able to write algorithms
- In part, it's probably because the computer elite want to maintain
their sense of superiority over the masses.
- In greater part, it's because English and other
can be ambiguous. At the very least, they have many similar structures
that are interpreted very differently. Consider the classic pair of
- Time flies like an arrow.
- Fruit flies like a banana.
- Remember: Computers are sentient and malicious.
- From the programmer's perspective, it often seems that they'll do
their best to misinterpret whatever it is you write.
- 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 (a.k.a. operation, a.k.a.
procedure) to some arguments (a.k.a. parameters),
- an open parenthesis;
- the name of the function;
- a space;
- the arguments to the function (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.
- And if you believe that claim, I have a bridge to sell you.
+: 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.
(abs v): Compute the absolute value of v.
(max v1 v2 ... vn): Determine the largest of the given values.
(min v1 v2 ... vn): Determine the smallest of the given values.
- Scheme is a variant of Lisp (the List processing language).
- Lisp is one of the oldest high-level programming languages in
- It's from the late 1950's.
- That is, 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 management 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 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.
- A variant of Scheme called Script-Fu was added to the Gimp in its
early development, so it is tightly integrated with the Gimp.
- Now that you have learned DrScheme and some background, it's time for the
- I hope to spend the first few minutes of the next class giving you a
chance to reflect on your first real experiences with Scheme.