Introduction: language evaluation criteria and influences on language design

This course does not teach a language; it teaches you to compare languages. Why did one language design a feature this way and another that way? Someone who asks this learns a new language quickly, chooses the right language, and uses the features of the language they use more consciously. The first week sets up the yardsticks we will use to weigh languages. On the midterm it comes as short-answer questions: “Which criterion does this feature affect?”, “What is orthogonality? Give an example from C.”

Golden rules:

1. Four criteria: readability, writability, reliability, cost.
2. Everything that affects readability also affects writability and reliability.
3. Orthogonality = no exceptions to the rule.
4. Language design is a series of trade-offs; while one criterion is gained, another is lost.

Why programming languages?

• The power to express ideas: the structures you can think of are limited by the structures of the language you know. Someone who knows the structures of other languages can imitate them in their own language.
• Choosing the right language: someone who knows only one language looks at every problem through that language.
• Learning new languages gets easier: concepts (binding, scope, parameter passing) carry over from language to language.
• Understanding implementation: knowing how a feature is implemented lets you use it efficiently (like the cost of recursion).
• Using a known language better and understanding the general development of computing.

Application domains (programming domains)

Evaluation criteria

Readability

The ease with which a program can be read and understood. Most of the maintenance cost is determined here.

• Simplicity: a small number of basic constructs. It has two enemies: feature multiplicity (more than one way to do the same job) and badly used operator overloading (a user-defined operator that does subtraction with +).

int count = 0;
count = count + 1;
count += 1;
count++;
++count;
System.out.println(count);

4

Four different spellings, the same job. Assembly, on the other hand, is extremely simple in the opposite direction: few constructs, but the program is long and unreadable.

• Orthogonality: a relatively small number of primitive constructs can be combined in a relatively small number of ways, and every possible combination is legal and meaningful. Shortcomings in C: a function can return a struct but not an array; parameters are passed by value, except arrays; a struct member can be any type except void, but an array element cannot be void or a function. Too much is also harmful: the exploding combinations in ALGOL 68.
• Data types: adequate type support. If there is no Boolean type, you write timeOut = 1; timeOut = true is much clearer.
• Syntax design: special words and the ends of compound statements. end if and end loop (Ada) give more information than a }. The form should reflect the meaning: the same word should not have different meanings depending on context (like the two meanings of static in C).

Writability

The ease of writing programs in a domain. In addition to what affects readability:

• Support for abstraction: being able to define and use complex structures while hiding the details. Process abstraction (a subprogram), data abstraction (a class for a tree node; in Fortran 77 you would need parallel integer arrays instead).
• Expressivity: being able to express the job in a short and suitable way. count++ is easier to write than count = count + 1, and a for loop is easier to write than the equivalent while.

Reliability

The program performing to its specification under all conditions.

• Type checking: catching type errors, preferably at compile time. Run-time checking is expensive, compile-time checking is cheap.
• Exception handling: being able to catch run-time errors and take corrective action.
• Aliasing: two names for the same cell. Restricting it increases reliability.

int[] a = {1, 2};
int[] b = a;
b[0] = 9;
System.out.println(a[0]);

9

• Readability and writability also affect reliability: a program written in unnatural ways is more likely to be wrong.

Cost

Programmer training, writing programs, compiling, executing, the language implementation system (a free compiler helped Java spread), the price of poor reliability (a failure in a critical system) and maintenance. In large systems the largest item is maintenance.

Summary table

Other criteria: portability (ease of moving a program from one implementation to another), generality (wide range of applications), well-definedness (completeness of the formal definition).

Design trade-offs

int[] big = new int[3];
try { big[3] = 1; } catch (ArrayIndexOutOfBoundsException e) { System.out.println("checked"); }

checked

Influences on language design

Computer architecture

Most of today’s computers have the von Neumann architecture: data and program are in the same memory, and the processor is separate. Instructions and data are moved from memory to the processor, and results are written back. This architecture gave rise to imperative languages:

• Variables model memory cells.
• Assignment models the movement of data between memory and the processor.
• Iteration is efficient on this architecture (instructions are in consecutive cells); recursion is more expensive.

Because the processor can execute instructions much faster than they can be fetched from memory, the speed of the connection between memory and processor limits the system: the von Neumann bottleneck.

Programming methodologies

Language categories

Object-oriented languages are not a separate category but are seen as an extension of imperative languages; scripting languages (Perl, Python, Ruby) and visual languages (.NET) are also in the imperative family.

Common mistakes

int count = 0;
count = count + 1;
count += 1;
count++;
++count;
System.out.println(count);

int[] a = {1, 2};
int[] b = a;
b[0] = 9;
System.out.println(a[0]);