Class 02: Starting Scheme

Held: Tuesday, 21 January 2003

Summary: Today we begin our exploration of Scheme with a short overview of the history and purpose of the language and lots of experimentation.

Related Pages:

• Reading on Scheme Basics.
• DrScheme Lab.
• Lab on Scheme Basics.

Assignments:

• Read Symbolic Values in Scheme.
• Read Lists in Scheme.
• Read Numbers in Scheme.

Notes:

• I teach three introductory courses in this room each day. Please excuse me if I occasionally get confused as to what I've told you or failed to tell you.
• I've started to prepare my responses to your questions from the introductory survey.
• I will be unavailable for office hours today. Sorry.

Overview:

• About Scheme
• Lab: The DrScheme Programming Environment.
• Lab: Starting Scheme.

A Short History of Scheme

• Scheme is a variant of Lisp (the List processing language).
• Lisp is one of the oldest high-level programming languages in active use
  • 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.

Scheme Basics

• Scheme is generally used in an interactive environment: You type syntactically-valid expressions and Scheme returns their values.
  • Later this semester, we'll see how to use Scheme in different environments.
• Scheme's syntax is fairly simple: Since almost everything in Scheme involves the application of a function to some arguments, you write:
  • 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)
  (sqrt 4)
  (expt 2 3)
  

• If you remember this basic syntactic structure, you'll rarely get syntactic errors from Scheme.

Some Procedures You Should Know

• +: 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 v^p.
• (abs v): Compute the absolute value of v.

Labs

• 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.