Simplicity: The language should be based upon as few ``basic concepts" as possible.Orthogonality: Independent functions should be controlled by independent mechanisms.
Regularity: A set of objects is said to be regular with respect to some condition if, and only if, the condition is applicable to each element of the set. The basic concepts of the language should be applied consistently and universally.
Type Completeness: There should be no arbitrary restriction on the use of the types of values. All types have equal status. For example, functions and procedures should be able to have any type as parameter and result. This is also called the principle of regularity.
Parameterization: A formal parameter to an abstract may be from any syntactic class.
Analogy: An analogy is a conformation in pattern between unrelated objects. Analogies are generalizations which are formed when constants are replaced with variables resulting in similarities in structure. Analogous operations should be performed by the same code parameterized by the type of the objects.
Correspondence: For each form of definition there exists a corresponding parameter mechanism and vice versa.
Clarity: The mechanisms used by the language should be well defined, and the outcome of a particular section of code easily predicted.Referential Transparency: Any part of a syntactic class may be replaced with an equal part without changing the meaning of the syntactic class (substitutivity of equals for equals).
Sub-types: A sub-type may appear wherever an element of the super-type is expected.
Expressivity: The language should allow us to construct as wide a variety of programs as possible.Example: user defined data types, functions and procedures. Binding, Scope, Lifetime,Extensibility: New objects of each syntactic class may be constructed (defined) from the basic and defined constructs in a systematic way.
Safety: Mechanisms should be available to allow errors to be detected.Type checking-static and dynamic, range checking
the Data Invariant: A data invariant is a property of an object that holds whenever control is not in the object. Objects should be designed around a data invariant.Information Hiding: Each ``basic program unit" should only have access to the information that it requires.
Explicit Interfaces: Interfaces between basic program units should be stated explicitly.
Privacy: The private members of a class are inaccessible from code outside the class.
Abstraction: Abstraction is an emphasis on the idea, qualities and properties rather than the particulars (a suppression of detail). An abstract is a named syntactic construct which may be invoked by mentioning the name. Each syntactic class may be referenced as an abstraction. Functions and procedures are abstractions of expressions and commands respectively and there should be abstractions over declarations (generics) and types (parameterized types). Abstractions permit the suppression of detail by encapsulation or naming. Mechanisms should be available to allow recurring patterns in the code to be factored out.Qualification: A block may be introduced in each syntactic class for the purpose of admitting local declarations. For example, block commands, block expressions, block definitions.
Representation Independence: A program should be designed so that the representation of an object can be changed without affecting the rest of the program.
Generalization: Generalization is a broadening of application to encompass a larger domain of objects of the same or different type. Each syntactic class may be generalized by replacing a constituent element with a variable. The idea is to enlarge of domain of applicability of a construct. Mechanisms should be available to allow analogous operations to be performed by the same code.polymorphism, overloading, generics
Efficiency: The language should not preclude the production of efficient code. It should allow the programmer to provide the compiler with any information which may improve the resultant code.Novice users of a programming language require language tutorials which provide examples and intuitive explanations. More sophisticated users require reference manuals which catalogue all the features of a programming language. Even more sophisticated students of a programming language require complete and formal descriptions which eliminate all ambiguity from the language description.Modularity: Objects of each syntactic class may be compiled separately from the rest of the program.