Unisys History Newsletter

Volume 6, Number 2
June 2002

UNIVAC and ALGOL

by George Gray

The Beginnings of ALGOL

The ALGOL language was the first major language to be designed by a committee with members from many different organizations. Preliminary work was done by committees in Germany and the United States, and a joint meeting in Zurich, Switzerland in 1958 prepared a report on the International Algorithmic Language. This version became known as ALGOL 58. Unlike FORTRAN, MATHMATIC and other languages developed by computer manufacturers, no ALGOL compiler was written by the committee. It just drew up the specifications of the language. The task of compiler writing was left to whoever decided to undertake it.

Various groups in Europe wrote ALGOL compilers at this time, but in the United States the only one which had significant use was one Burroughs wrote for its model 220 computer. Some languages emerged which were derivatives of ALGOL, such as NELIAC (Navy Electronics Laboratory International ALGOL Compiler) and MAD (Michigan Algorithm Decoder). NELIAC was first implemented on the computers which UNIVAC developed for the Navy Tactical Data System, and a compiler was later written for the UNIVAC 1108.

MAD

MAD was developed at the University of Michigan in 195960 for the IBM 704. It was very widely used on the IBM 7090 and 7094, the Philco 2000, and UNIVAC 1100 computers during the 1960s for the purpose of teaching programming to college students. Michigan published a reference manual, but most students learned MAD from the MAD PRIMER, written by Elliott Organick of the University of Houston and distributed by Ulrichs Book Store of Ann Arbor, Michigan. Organick also wrote a more widely used FORTRAN PRIMER. The MAD compiler for the UNIVAC 1100 computers called RALPH was developed at the University of Maryland. The name RALPH is an acronym of sorts: Reentrant Algorithmic Language Processor with H just for the H of it. (The explanation of the acronym is supplied by George Baltz, formerly at the University of Maryland.) The RALPH processor could compile either FORTRAN or MAD, depending on the option selected.

MAD is perhaps most famous for the line printer picture of Alfred E. Neumann which was printed when an attempted compilation had too many errors. Underneath the picture it printed the caption: See this man about your program--He might want to publish it. He never worries--but from the looks of your program, you should. MAD faded from the scene in the 1970s.

A very simple MAD program follows:

                                                                    
            INTEGER A                                                           
 START      A = 1                                                               
            WHENEVER A .G. 0                                                    
            PRINT COMMENT $ A GTR 0$                                            
            OTHERWISE                                                           
            PRINT COMMENT $A LEQ 0$                                             
            END OF CONDITIONAL                                                  
            PRINT COMMENT $ END $                                               
            END OF PROGRAM

The WHENEVER OTHERWISE END OF CONDITIONAL is equivalent to an if-else statement.

ALGOL 60

Further international committee meetings in 1959 and 1960 revised and improved the ALGOL specifications, creating ALGOL 60. At this time many computer programmers expected (or at least hoped) that ALGOL would displace FORTRAN as the principal language for scientific and engineering programming. ALGOL 60 compilers were written for many types of computers, but ALGOL could not overcome the headstart which FORTRAN already had, and in the United States its only major use was on Burroughs machines. ALGOL was used to write the second version MCP operating system for the B5000 computer (when it switched from drum to disk as the primary mass storage device). At this time it was remarkable to have an operating system as complex as MCP, and even more remarkable for it to be written in a higherlevel language.

UNIVAC developed the 1107, its secondgeneration scientific computer, between 1960 and 1962. There was much talk about ALGOL being its primary language. (In 1959, it had even been proposed to develop an ALGOL compiler for UNIVACs LARC supercomputer, but the LARC project was so far over budget that the proposal never got anywhere and the LARC used a modified FORTRAN). At that time, the company's resources were spread very thin, and much of the software development was farmed out. UNIVAC wrote an operating system (EXEC I) and an assembler (SLEUTH), but development of the FORTRAN and ALGOL compilers was assigned to General Kinetics, a firm in Arlington, VA. General Kinetics ultimately failed to produce either one. The COBOL compiler was assigned to Computer Sciences Corporation (CSC). CSC, with the approval of Bob Bemer, UNIVACs Director of Systems Programming, altered the terms of the contract by writing its own operating system (EXEC II) and producing COBOL for it instead. EXEC II was an excellent operating system, and CSC also developed a FORTRAN compiler for it. Case Institute of Technology in Cleveland provided an ALGOL compiler for the EXEC II environment, as part of the arrangement by which it acquired an 1107. The Case Tech compiler was completed in 1964, and computer science students there were trained in ALGOL, rather than FORTRAN. However, FORTRAN was the most widely used language on the 1107.

SIMULA and NU ALGOL

In 1962 Bob Bemer became aware of the SIMULA language which had been proposed by Kristen Nygaard and Ole-Johan Dahl of the Norwegian Computing Center. SIMULA was designed for the analysis of systems which can be modeled as a series of events, such as a service counter serving a line of customers. In 1963 UNIVAC agreed to provide an 1107 to the Norwegian Computing Center at a discounted price in exchange for the development of SIMULA as an extension to the Case Tech ALGOL. The 1107 was delivered in August 1963, and the first version of SIMULA was completed in December 1964.

SIMULA used a framework of activities and processes. An activity was a class of similar entities called processes. An activity was constructed in a manner similar to an ALGOL procedure, having a declaration (naming the activity and listing its parameters), operations (statements), and data items. For example:

activity machine (speed, holesize);
	real speed, holesize;
	begin
	   data items
	   operation statements;
	end

An instance of machine might be NewMachine (3, 0.625). [This example is taken from UNIVAC 1106/1108 SIMULA (1971).] When SIMULA was revised in 1967, the terms class and object were used in place of activity and process.

In 1965 the Technical Institute at Trondheim, Norway obtained its own 1107 at a discount and began working on a new ALGOL compiler. It was adopted by UNIVAC which named it Norwegian University ALGOL (NU ALGOL). A sample NU ALGOL program follows:

  BEGIN                                                                        
      comment program to find sum of set of numbers;                           
      comment declare X and SUM to be real;                                    
      REAL X,SUM;                                                              
      comment format f1 indicates 5 columns, 1 decimal place;                  
      FORMAT F1(A,D5.1);                                                       
      FORMAT F2('   sum = ',D7.1,A1.0);                                        
      FORMAT F3(x1,D5.1,A1.0);                                                 
      SUM:=0.0;                                                                
      comment read input value using format f1;                                
      comment when no more data, go to p2;                                     
  P1: READ(CARDS,F1,X,P2);                                                     
      WRITE(PRINTER,F3,X);                                                     
      SUM:=SUM + X;                                                            
      GO TO P1;                                                                
  P2: WRITE(PRINTER,F2,SUM);                                                   
  END;

NU ALGOL found modest use within the UNIVAC 1100 customer base. The University of Wisconsin, which was making the transition from a Burroughs B5500 to a UNIVAC 1108, developed various extensions to NU ALGOL including the capability of handling ASCII characters in place of the 1108s native Fieldata character set. Wisconsin wrote an e-mail system using NU ALGOL.

ALGOL 68

The international committee continued to meet throughout the mid-1960s, trying to reach agreement on an update the 1960 ALGOL standard. Niklaus Wirth from Switzerland and C.A.R. Hoare of Oxford University submitted a proposal, which the committee rejected. Nevertheless, it was implemented on various computers as ALGOL W, and after further change it became Pascal. Ultimately, the committee adopted a standard for a fairly complex language which was called ALGOL 68, which Wirth, Hoare, and various other computer scientists regarded as a monstrosity. The University of Paris-Sud in France wrote an ALGOL 68 compiler for the UNIVAC 1108 during the mid-1970s. It was a 9-pass compiler and was written in FORTRAN. It was not very widely used.

Conclusion

It is unfortunate that ALGOL was not able to displace FORTRAN in the early 1960s and that FORTRAN took so long to add any block structuring features. In the 1970s, Pascal briefly took over as the language of choice for training beginning computer science students, however its primitive i/o capabilities meant that it was not suitable for writing production program systems. Pascal was eventually displaced by C, which is block structured, but has other problems of its own. One might imagine a more orderly alternative universe where ALGOL did prevail.