Dialects: Burroughs/Unisys, Elliott, Simula & Others

23.1 Burroughs Extended ALGOL and Unisys MCP

The Burroughs B5000 (1961), B5500, B6500/B6700 and their descendants (today's Unisys ClearPath MCP systems) were designed for ALGOL: a hardware stack, display registers, descriptors for arrays (with hardware bounds checking) and tagged memory. There was no assembler: the OS was written in ESPOL (Executive Systems Problem Oriented Language), later NEWP.

Burroughs/Unisys ALGOL dialects:

Extended ALGOL — ALGOL 60 plus strings, pointers into character arrays (POINTER, REPLACE, SCAN), DEFINE macros, CASE statements, FILE declarations and READ/WRITE with FORMATs, EVENTs and tasking (PROCESS, CALL, WAIT, CAUSE).

DCALGOL — for data communications programs.

DMALGOL — for the DMSII database system.

NEWP — systems programming (unsafe constructs require explicit marking).

Illustrative flavor of Extended ALGOL (syntax details vary between compiler releases; not runnable without an MCP system):

BEGIN
   FILE OUT (KIND = REMOTE);
   INTEGER I;
   FORMAT F ("SQUARE OF ", I3, " IS ", I6);
   FOR I := 1 STEP 1 UNTIL 10 DO
      WRITE (OUT, F, I, I * I);
END.

23.2 Elliott ALGOL

Tony Hoare led the team at Elliott Brothers that built an ALGOL 60 compiler for the Elliott 803 (1962). It was notable for its careful subset design, fast compilation, and run-time checking of array subscripts — Hoare later recalled (in his Turing Award lecture) that when customers were asked whether they wanted an option to switch the checks off for efficiency, they unanimously declined. Hoare invented Quicksort around this time (1959–61) and published it in ALGOL 60. Emulators of the Elliott 803 can run the original compiler today.

23.3 Simula 67: ALGOL 60 plus classes

Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center extended ALGOL 60 into Simula I (1962–65, for discrete-event simulation) and then Simula 67, a general-purpose language that is almost a superset of ALGOL 60. It introduced classes, objects, inheritance (prefixing), virtual procedures, references (ref), and coroutines — the foundation of object-oriented programming (C++, Smalltalk, Java, C#).

Runnable with GNU Cim (cim point.sim && ./point):

Note the ALGOL heritage: Begin ... End blocks, Real Procedure, :=, call by value/name rules (Simula defaults differ: simple parameters default to by value), and block structure. Simula uses reserved words (case-insensitive) rather than stropping.

Begin
   Class Point(x, y); Real x, y;
   Begin
      Real Procedure Dist;
         Dist := Sqrt(x ** 2 + y ** 2);
   End;

   Point Class Point3(z); Real z;
   Begin
   End;

   Ref(Point) p;
   p :- New Point3(3, 4, 12);
   OutText("Distance in plane: ");
   OutFix(p.Dist, 2, 8);
   OutImage;
End

23.4 Other ALGOL-derived languages

From ALGOL 58; US Air Force systems, still maintained in places ALGOL 58 dialects

Manchester; ALGOL-like with its own syntax Cambridge/London; ALGOL-inspired → BCPL → B → C

Wirth & Weber; generalization of ALGOL 60 IBM; blocks and scoping from ALGOL, plus FORTRAN and COBOL features

UK military real-time language based on ALGOL 60 Wirth; from ALGOL W

St Andrews (Ron Morrison); orthogonal ALGOL successor ALGOL 68 dialects

ALGOL 68-R, 68C, 68S, 68RS, FLACC, a68g (Part III)

🧪 Part II Exercises

Write a procedure exchange that correctly swaps two simple integer variables, then show (with output) why no procedure can correctly swap i and a[i] in all orders under call by name.

Use Jensen's device to write product(i, lo, hi, term) and compute n! and the Wallis product approximation of π/2.

Write a sum call that computes the double sum of i × j for 1 ≤ i, j ≤ 10 using nested Jensen's devices.

Run the Man or Boy test in MARST for k = 0 ... 12 and compare with the table in §17.5. Find the largest k your system can handle.

Write a procedure that receives a label parameter and use it to escape from deep recursion when a solution is found (e.g., first solution of the 8-queens problem).

Translate a MARST program to C and study the generated thunks for a by-name parameter. Draw the activation records and static links for a call of sum(k, 1, 3, a[k]).

Implement merge sort in ALGOL 60 using a dynamic work array allocated in an inner block.

Write a character-frequency counter using inchar with an index string containing the alphabet.

Translate the ALGOL W linked-list program in §22.3 into ALGOL 60 by simulating records with parallel integer arrays and a free list.

List five ambiguities from Knuth's "Remaining Trouble Spots" and write a small program that would behave differently under two plausible interpretations of each.