CS655: Programming Languages

University of Virginia, Department of Computer Science
CS655: Programming Languages
Spring 2000

Languages Summary

The point of this excersise wasn't to learn a lot of specific details about the various Algol-like language, but to see how different language goals and guiding principles led to different language features. You aren't expected (e.g., on your final) to be able to answer specific questions about details of a particular language, but are expected to be able to explain what a feature means and its implications on programming, and speak coherently about the design principles reflected in different language design decisions.

Summary

The group answers are in the table below. I have excercised only limited editorial control on these entries, so I don't necessarily agree with the objective answers listed here (but I believe they are all at least defensible).

Algol60 Algol68 BLISS C Pascal

Years under Development 1958-1963 1965-1975 1969-1971 1970, 1978, - 1971, 1973, -

Goals Language for publishing algorithms, universal programming language Good language for describing algorithms, advance state of language description Support systems programming with a high-level language; design for modularity, flexibility and reuse. Ease/size of implementation, add types to BCPL, useful for writing OS Language for teaching programming, write reliable, efficient programs

Guiding Principles Support structured programming, use mathematical notations, machine independence Othogonality above all, extensiblity Allow low-level systems programming with a high-level language Generality/Simplicity, minimize learning curve, flexibility Simplicity, easily describing using formal semantics

Types Integer, real, boolean, arrays. No user-defined types or records. Some automatic coercions (real -> integer) simple and compound types, arbitrary combinations, automatic type coercions no manifest types, dimensioned arrays many including struct (records), union (untagged), enum user-defined symbolic scalar, record, set and subranges; arrays where bounds of array are part of its type

Variables must be declared and typed; introduced block structured static scoping; own for persistent variables must be declared, stack and head based, anonymous structures must be declared but no types (other than array bounds) Program, file, function and block scopes; storage class (register, auto, static, extern); pointers must be declared, forward declarations for recursion

Control Structures compound statements; begin ... end blocks; if-then-else (but no endif); complex for loop; goto All from Algol60, expression language (all statements have values), collateral vs. closed clauses (can control parallelism) No goto, expression language, support for coroutines using create and exchj. All from Algol60, { ... } bloacks, break and continue, tagged switch All from Algol60 including goto, no escape from loops (break)

Procedures Recursion; call-by-name (default), call-by-value (if declared); procedure evaluation describe as copying body text Pass-by-value, pass-by-reference; treated as first class values (can pass, return, assign, define inline) Pass-by-value (can pass references) Separate declaration and definition, no nested functions, pass-by-value (can pass pointers) Procedures and functions are different, pass-by-value or pass-by-reference (must declare), pass as parameters

Most Interesting Aspects Formal syntax description, introduced block structure, support for recursion Support for concurrency, general operator overloading, garbage collection Explicit dereferencing required using dots, support for coroutines, array declarations define an accessing algorithm, can change representation without breaking program (hints of data abstraction) Pointer manipulation, idiomatic expressions (++, -=), compact syntax Targeted academic environment, but widely used in industry

Little Mistakes some ambiguities (as described by Knuth); dangling else problem; designed by a committee (little evidence for this in actual language spec, besides need for three languages - reference, publication, machine.) type sizes unspecified, no labels in case statement, allows spaces in variable names, implicit dereferencing awkward syntax required for explicit dereferncing ("all those dots!"), multiple exit keywords Pointers (was there a better alternative?), no nested functions (was this a mistake?) Unions (can violate type safety), distinction between procedures and functions, no dynamic strings, ambiguous type equivalence (name or structure), set on 1-pass compilation

Biggest Mistake Call-by-name is hard to understand and analyze Too complex (took orthogonality too far); took too long to produce readable language description Machine dependence (designed around PDP-10), no typing Lack of type safety File handling (strictly sequential), lack of flexiblity

Excuses First formally described language; introduced many new concepts Very ambitious goals Focused on an actual systems project Size constraints, BCPL history (no types), desire for flexibility Goal of simplicity, teaching language

	Algol60	Algol68	BLISS	C	Pascal
Years under Development	1958-1963	1965-1975	1969-1971	1970, 1978, -	1971, 1973, -
Goals	Language for publishing algorithms, universal programming language	Good language for describing algorithms, advance state of language description	Support systems programming with a high-level language; design for modularity, flexibility and reuse.	Ease/size of implementation, add types to BCPL, useful for writing OS	Language for teaching programming, write reliable, efficient programs
Guiding Principles	Support structured programming, use mathematical notations, machine independence	Othogonality above all, extensiblity	Allow low-level systems programming with a high-level language	Generality/Simplicity, minimize learning curve, flexibility	Simplicity, easily describing using formal semantics
Types	Integer, real, boolean, arrays. No user-defined types or records. Some automatic coercions (real -> integer)	simple and compound types, arbitrary combinations, automatic type coercions	no manifest types, dimensioned arrays	many including struct (records), union (untagged), enum	user-defined symbolic scalar, record, set and subranges; arrays where bounds of array are part of its type
Variables	must be declared and typed; introduced block structured static scoping; own for persistent variables	must be declared, stack and head based, anonymous structures	must be declared but no types (other than array bounds)	Program, file, function and block scopes; storage class (register, auto, static, extern); pointers	must be declared, forward declarations for recursion
Control Structures	compound statements; begin ... end blocks; if-then-else (but no endif); complex for loop; goto	All from Algol60, expression language (all statements have values), collateral vs. closed clauses (can control parallelism)	No goto, expression language, support for coroutines using create and exchj.	All from Algol60, `{ ... }` bloacks, break and continue, tagged switch	All from Algol60 including goto, no escape from loops (break)
Procedures	Recursion; call-by-name (default), call-by-value (if declared); procedure evaluation describe as copying body text	Pass-by-value, pass-by-reference; treated as first class values (can pass, return, assign, define inline)	Pass-by-value (can pass references)	Separate declaration and definition, no nested functions, pass-by-value (can pass pointers)	Procedures and functions are different, pass-by-value or pass-by-reference (must declare), pass as parameters
Most Interesting Aspects	Formal syntax description, introduced block structure, support for recursion	Support for concurrency, general operator overloading, garbage collection	Explicit dereferencing required using dots, support for coroutines, array declarations define an accessing algorithm, can change representation without breaking program (hints of data abstraction)	Pointer manipulation, idiomatic expressions (`++`, `-=`), compact syntax	Targeted academic environment, but widely used in industry
Little Mistakes	some ambiguities (as described by Knuth); dangling else problem; designed by a committee (little evidence for this in actual language spec, besides need for three languages - reference, publication, machine.)	type sizes unspecified, no labels in case statement, allows spaces in variable names, implicit dereferencing	awkward syntax required for explicit dereferncing ("all those dots!"), multiple exit keywords	Pointers (was there a better alternative?), no nested functions (was this a mistake?)	Unions (can violate type safety), distinction between procedures and functions, no dynamic strings, ambiguous type equivalence (name or structure), set on 1-pass compilation
Biggest Mistake	Call-by-name is hard to understand and analyze	Too complex (took orthogonality too far); took too long to produce readable language description	Machine dependence (designed around PDP-10), no typing	Lack of type safety	File handling (strictly sequential), lack of flexiblity
Excuses	First formally described language; introduced many new concepts	Very ambitious goals	Focused on an actual systems project	Size constraints, BCPL history (no types), desire for flexibility	Goal of simplicity, teaching language

Buried Treasures:
Algol68: anonymous structures and functions, support for concurrency (not really burried?)
BLISS: defining array accessing algorithms (not buried in that most data abstraction language have adopted something similar but much more general)

Reasons for Success:
C: simple to learn, efficient, compact and expressive syntax, leverage UNIX's success, good implementations for many platforms, vast right-wing conspiracy (?).

University of Virginia
CS 655: Programming Languages

cs655-staff@cs.virginia.edu
Last modified: Mon Feb 26 12:48:21 2001