No policy is a good policy

[Richard M. Stallman <RMS at MIT-AI>]

Common Lisp is an attempt to compromise betwen several goals:
cleanliness, utility, efficiency and compatibility both between
implementations and with Maclisp.  On any given issue, it is usually
possible to find a "right" solution which may meet most of these goals
well and meet the others poorly but tolerably.  Which goals have to be
sacrificed are different in each case.

For example, issue A may offer a clean, useful and efficient solution
which is incompatible, but in ways that are tolerable.  The other
solutions might be more compatible but worse in general.  Issue B may
offer a fully upward compatible solution which is very useful and fast
when implemented, which we may believe justifies being messy.  If we
are willing to consider each issue separately and sacrifice different
goals on each, the problem is easy.  But if we decide to make a global
choice of how much incompatibility we want, how much cleanliness we
want, etc., then probably whichever way we decide we will be unable to
use both the best solution for A and the best solution for B.  The
language becomes worse because it has been designed dogmatically.

Essentially the effect of having a global policy is to link issues A
and B, which could otherwise be considered separately.  The combined
problem is much harder than either one.  For example, if someone found a new
analogy between ways of designing the sequence function and ways of
designing read syntaxes for sequences, it might quite likely match
feasible designs for one with problematical designs for the other.
Then two problems which are proving enough work to get agreement on
individually would turn into one completely intractable problem.

It is very important to finish Common Lisp reasonably quickly, if the
effort is to be useful.  The study of philosophy of language design is
a worthy field but a difficulty one.  There are many more years of
work to be done in it.  If we make solving this field part of the plan
for designing Common Lisp, we will not be finished in time to do the
job that Common Lisp was intended for: to enable users of different
Maclisp descendents to write portable programs.