COMPUTING SCIENCE 370
Programming Languages

Algol-60

Structural Organization

• Imperative -- two types of imperative constructs:

  • Computational (i.e., assignment    := ).
  • Control flow (e.g., for, if-then-else, goto).
  • No I/O -- handled by library procedures.

• Compiled -- no separate compilation.

• Block-structured -- constructs may be nested.
  E.g.,

  main       binomial coefficient                  factorial

• Declarations are explicit.

  • variable declarations
  • procedure declarations
  • switch declarations

• Supports recursion.

• Provides dynamic arrays.

• Run-time binding.

• Stack is main run-time data structure.

  • Holds activation records for procedures and blocks.
  • Dynamic memory allocation by pushing/popping activation records.

Syntactic Structures

• Lexics -- free format.

  • White space as token separators.
  • Allows indentation as an aid to understanding program structure. (See the Structure Principle.)
    E.g., indentation can be used to indicate the extent of a loop:

       for i := 1 step 1 until N do
          sum := sum + Data[i];
       average := sum / N
    

• Algol is defined on three levels with common syntax, but different lexics:

  • Reference language (used in the Algol-60 Report)
    E.g.,
       a[i+1] := (a[i] + pi x r^2) / 6.02₁₀23;

  • Publication language -- allows math-like conventions for printing algorithms (e.g., subscripts, Greek letters); in practice, has been the same as the reference language.
    E.g.,
       a_i+1 <- {a_i + π x r²} / 6.02 x 10²³;

  • Hardware representations -- implementation dependent. (See the Portability Principle)
    E.g.,
       a(/i+1/) := (a(/i/) + pi * r ** 2) / 6,02e23;
    or  A(.I+1.) .= (A(.I.) + PI * R 'POWER' 2) / 6.02'23.,
    or  a[i+1] := (a[i] + pi * r^2) / 6.02E23;

• Algol uses keywords.

  In general, special words can be denoted in three ways:

  1. Reserved words -- Special words cannot be used as identifiers by the programmer.
     E.g., Pascal words if and then.

  2. Keywords -- Special words are distinguished by marking them in an unambiguous way, e.g.,

     • preceding each keyword with #:    #IF

     • surrounding each keyword with quotes:    'if'

     • typing keywords in upper case:    IF i < 5

     • printing keywords in a different font:    if i < 5

     -	difficult to type
     -	not easily readable (except for different font)

  3. Keywords in context -- Compiler finds special words according to the context in which they are expected (as in FORTRAN and PL/I).
     E.g., PL/I:

       IF IF THEN
          THEN = 0;
       ELSE
          ELSE = 0;
     

  Most modern languages use reserved words.

  Note that the use of the word "keyword" as defined above is specific to textbook; many language references use "keyword" as synonymous with "reserved word".

• Algol follows the Zero-One-Infinity Principle:

  • No limit on the number of characters in an identifier.
  • Any expression is allowed as a subscript, including other array elements. (This also illustrates the Orthogonality Principle).
    E.g.,
       A[ 2 x B[i] - 1 ]
    or  Count[ if i > 100 then 100 else i ]

    The latter example illustrates Algol's conditional expression (like that in C).

• Dangling else problem -- There are two possible meanings for the statement

  if <cond1> then if <cond2> then <stmt1> else <stmt2>

  1. if <cond1> then
        if <cond2> then
           <stmt1> 
        else
           <stmt2>
     

  2. if <cond1> then
        if <cond2> then
           <stmt1> 
     else
        <stmt2>
     

  • Algol's simplistic solution: A conditional statement (if) is not allowed as the statement in a conditional statement. Instead, the intended structure must be explicitly shown using a block (begin-end pair):

    1. if <cond1> then
          begin
             if <cond2> then
                <stmt1> 
             else
                <stmt2>
          end
       

    2. if <cond1> then
          begin
             if <cond2> then
                <stmt1> 
          end
       else
          <stmt2>
       

  • Other languages solve the problem by:

    • Adopting a convention, usually that an else goes with the nearest preceding unmatched if (e.g., PL/I, C).

    • Using fully bracketed structures (e.g., Modula-2, Ada).

      1. IF <cond1> THEN
            IF <cond2> THEN
               <stmt1> 
            ELSE
               <stmt2>
            END
         END
         

      2. IF <cond1> THEN
            IF <cond2> THEN
               <stmt1> 
            END
         ELSE
            <stmt2>
         END
         

      Perhaps the ultimate example of fully bracketed structures is Algol 68 which uses the backward spelling of a structure's starting "keyword" to close the structure: if ... fi, case ... esac. The Unix Bourne shell follows Algol 68's bracketing principle, but uses do ... done for for, while and until loops instead of Algol 68's do ... od.