ALGOL 58

From Wikipedia, the free encyclopedia
Jump to: navigation, search
ALGOL 58
Paradigm(s) procedural, imperative, structured
Designed by Friedrich L. Bauer, Hermann Bottenbruch, Heinz Rutishauser, Klaus Samelson, John Backus, Charles Katz, Alan Perlis, Joseph Henry Wegstein
Appeared in 1958
Influenced by

FORTRAN, IT, Plankalkül,[1]

Sequentielle Formelübersetzung
Influenced Most subsequent imperative languages (Algol-like)

ALGOL 58, originally known as IAL, is one of the family of ALGOL computer programming languages. It was an early compromise design soon superseded by ALGOL 60. According to John Backus[2]

"The Zurich ACM-GAMM Conference had two principal motives in proposing the IAL: (a) To provide a means of communicating numerical methods and other procedures between people, and (b) To provide a means of realizing a stated process on a variety of machines..."

ALGOL 58 introduced the fundamental notion of the compound statement, but it was restricted to control flow only, and it was not tied to identifier scope in the way that Algol 60's blocks were.

Name[edit]

Bauer attributes the name to Bottenbruch: "He [Bottenbruch] was also the man who coined at that time [1957] the word 'algorithmic language' (algorithmische Sprache) at least in Germany."[3]

History[edit]

There were proposals for a universal language by the Association for Computing Machinery (ACM) and also by the GAMM. It was decided to organize a joint meeting to combine them. The meeting took place from May 27 to June 2, 1958, at ETH Zurich and was attended by the following people:

The language was originally proposed to be called IAL (International Algebraic Language) but according to Perlis[4] this was rejected as an "'unspeakable' and pompous acronym". ALGOL was suggested instead, though not officially adopted until a year later. The publication following the meeting still used the name IAL.[5] Unresolved disagreements also led to a plan to define two dialects, ALGOL 58 and ALGOL 60[citation needed] but the name ALGOL 60 was eventually used for a specific language .[6]

By the end of 1958 the ZMMD-group had built a working ALGOL 58 compiler for the Z22 computer. ZMMD was an abbreviation for Zürich (where Rutishauser worked), München (workplace of Bauer and Samelson), Mainz (location of the Z22 computer), Darmstadt (workplace of Bottenbruch).

ALGOL 58 saw some implementation effort at IBM, but the effort was in competition with FORTRAN, and soon abandoned. It was also implemented at Dartmouth College on an LGP-30, but that implementation soon evolved into Algol 60. An implementation for the Burroughs 220 called BALGOL evolved along its own lines as well, but retained much of ALGOL 58's original character.[7]

ALGOL 58's primary contribution was to later languages; it was used as a basis for JOVIAL, MAD, NELIAC and ALGO. It was also used during 1959 to publish algorithms in CACM, beginning a trend of using ALGOL notation in publication that continued for many years.

Time line of implementations of ALGOL 58 variants[edit]

Name Year Author State Description Target CPU
ZMMD-implementation 1958 Friedrich L. Bauer, Heinz Rutishauser, Klaus Samelson, Hermann Bottenbruch Germany Z22
NELIAC 1958 Naval Electronics Laboratory USA AN/USQ-17
JOVIAL 1960 Jules Schwarz USA Was the DOD HOL prior to Ada (programming language) Various (see article)
BALGOL 1960 Joel Merner et al. USA Burroughs Corporation B220
MAD 1960 University of Michigan USA IBM 7090/7094 mainframe, then mid-1960s ported to Univac 1108
Dartmouth ALGOL 30 1962 Thomas Eugene Kurtz et al. - evolved into ALGOL 60 USA LGP-30
SUBALGOL 1962 Bob Braden, Lawrence M. Breed and Roger Moore USA BALGOL extension IBM 7090
ALGO ~ Bendix Corporation USA Bendix G-15

ALGOL 58's influence on ALGOL 60[edit]

  • IAL introduced the three-level concept of reference, publication and hardware language, and the concept of "word delimiters" having a separate representation from freely chosen identifiers (hence, no reserved words). ALGOL 60 kept this three-level concept.
  • The distinction between assignment (:= representing a left-facing arrow) and the equality relation (=) was introduced in IAL and kept in ALGOL 60.
  • Both IAL and ALGOL 60 allowed arrays with arbitrary lower and upper subscript bounds, and allowed subscript bounds to be defined by integer expressions.
  • Both IAL and ALGOL 60 allowed nesting of procedure declarations and the corresponding identifier scopes.
  • The IAL report described parameter substitution in much the same terms as the ALGOL 60 report, leaving open the possibility of call by name. It is unclear if this was realized at the time.
  • IAL allowed numeric statement labels, that ALGOL 60 kept.
  • The possibility of including non-ALGOL code within a program was already hinted at, in the context of parameters to procedures.
  • Both IAL and ALGOL 60 had a Switch statement.
  • In-line functions of the form f(x) := x / 2; were proposed in IAL but dropped in ALGOL 60.
  • IAL procedure declarations provided separate declaration lists for input and output parameters, a procedure could return multiple values; this mechanism was replaced in ALGOL 60 with the value declaration.
  • Variable declarations in IAL could be placed anywhere in the program and not necessarily at the beginning of a procedure. In contrast, the declarations within an ALGOL 60 block should occur before all execution statements.
  • The for-statement had the form for i:=base(increment)limit, directly resembling the loop of Rutishauser's programming language Superplan, replacing “=” with “:=”, and replacing its German keyword Für with the direct English translation for; ALGOL 60 replaced the parentheses with the word delimiters step and until, such that the previous statement instead would be i:=base step increment until limit.
  • The IAL if-statement did not have a then-clause or else-clause; it rather guarded the succeeding statement. IAL provided an if either-statement that cleanly allowed testing of multiple conditions. Both were replaced by ALGOL's if-then construct, with the introduction of the "dangling-else" ambiguity.
  • IAL provided macro-substitution with the do-statement; this was dropped in ALGOL 60.
  • IAL allowed to omit one or more array subscripts when passing arrays to procedures, and to provide any or all arguments to a procedure passed to another procedure.
  • IAL's binary boolean operators were all of the same precedence level. Exponents were indicated with paired up and down arrows, which removed any confusion about the correct interpretation of nested exponents; ALGOL 60 replaced the paired arrows with a single up-arrow whose function was equivalent to FORTRAN's **.
  • The IAL report did not explicitly specify which standard functions were to be provided, making a vague reference to the "standard functions of analysis." The ALGOL 60 report had a more explicit list of standard functions.

References[edit]

  1. ^ Rojas, Raúl; Hashagen, Ulf (2002). The First Computers: History and Architectures. MIT Press. p. 292. ISBN 978-0262681377. Retrieved October 25, 2013. 
  2. ^ Backus, J.W. (1959). "Proceedings of the International Conference on Information Processing". UNESCO. pp. 125–132.  |chapter= ignored (help)
  3. ^ Friedrich L. Bauer
  4. ^ Perlis, A.J. (1981). "ACM National Conference. Nashville,. TN". (Transcript in J. A. N. Lee (ed.), Computer Pioneers, IEEE Computer Society Press, Los Alamito, CA, 1995, 545-556).  |chapter= ignored (help)
  5. ^ Perlis, A.J.; Samelson, K. (1958). "Preliminary report: international algebraic language". Communications of the ACM 1 (12): 8–22. doi:10.1145/368685.368689. 
  6. ^ Naur, P (editor) (1962). Revised report on the Algorithmic Language ALGOL 60. International Federation for Information Processing. 
  7. ^ "Algol 58 implementations and dialects", Software Preservation Group, Computer History Museum. Donald Knuth is quoted on BALGOL: "I’m in my second year at Cal Tech, and I was a consultant to Burroughs. After finishing my compiler for Burroughs, I joined the Product Planning Department. The Product Planning Department was largely composed of people who had written the best software ever done in the world up to that time, which was a Burroughs ALGOL compiler for the 220 computer. That was a great leap forward for software. It was the first software that used list processing and high level data structures in an intelligent way. They took the ideas of Newell and Simon and applied them to compilers. It ran circles around all the other things that we were doing." [Don Knuth, CHM Oral History, 2007, page 9]

External links[edit]