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.


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

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 (?).

CS 655 University of Virginia
CS 655: Programming Languages
Last modified: Mon Feb 26 12:48:21 2001