ALGOL 58

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.

ALGOL 58
Paradigmprocedural, imperative, structured
Designed byFriedrich L. Bauer, Hermann Bottenbruch, Heinz Rutishauser, Klaus Samelson, John Backus, Charles Katz, Alan Perlis, Joseph Henry Wegstein
First appeared1958
Influenced by
FORTRAN, IT,

Plankalkül,[1]

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

Name

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

There were proposals for a universal language by the Association for Computing Machinery (ACM) and also by the German Gesellschaft für Angewandte Mathematik und Mechanik ("Society of Applied Mathematics and Mechanics") (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]

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.[6]

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

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 Schwartz 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

  • 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.[7]
  • 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 allow arrays with arbitrary lower and upper subscript bounds, and allow subscript bounds to be defined by integer expressions.
  • Both IAL and ALGOL 60 allow 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 allows 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 have a switch designator, unrelated, however, to the switch statement in C and other languages.
  • In-line functions of the form f(x) := x / 2; were proposed in IAL but dropped in ALGOL 60.
  • IAL procedure declarations provide separate declaration lists for input and output parameters, a procedure can return multiple values; this mechanism was replaced in ALGOL 60 with the value declaration.
  • Variable declarations in IAL can 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 has 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 does not have a then-clause or else-clause; it rather guards the succeeding statement. IAL provides an if either-statement that cleanly allows testing of multiple conditions. Both were replaced by ALGOL's if-then construct, with the introduction of the "dangling-else" ambiguity.
  • IAL provides macro-substitution with the do-statement; this was dropped in ALGOL 60.
  • IAL allows one or more array subscripts to be omitted when passing arrays to procedures, and to provide any or all arguments to a procedure passed to another procedure.
  • IAL's infix boolean operators are all of the same precedence level. Exponents are 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 is equivalent to FORTRAN's **.
  • The IAL report does not explicitly specify which standard functions were to be provided, making a vague reference to the "standard functions of analysis." The ALGOL 60 report has a more explicit list of standard functions.

References

  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). "The Syntax and Semantics of the Proposed International Algebraic Language of Zürich ACM-GAMM Conference". Proceedings of the International Conference on Information Processing. UNESCO. pp. 125–132.
  3. ^ Friedrich L. Bauer Archived April 22, 2012, at the Wayback Machine
  4. ^ Perlis, A.J. (1981). "Talk on Computing in the fifties". ACM National Conference. Nashville,. TN. (Transcript in J. A. N. Lee (ed.), Computer Pioneers, IEEE Computer Society Press, Los Alamito, CA, 1995, 545-556).
  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. ^ "Algol 58 implementations and dialects", Software Preservation Group, Computer History Museum. Donald Knuth is quoted on BALGOL: "I’m in my second year at Caltech, 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]
  7. ^ Naur, P (editor) (1962). Revised report on the Algorithmic Language ALGOL 60 (PDF). International Federation for Information Processing.CS1 maint: Extra text: authors list (link)

External links

ALGO

ALGO is an algebraic programming language developed between 1959 and 1961 for the Bendix G-15 computer.

ALGO was one of several programming languages inspired by the Preliminary Report on the Language written in Zürich in 1958. This report underwent several modifications before becoming the Revised Report on which most ALGOL implementations are based. As a result, ALGO and other early "ALGOLs" have a very different syntax from ALGOL 60.

Other languages

ALGOL

ALGOL (; short for "Algorithmic Language") is a family of imperative computer programming languages, originally developed in the mid-1950s, which greatly influenced many other languages and was the standard method for algorithm description used by the ACM in textbooks and academic sources for more than thirty years.In the sense that the syntax of most modern languages is "Algol-like", it was arguably the most influential of the four high-level programming languages among which it was roughly contemporary: FORTRAN, Lisp, and COBOL. It was designed to avoid some of the perceived problems with FORTRAN and eventually gave rise to many other programming languages, including PL/I, Simula, BCPL, B, Pascal, and C.

ALGOL introduced code blocks and the begin…end pairs for delimiting them. It was also the first language implementing nested function definitions with lexical scope. Moreover, it was the first programming language which gave detailed attention to formal language definition and through the Algol 60 Report introduced Backus–Naur form, a principal formal grammar notation for language design.

There were three major specifications, named after the year they were first published:

ALGOL 58 – originally proposed to be called IAL, for International Algebraic Language.

ALGOL 60 – first implemented as X1 ALGOL 60 in mid-1960. Revised 1963.

ALGOL 68 – introduced new elements including flexible arrays, slices, parallelism, operator identification. Revised 1973.ALGOL 68 is substantially different from ALGOL 60 and was not well received, so that in general "Algol" means ALGOL 60 and dialects thereof.

ALGOL 60

ALGOL 60 (short for Algorithmic Language 1960) is a member of the ALGOL family of computer programming languages. It followed on from ALGOL 58 which had introduced code blocks and the begin and end pairs for delimiting them. ALGOL 60 was the first language implementing nested function definitions with lexical scope. It gave rise to many other programming languages, including CPL, Simula, BCPL, B, Pascal and C.

Niklaus Wirth based his own ALGOL W on ALGOL 60 before moving to develop Pascal. Algol-W was intended to be the next generation ALGOL but the ALGOL 68 committee decided on a design that was more complex and advanced rather than a cleaned simplified ALGOL 60. The official ALGOL versions are named after the year they were first published. Algol 68 is substantially different from Algol 60 and was criticised partially for being so, so that in general "Algol" refers to dialects of Algol 60.

Block (programming)

In computer programming, a block or code block is a lexical structure of source code which is grouped together. Blocks consist of one or more declarations and statements. A programming language that permits the creation of blocks, including blocks nested within other blocks, is called a block-structured programming language. Blocks are fundamental to structured programming, where control structures are formed from blocks.

The function of blocks in programming is to enable groups of statements to be treated as if they were one statement, and to narrow the lexical scope of objects such as variables, procedures and functions declared in a block so that they do not conflict with those having the same name used elsewhere. In a block-structured programming language, the objects named in outer blocks are visible inside inner blocks, unless they are masked by an object declared with the same name.

Dartmouth ALGOL 30

Dartmouth ALGOL 30 was a 1960s-era implementation, firstly of the ALGOL 58 programming language, then of ALGOL 60 for the LGP-30 at Dartmouth College, hence the name.

Since the limited size of the LGP-30 precluded a full implementation of ALGOL 60, certain of its features (arrays called by value, own arrays, strings, variable array bounds, and recursion) were omitted; but the implementers did include parameters called by name, using "thunks", and integer labels. They dubbed their work ALGOL 30, since it was for the LGP-30. From this project emerged a small group of undergraduate students who were well equipped to perform further work in the development of computer languages. For instance, one student (Stephen J. Garland) discovered that compound statements and blocks could be included in the Samelson and Bauer scanning algorithm. This simple fact was not published until some years later.

The ALGOL 30 system suffered one defect that hindered its wide use as a student-oriented language: it was a two-pass system. The intermediate code was similar to relocatable binary, but had to be punched onto paper tape. Compilations could be "batched," but the delays between presenting the source code tape and the final execution were too great to allow widespread student use. It was clear that a "load-and-go" system was needed. Thus was born SCALP, a Self Contained ALgol Processor

— Kurtz, 1962c, Oct.

For loop

In computer science, a for-loop (or simply for loop) is a control flow statement for specifying iteration, which allows code to be executed repeatedly. Various keywords are used to specify this statement: descendants of ALGOL use "for", while descendants of Fortran use "do". There are other possibilities, for example COBOL which uses "PERFORM VARYING".

A for-loop has two parts: a header specifying the iteration, and a body which is executed once per iteration. The header often declares an explicit loop counter or loop variable, which allows the body to know which iteration is being executed. For-loops are typically used when the number of iterations is known before entering the loop. For-loops can be thought of as shorthands for while-loops which increment and test a loop variable.

The name for-loop comes from the English word for, which is used as the keyword in many programming languages to introduce a for-loop. The term in English dates to ALGOL 58 and was popularized in the influential later ALGOL 60; it is the direct translation of the earlier German für, used in Superplan (1949–1951) by Heinz Rutishauser, who also was involved in defining ALGOL 58 and ALGOL 60. The loop body is executed "for" the given values of the loop variable, though this is more explicit in the ALGOL version of the statement, in which a list of possible values and/or increments can be specified.

In FORTRAN and PL/I, the keyword DO is used for the same thing and it is called a do-loop; this is different from a do-while loop.

Gesellschaft für Angewandte Mathematik und Mechanik

Gesellschaft für Angewandte Mathematik und Mechanik ("Society of Applied Mathematics and Mechanics"), often referred to by the acronym GAMM, is a German society for the promotion of science, founded in 1922 by the physicist Ludwig Prandtl and the mathematician Richard von Mises. The society awards the Richard von Mises prize annually.

In 1958 the GAMM and the ACM together worked out the "ALGOL 58 Report" at a meeting in Zurich.

Hermann Bottenbruch

Hermann Bottenbruch (born September 14, 1928) is a German mathematician and computer scientist.

Bottenbruch grew up in Mülheim an der Ruhr in the German state of North Rhine-Westphalia. Toward the end of the Second World War, he served as a flakhelfer. In 1947, he began the study of mathematics at the Rheinische Friedrich-Wilhelms-Universität Bonn where he graduated in 1951. Following graduation he joined the staff of the Institute for Applied Mathematics at the Technische Universität Darmstadt (TU Darmstadt). The institute was founded by Alwin Walther. Bottenbruch earned his doctorate there in 1957.

In the same year on Walther's recommendation he joined the international working group to develop a new programming language. This language was intended to combine current understanding of programming languages into a single standard. According to Friedrich Bauer, Bottenbruch coined the name "Algol", at least for Germany, from the English "Algorithmic Language“. In 1958, the members of the working group—Friedrich L. Bauer, Bottenbruch, Heinz Rutishauser, Klaus Samelson, John Backus, Charles Katz, Alan Perlis, and Joseph Henry Wegstein—met at the ETH Zurich. The result of their deliberations was Algol 58.

In 1960 and 1961 Bottenbruch worked at the US Oak Ridge National Laboratory. After that he took a leading position in German industry where, among other things, he served as a specialist in the area of industrial chimney construction. In 1994, he founded his own company, Primasoft GmbH, in the German city of Oberhausen, providing IT consulting and database solutions.

History of programming languages

The first high-level programming language was Plankalkül, created by Konrad Zuse between 1942 and 1945. The first high-level language to have an associated compiler was created by Corrado Böhm in 1951, for his PhD thesis. The first commercially available language was FORTRAN (FORmula TRANslation); developed in 1956 (first manual appeared in 1956, but first developed in 1954) by a team led by John Backus at IBM.

When FORTRAN was first introduced it was treated with suspicion because of the belief that programs compiled from high-level language would be less efficient than those written directly in machine code. FORTRAN became popular because it provided a means of porting existing code to new computers, in a hardware market that was rapidly evolving; the language eventually became known for its efficiency.

IAL

IAL may refer to:

Intel Architecture Labs, a research arm of Intel Corporation during the 1990s

International Algebraic Language or ALGOL 58

International auxiliary language, a language for communication between people who do not share a native language

JOVIAL

JOVIAL is a high-level computer programming language similar to ALGOL, specialized for the development of embedded systems (specialized computer systems designed to perform one or a few dedicated functions, usually embedded as part of a complete device including mechanical parts).

John Backus

John Warner Backus (December 3, 1924 – March 17, 2007) was an American computer scientist. He directed the team that invented and implemented FORTRAN, the first widely used high-level programming language, and was the inventor of the Backus–Naur form (BNF), a widely used notation to define formal language syntax. He later did research into the function-level programming paradigm, presenting his findings in his influential 1977 Turing Award lecture "Can Programming Be Liberated from the von Neumann Style?"

The IEEE awarded Backus the W. W. McDowell Award in 1967 for the development of FORTRAN. He received the National Medal of Science in 1975 and the 1977 ACM Turing Award "for profound, influential, and lasting contributions to the design of practical high-level programming systems, notably through his work on FORTRAN, and for publication of formal procedures for the specification of programming languages".He retired in 1991 and died at his home in Ashland, Oregon on March 17, 2007.

Joseph Henry Wegstein

Joseph Henry Wegstein (April 7, 1922 in Washburn, Illinois - August 16, 1985) was an American computer scientist.Wegstein attended the University of Illinois, where he graduated with a Master's Degree in physics in 1948. He worked at the National Bureau of Standards (now NIST), where he specialized in standards for automatic data processing and in particular in the technology of fingerprint recognition.

He participated in conferences in Zurich in 1958 and Paris in 1960 which developed the programming languages Algol 58 and Algol 60 respectively. As a member of the CODASYL committee he was involved in the development of the COBOL language.

List of programming languages

The aim of this list of programming languages is to include all notable programming languages in existence, both those in current use and historical ones, in alphabetical order. Dialects of BASIC, esoteric programming languages, and markup languages are not included.

MAD (programming language)

MAD (Michigan Algorithm Decoder) is a programming language and compiler for the IBM 704 and later the IBM 709, IBM 7090, IBM 7040, UNIVAC 1107, UNIVAC 1108, Philco 210-211, and eventually the IBM S/370 mainframe computers. Developed in 1959 at the University of Michigan by Bernard Galler, Bruce Arden and Robert M. Graham, MAD is a variant of the ALGOL language. It was widely used to teach programming at colleges and universities during the 1960s and played a minor role in the development of CTSS, Multics, and the Michigan Terminal System computer operating systems.The archives at the Bentley Historical Library of the University of Michigan contain reference materials on the development of MAD and MAD/I, including three linear feet of printouts with hand-written notations and original printed manuals.

NELIAC

The Navy Electronics Laboratory International ALGOL Compiler or NELIAC is a dialect and compiler implementation of the ALGOL 58 programming language developed by the Naval Electronics Laboratory in 1958.

It was designed for numeric and logical computations and was the first language to provide a bootstrap implementation.

Structured programming

Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making extensive use of the structured control flow constructs of selection (if/then/else) and repetition (while and for), block structures, and subroutines.

It emerged in the late 1950s with the appearance of the ALGOL 58 and ALGOL 60 programming languages, with the latter including support for block structures. Contributing factors to its popularity and widespread acceptance, at first in academia and later among practitioners, include the discovery of what is now known as the structured program theorem in 1966, and the publication of the influential "Go To Statement Considered Harmful" open letter in 1968 by Dutch computer scientist Edsger W. Dijkstra, who coined the term "structured programming".Structured programming is most frequently used with deviations that allow for clearer programs in some particular cases, such as when exception handling has to be performed.

Timeline of programming languages

This is a record of historically important programming languages, by decade.

Z22 (computer)

The Z22 was the seventh computer model Konrad Zuse developed (the first six being the Z1, Z2, Z3, Z4, Z5 and Z11, respectively). One of the early commercial computers, the Z22's design was finished about 1955. The major version jump from Z11 to Z22 was due to the use of vacuum tubes, as opposed to the electromechanical systems used in earlier models. The first machines built were shipped to Berlin and Aachen.

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).

In 1961, the Z22 was followed by a logically very similar transistorized version, the Z23. Already in 1954 Zuse had come to an agreement with Heinz Zemanek that his Zuse KG would finance the work of Rudolf Bodo, who helped Zemanek build the early European transistorized computer Mailüfterl, and that after that project Bodo should work for the Zuse KG—there he helped build the transistorized Z23. Furthermore, all circuit diagrams of the Z22 were supplied to Bodo and Zemanek.

The University of Applied Sciences, Karlsruhe still has an operational Z22 which is on permanent loan at the ZKM in Karlsruhe.

Altogether 55 Z22 computers were produced.In the 1970s, clones of the Z22 using TTL were built by the company Thiemicke Computer.

This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.