ALGOL 60 Revised(ID:174/alg043)

Revised report of IAL committee 

Revised report by IAL Committee - still lacked standard I/O - or as the notes put it "We recommend that the problems of input-output be returned to IFIP WG2.1 for solution."

Also known as Algol 60 (Rome) - as opposed to Algol 60 (Munich) - after the location of the discussion of the ISO WG.

Related languages
ALGOL 60 => ALGOL 60 Revised   Evolution of
ALGOL 60 Revised => ALGOL 60 Modified   Revision
ALGOL 60 Revised => ALGOL 68   Evolution of
ALGOL 60 Revised => Algol S   Revision
ALGOL 60 Revised => ALGOL W   Evolution of
ALGOL 60 Revised => ALGOL X   Evolution of
ALGOL 60 Revised => ALGOL Y   Evolution of
ALGOL 60 Revised => APLGOL   Influence
ALGOL 60 Revised => ASLIP   Written using
ALGOL 60 Revised => Atlas Autocode   Influence
ALGOL 60 Revised => BALM   Strong, Influence
ALGOL 60 Revised => CORAL 66   Based on
ALGOL 60 Revised => CPL   Implementation
ALGOL 60 Revised => DASH   Extension of
ALGOL 60 Revised => DCALGOL   Augmentation of
ALGOL 60 Revised => DMALGOL   Augmentation of
ALGOL 60 Revised => DTALGOL   Augmentation of
ALGOL 60 Revised => Fortran 90   Influence
ALGOL 60 Revised => GRAAL   Extension of
ALGOL 60 Revised => Graphic ALGOL   Extension of
ALGOL 60 Revised => Language for Class Description   Extension of
ALGOL 60 Revised => LCC   Influence
ALGOL 60 Revised => Micro-Algol   Implementation
ALGOL 60 Revised => Realtime Algol   Implementation
ALGOL 60 Revised => S-Algol   Augmentation of
ALGOL 60 Revised => SESPOOL   Derivation of
ALGOL 60 Revised => SLPL   Extension of
ALGOL 60 Revised => SNAP   Extension of
ALGOL 60 Revised => TEMPO   Influence
ALGOL 60 Revised => UNIVAC 1108 ALGOL   Implementation
ALGOL 60 Revised => Whetstone Algol   Implementation

  • Higman, B "What EVERYBODY should know about ALGOL" view details
          in The Computer Journal 6(1) April 1963 view details
  • Naur, Peter (ed) "Revised Report on the Algorithmic Language ALGOL 60 view details
          in Goodman, Richard (ed) "Annual Review in Automatic Programming" (4) 1964 Pergamon Press, Oxford view details
  • Naur, Peter (ed) "Revised Report on the Algorithmic Language ALGOL 60" view details
          in [ACM] CACM 6(01) (January 1963) view details
  • Ryder, KL "Note on an ALGOL 60 compiler for Pegasus I" view details Abstract: The Computer Journal, Volume 6, Issue 4, pp. 336-338: Abstract.

    Note on an ALGOL 60 compiler for Pegasus I
    KL Ryder

    Hawker Siddely Aviation Ltd., Hatfield, Herts., UK

    This note gives a brief description of an ALGOL 60 compiler which implements most of ALGOL 60 including recursive facilities. Comparison is made with the Pegasus Autocode, and the effort involved and reasons for writing are given.

          in The Computer Journal 6(4) January 1964 view details
  • Utman, R. E. "Suggestions on ALGOL 60 (ROME) issues" view details Abstract: At the IFIF WG 2.1 meeting in Munich it was recommended that the ALGOL report as modified bv the Rome authors' meeting be submitted as an ISO standard programming language. At the same time it was recommended that a subset be defined which would form a part of the standard.
    Since there were five problem areas defined, but not solved, at Rome, X3.4.2 felt that suggestions on their resolution should be prepared for each of these. Moreover, X3.4.2 feels that though ALGOL is satisfactorY as a publication language, it would be absolutely necessary to develop an input-output facility for the  language before it should be considered as a standard programming language.
    This document contains a brief discussion of the five problem areas and other issues, together with recommended positions on each. We recommend that the problems of input-output be returned to IFIP WG2.1 for solution.
    Finally, it is an assumption in X3.4.2 (which we wish made explicit) that implementation of a standard ALGOL subset would in no way imply implementation of full ALGOL 60 (ROME).
    The following issues and problem areas of ALGOL 60 (ROME)
    are treated herein
    1. Side effects in function designators,
    2. General versus restricted "call by name"
    3. "Own" variables and arrays
    4. Static versus dynamic "for" statements
    5. Conflict between Specification and Declaration
    Also considered are
    a. Function designator call statements
    b. Abnormal exits from function designators
    c. Numeric labels
    d. Initialization of "own" variables
          in [ACM] CACM 6(01) (January 1963) view details
  • Zemanek , H review of revised report view details Abstract: The revised report gives a complete defining description of the international algorithmic language ALGOL 60. The revision has been made at a meeting of some of the authors of the original report on ALGOL 60 held in Rome, Italy, on 2-3 April 1962 and includes corrections of some errors, elimination of some ambiguities and some clarifications of the original report. No extensions were considered and items like side effects, call by name, static or dynamic "own" and "for-statement" and conflict between specification and declaration were left for further consideration by the IFIP Working Group 2.1. This Working Group is now responsible for the language ALGOL; it has presented the revised report to ISO for standardization. It does not seem, however, that the revised report will become a standard in this form because ISO has asked Working Group 2.1 for some amendments, namely definition of a sub-set, characters for program symbols for punched cards and numerical operator facilities.

          in ACM Computing Reviews 4(05) September-October 1963 view details
  • Grau, A. A.; Hill, U. and Langmaack, H. "Translation of ALGOL 60" Handbook for Automatic Computation. Vol. 1, Part b Berlin: Springer-Verlag view details
          in ACM Computing Reviews 4(05) September-October 1963 view details
  • Rutishauser, H. "Description of ALGOL 60" Handbook for Automatic Computation. Vol. 1, Part a Berlin: Springer-Verlag view details
          in ACM Computing Reviews 4(05) September-October 1963 view details
  • Hopgood, FRA and Bell, AG "The Atlas ALGOL preprocessor for non-standard dialects" pp360-364 view details
          in The Computer Journal 9(4) 1967 view details
  • McEwan, AT "An Atlas Autocode to ALGOL 60 translator" pp353-359 view details
          in The Computer Journal 9(4) 1967 view details
  • Murphy, J. W. Review of Ruitishauser 1965 and Grau 1965 in the Computer Journal 11(3) 1968 view details Abstract: In the words of the publishers 'the aim of the Handbook for Automatic Computation is to supply the computing scientist with a selection of tested algorithms. . . . written in the algorithmic language ALGOL 60'. The first two parts, which are reviewed here, are introduced to provide the theoretical background and are concerned with a description of ALGOL 60 and a description of translating ALGOL 60, respectively.
    Part a restricts itself to the IFIP subset of ALGOL and thereby eliminates discussion of the more controversial aspects of the language. This is in keeping with the stated intention for the whole handbook in that all programs shall either adhere to this subset or the deviations shall be clearly stated. The collected algorithms will then run successfully with most existing ALGOL compilers. The bulk of the book was modelled after lectures given at the Swiss Federal Institute of Technology, Zurich.
    There seem to be two possible strategies for writing a book such as this. One is to exhibit the revised ALGOL report (and/or the IFIP subset) and to supplement these by examples so chosen that they illustrate the semantic content of the language, highlighting any areas of ambiguity. The other is to reformulate the definition of ALGOL and to illustrate this in like manner. Both methods are used here. To my mind the revised ALGOL report still serves as the best available definition of the language, although the syntactic diagrams presented do constitute a useful alternative viewpoint. The value of the work lies in the fact that it does enable the reader to obtain a clear impression of how the ALGOL language can be used to solve numerical problems, not with elegance alone but also with effect and with economy of effort. In consequence it can be claimed to supplement the revised ALGOL report in a very desirable manner.
    Part b is concerned with an ALGOL translator whose main purpose quite escapes me. It transforms an unspecified dialect of ALGOL into the symbolic assembly language for a non-existent machine. The presentation of the translator program, which takes more than half of the available space, is in the style of a novel written in an original form of ALGOL, complete with Greek, Gothic and other symbolic notation. It is extremely curious that all questions of syntax analysis and statement recognition are largely ignored, being assumed to have been performed in an undiscussed prepreparatory pass, whilst it is pedantically footnoted that a symbol, which approximates the reflection of a question mark, is used to denote ; in an ALGOL comment. It is just this type of inconsistency which leaves me with the feeling that the book is not a good introduction to compiler writing. The written text is mainly concerned with questions of storage allocation and choice of object code, and can be used to build up a reasonable picture of the state of a compiled ALGOL program for an 'average' implementation. This can be used to illustrate the basic inefficiencies of machine utilisation which comprise the premium paid to gain the many advantages in using a language such as ALGOL. The increased readability obtained through presenting the translator program written in 'ALGOL' itself highlights one of these advantages. It becomes apparent that the first entry into the procedure 'check for the same identifier in the same block' on page 175, during the initialisation of the identifier list, prejudices the entire translation.
    This is not the first venture of the publishers into the production of a Handbook of this type, which is intended to be used by workers in the field. In particular I am familiar with their Handbook of Physics and a very useful set of volumes it is. If the Handbook for Automatic Computation maintains the standard set in other fields then undoubtedly the volumes will constitute a very desirable addition to the literature. However, one would hope that they have the strength of mind to keep to the two ideals of a restriction to the IFIP subset and to publish only tested algorithms. It is with these features that the primary value of the Handbook rests.

          in The Computer Journal 9(4) 1967 view details
  • Sammet, Jean E. "Roster of Programming Languages for 1973" p147 view details Extract: Description
    A language developed jointly in the U.S. and Europe. Suitable for expressing solutions to problems requiring numeric computations and some logical processes. Has no officially defined input/output. Revised ALGOL 60 (with input/output specifications added) has been approved as an intennational standard.

          in ACM Computing Reviews 15(04) April 1974 view details
  • R.M. De Morgan, I.D. Hill and B.A. Wichman "Modified report on the algorithmic language ALGOL 60" view details
          in The Computer Journal view details
  • RM De Morgan, ID Hill and BA Wichmann "A supplement to the ALGOL 60 revised report" view details External link: Online copy
          in The Computer Journal 19(3) 1976 view details
  • George Gray "UNIVAC and ALGOL" Unisys History Newsletter 6(2) June 2002 view details Extract: Information
    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$                                            
                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 External link: Online copy at UNISIS History
          in The Computer Journal 19(3) 1976 view details

    • NASE A60 Interpreter