8.1 Overview of the Expression Language
Following Algol, the expression language is statically scoped. Each use of a variable is associated with a lexically apparent binding of that variable.
The expression language has latent as opposed to manifest types.  Types are associated with values (also called objects) rather than with variables.  (Some authors refer to languages with latent types as weakly typed or dynamically typed languages.)  Other languages with latent types are other dialects of Lisp, APL, and Snobol.  Languages with manifest types (sometimes referred to as strongly typed or statically typed languages) include Algol 60, Pascal, and C.
All objects created in the course of a computation, including procedures, have unlimited extent. No expression language object is ever destroyed.  The reason that implementations do not (usually!) run out of storage is that they are permitted to reclaim the storage occupied by an object if they can prove that the object cannot possibly matter to any future computation.  Other languages in which most objects have unlimited extent include other dialects of Lisp and APL.
Implementations are required to be properly tail-recursive. This allows the execution of an iterative computation in constant space, even if the iterative computation is described by a syntactically recursive procedure.  Thus, with a tail-recursive implementation, iteration may be expressed using the ordinary procedure-call mechanics, so that special iteration constructs are useful only as syntactic sugar.
Procedures are objects in their own right.  Procedures may be created dynamically, stored in data structures, returned as results of procedures, and so on.  Other languages with these properties include Common Lisp and ML.
Arguments to procedures are always passed by value, which means that the actual argument expressions are evaluated before the procedure gains control, whether the procedure needs the result of the evaluation or not.  ML, C, and APL are three other languages that always pass arguments by value. This is distinct from the lazy-evaluation semantics of Haskell, or the call-by-name semantics of Algol 60, where an argument expression is not evaluated unless its value is needed by the procedure.
The expression language, like most dialects of Lisp, employs a fully parenthesized prefix notation for expressions and (other) data; the grammar of the expression language generates a sublanguage of the language used for data.