Fundamentals of Computer Science I: Media Computing (CS151.02 2007F)
[Skip to Body]
Primary:
[Front Door]
[Glance]

[Academic Honesty]
[Instructions]
Current:
[Outline]
[EBoard]
[Reading]
[Lab]
[Assignment]
Groupings:
[Assignments]
[EBoards]
[Examples]
[Exams]
[Handouts]
[Labs]
[Outlines]
[Projects]
[Readings]
[Reference]
Reference:
[Scheme Report (R5RS)]
[Scheme Reference]
[DrScheme Manual]
Related Courses:
[CSC151.01 2007F (Davis)]
[CSC151 2007S (Rebelsky)]
[CSCS151 2005S (Stone)]
This reading is also available in PDF.
Summary: We consider the purpose of Scheme and the structure of expressions in Scheme.
Contents:
Our main objectives in this course are (1) to learn about algorithms, stepbystep methods for solving problems, and (2) to learn how to direct computers to perform such algorithms for us. A programming language, such as Scheme, is a formal notation in which one can express algorithms so exactly that a computer can perform them without any other assistance from human beings. The expression of an algorithm in such a notation is called a program, and the computer is said to be executing the program when it is performing the algorithm as directed.
Although not all of the problems that we'd like computers to solve are
arithmetical, the simplest examples belong to that category, and we'll
start with a few of them. Here, for instance, is a program, written in
Scheme, that directs the computer to find the answer to the question What
is the square root of 137641?
(sqrt 137641)
In order to make the Scheme environment answer that question, you need to learn how to work with Scheme. There are many different implementations of Scheme available. We'll use DrFu, which you will be learning simultaneously. In DrFu, you can work interactively with Scheme, typing a bit of code, finding a result, typing another bit of code, finding a result, and so on and so forth.
> (sqrt 137641)
371
The full Scheme language contains several hundred primitive
procedures  operations, such as finding the square root
of a number, for which a Scheme interpreter can use prepackaged
algorithms. DrFu includes implementations of many of those
procedures. Some programmers who are experts on square roots and on
the idiosyncracies of our computers have figured out and written up a
stepbystep method for computing the square root of any number, using
only the very elementary transformations that the processor can perform.
Most Scheme interpreters recognize sqrt
as the name of this algorithm and
knows where the processor instructions that carry it out are stored.
When the interpreter receives a command to compute a square root, it recovers
these instructions and arranges for the processor to follow them.
A procedure call is a command that directs the Scheme
interpeter to activate a procedure such as sqrt
. (Note:
sqrt
is the name of the procedure, and (sqrt
137641)
is the procedure call.) In Scheme, every procedure
call begins with a left parenthesis and ends with the matching right
parenthesis. Within the parentheses, one always begins by identifying
the procedure to be called and then continues by identifying the
arguments, the values that the procedure is supposed to
operate on. The sqrt
procedure takes only one argument,
the number of which you want the square root, but other procedures take
two or more arguments, and some need no arguments at all.
All arithmetic in Scheme is done with procedure calls. The primitive
procedure +
adds numbers together, the primitive procedure

subtracts one number from another. Similarly, the primitive
procedure *
performs multiplication, and the primitive
procedure /
performs division. The fact that in a procedure
call the procedure is identified first makes calls to these procedures look
different from ordinary arithmetic expressions: For instance, to tell
DrScheme to subtract 68343 from 81722, one gives the command ( 81722
68343)
.
Other Scheme procedures include abs
, and expt
.
The Scheme procedure abs
computes the absolute value of
its argument. The Scheme procedure for raising a number to some power
is expt
.
As you may have noted, the appropriate way to write a Scheme expression is
(operation operand_{1} ... operand_{n})
That is, you parenthesize the expression (and any nontrivial subexpressions) and you place the operation before the operands.
It is harmless, though unproductive, to try to give a Scheme interpreter ordinary arithmetic expressions, in which the procedure is written between the operands.
DrFu, like most Scheme interpreters, can also learn new names for things by reading definitions. Here's what a definition looks like:
(define name value)
For example,
(define daysinaweek 7)
Like a procedure call, a definition begins and ends with matching
parentheses. To distinguish between definitions and procedure calls,
DrScheme looks at what comes immediately after the left parenthesis. In a
definition, the keyword define
must appear at that point.
The keyword define
is not the name of a procedure;
it is part of the syntactic structure of the Scheme programming language.
Its only role is to serve as the mark of a definition.
After the keyword define
, a definition contains the name being
defined and an expression that identifies the value that the name should
stand for. In this example, the name is daysinaweek
.
(Notice that in Scheme a name can, and often does, contain hyphens
internally.) The value that it names is the number 7. Once DrScheme has
seen this definition, it remembers that daysinaweek
stands
for 7.
The value that gets a new name need not be a number; it can be anything,
even a computation or the name of a procedure. For example, if you don't like the name *
for the multiplication procedure and would rather call it by the name
multiply
, just start each sequence of interactions with
DrFu by giving it
the definition (define multiply *)
. (Alternately,
place the definition in a file, and load the file in your interactions
window.)
At this point, I hope you're wondering what other useful and interesting procedures are built into Scheme. Section 6.2.5 of the Revised^{5} report on the algorithmic language Scheme contains a list of the ones that are mainly about numbers, and that's only one section of the full roster of standard Scheme procedures. Fortunately, most of the primitive procedures perform small, simple jobs and are easily learned.
http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/History/Readings/beginningscheme.html
.
[Skip to Body]
Primary:
[Front Door]
[Glance]

[Academic Honesty]
[Instructions]
Current:
[Outline]
[EBoard]
[Reading]
[Lab]
[Assignment]
Groupings:
[Assignments]
[EBoards]
[Examples]
[Exams]
[Handouts]
[Labs]
[Outlines]
[Projects]
[Readings]
[Reference]
Reference:
[Scheme Report (R5RS)]
[Scheme Reference]
[DrScheme Manual]
Related Courses:
[CSC151.01 2007F (Davis)]
[CSC151 2007S (Rebelsky)]
[CSCS151 2005S (Stone)]
Disclaimer:
I usually create these pages on the fly
, which means that I rarely
proofread them and they may contain bad grammar and incorrect details.
It also means that I tend to update them regularly (see the history for
more details). Feel free to contact me with any suggestions for changes.
This document was generated by
Siteweaver on Mon Dec 3 09:53:20 2007.
The source to the document was last modified on Mon Aug 27 18:04:25 2007.
This document may be found at http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2007F/Readings/beginningschemereading.html
.
You may wish to validate this document's HTML ; ;
Samuel A. Rebelsky, rebelsky@grinnell.eduhttp://creativecommons.org/licenses/bync/2.5/
or send a letter to Creative Commons, 543 Howard Street, 5th Floor,
San Francisco, California, 94105, USA.