Principles of Programming Language Design
Abstraction Avoid requiring something to be stated more than
once; factor out the recurring pattern.
Automation Automate mechanical, tedious, or error-prone
Defense in Depth Have a series of defenses so that if an error
is not caught by one, it will probably be caught by another.
Elegance Confine your attention to designs that look
good because they are good.
Impossible Error Making errors impossible to commit is preferable to
detecting them after their commission.
Information Hiding The language should permit
modules designed so that (1)
The user has all the information needed to use the module correctly, and
nothing more; (2) the implementor has all the information needed to implement
the module correctly, and nothing more.
Labeling Avoid arbitrary sequences more than a few items long;
do not require the user to know the absolute
position of an item in a list. Instead, associate a meaningful label with each
item and allow the items to occur in any order.
Localized Cost Users should pay only for what they use; avoid
Manifest Interface All interfaces should be apparent (manifest)
in the syntax.
Orthogonality Independent functions should be controlled by
Portability Avoid features or facilities that are dependent on
a particular computer or a small class of computers.
Preservation of Information The language should allow the
representation of information that the user might know and that the compiler might
Regularity Regular rules, without exceptions, are easier to
learn, use, describe, and implement.
Responsible Design Do not ask users what they want; find out what
Security No program that violates the definition of the
language, or its own intended structure, should escape detection.
Simplicity A language should be as simple as possible. There
should be a minimum number of concepts with simple rules for their combination.
Structure The static structure of the program should correspond
in a simple way to the dynamic structure of the corresponding computations.
Syntactic Consistency Similar things should look similar,
different things different.
Zero-One-Infinity The only reasonable number
are zero, one, and infinity.
Adapted from Bruce J. MacLennan,
Principles of Programming Languages Design, Evaluation, and
third ed., Oxford University Press, 1999.
Return to MacLennan's home page
Send mail to Bruce MacLennan / MacLennan@cs.utk.edu
Thu Sep 10 23:52:30 EDT 1998