One easy way to get started at programming is to examine some typical
interactions with an interpreter for the Scheme dialect of Lisp.
Imagine that you are sitting at a computer terminal. You type an *
expression*, and the interpreter responds by displaying the result
of its * evaluating* that expression.

One kind of primitive expression you might type is a number. (More precisely, the expression that you type consists of the numerals that represent the number in base 10.) If you present Lisp with a number

`
486`

`
`
the interpreter will respond by printing ^{5}

`
486`

Expressions representing numbers may be combined with an expression representing a primitive procedure (such as + or ) to form a compound expression that represents the application of the procedure to those numbers. For example:

`
(+ 137 349)
486
`

`
(- 1000 334)
666
`

`
( 5 99)
495
`

`
(/ 10 5)
2
`

`
(+ 2.7 10)
12.7`

Expressions such as these, formed by delimiting a list of expressions
within parentheses in order to denote procedure application, are
called * combinations*. The leftmost element in the list is
called the * operator*, and the other elements are called *
operands*. The value combination is obtained by applying the
procedure specified by the operator to the * arguments* that
are the values of the operands.

The convention of placing the operator to the left of the operands is
known as * prefix notation*, and it may be somewhat confusing
at first because it departs significantly from the customary
mathematical convention. Prefix notation has several advantages,
however. One of them is that it can accommodate procedures that may
take an arbitrary number of arguments, as in the following examples:

`
(+ 21 35 12 7)
75
`

`
( 25 4 12)
1200`

No ambiguity can arise, because the operator is always the leftmost element and the entire combination is delimited by the parentheses.

A second advantage of prefix notation is that it extends in a
straightforward way to allow combinations to be * nested*, that
is, to have combinations whose elements are themselves combinations:

`
(+ ( 3 5) (- 10 6))
19`

There is no limit (in principle) to the depth of such nesting and to the overall complexity of the expressions that the Lisp interpreter can evaluate. It is we humans who get confused by still relatively simple expressions such as

`
(+ (* 3 (+ (* 2 4) (+ 3 5))) (+ (- 10 7) 6))`

which the interpreter would readily evaluate to be 57. We can help ourselves by writing such an expression in the form

(+ ( 3 (+ ( 2 4) (+ 3 5))) (+ (- 10 7) 6))

following a formatting convention known as * pretty-printing*,
in which each long combination is written so that the operands are
aligned vertically. The resulting indentations display clearly the
structure of the expression. ^{6}

Even with complex expressions, the interpreter always operates in the
same basic cycle: It reads an expression from the terminal, evaluates
the expression, and prints the result. This mode of operation is
often expressed by saying that the interpreter runs in a *
read-eval-print loop*. Observe in particular that it is not
necessary to explicitly instruct the interpreter to print the value of
the expression. ^{7}