ALGOL 68

<h2 id="overview">Overview</h2>
ALGOL 68 features include expression-based syntax, user-declared types and structures/tagged-unions, a reference model of variables and reference parameters, string, array and matrix slicing, and concurrency.
ALGOL 68 was designed by the <a href="/facts/International_Federation_for_Information_Processing/RgTMBVN9">International Federation for Information Processing</a> (IFIP) <a href="/facts/IFIP_Working_Group_2.1/JhPYRM7c">IFIP Working Group 2.1</a> on Algorithmic Languages and Calculi. On 20 December 1968, the language was formally adopted by the group, and then approved for publication by the General Assembly of IFIP.
ALGOL 68 was defined using a <a href="/facts/Formalism_(philosophy_of_mathematics)/g0690AVL">formalism</a>, a two-level <a href="/facts/Formal_grammar/QLxaQNAz">formal grammar</a>, invented by <a href="/facts/Adriaan_van_Wijngaarden/vobXnR7n">Adriaan van Wijngaarden</a>. <a href="/facts/Van_Wijngaarden_grammar/YkMRSh4u">Van Wijngaarden grammars</a> use a <a href="/facts/Context-free_grammar/yu1FFdK4">context-free grammar</a> to generate an infinite set of productions that will recognize a particular ALGOL 68 program; notably, they are able to express the kind of requirements that in many other programming language <a href="/facts/Technical_standard/P4orT1SM">technical standards</a> are labelled semantics, and must be expressed in ambiguity-prone natural language prose, and then implemented in compilers as ad hoc code attached to the formal language parser.

The main aims and principles of design of ALGOL 68 are:<a class="footnote-ref" id="fnref:1" href="#fn:1">1</a>

<ol><li>Completeness and clarity of description</li>
<li><a href="/facts/Orthogonality/JVIjYPog">Orthogonality</a> of design</li>
<li>Security</li>
<li>Efficiency:
<ul><li>Static mode checking</li>
<li>Mode-independent parsing</li>
<li>Independent compiling</li>
<li>Loop optimizing</li>
<li>Representations – in minimal & larger <a href="/facts/Character_encoding/ShJHIMoA">character sets</a></li></ul></li></ol>
ALGOL 68 has been criticized, most prominently by some members of its design committee such as <a href="/facts/C._A._R._Hoare/vBeb3cmn">C. A. R. Hoare</a> and <a href="/facts/Edsger_Dijkstra/910x0MjT">Edsger Dijkstra</a>, for abandoning the simplicity of <a href="/facts/ALGOL_60/QnpxUYQm">ALGOL 60</a>, becoming a vehicle for complex or overly general ideas, and doing little to make the <a href="/facts/Compiler/WNfCDFJe">compiler</a> writer's task easier, in contrast to deliberately simple contemporaries (and competitors) such as <a href="/facts/C_(programming_language)/Ky2No763">C</a>, <a href="/facts/S-algol/S6LGGXA7">S-algol</a> and <a href="/facts/Pascal_(programming_language)/b3yvp8bF">Pascal</a>.
In 1970, <a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a> became the first working compiler for ALGOL 68.
In the 1973 revision, certain features — such as <a href="/facts/ALGOL_68-R/9Ed1AtrD">proceduring</a>, gommas<a class="footnote-ref" id="fnref:2" href="#fn:2">2</a> and <a href="/facts/ALGOL_68-R/9Ed1AtrD">formal bounds</a> — were omitted.<a class="footnote-ref" id="fnref:3" href="#fn:3">3</a> Cf. The language of the unrevised report.r0
Though European defence agencies (in Britain <a href="/facts/Royal_Signals_and_Radar_Establishment/G96SheBm">Royal Signals and Radar Establishment</a> (RSRE)) promoted the use of ALGOL 68 for its expected security advantages, the American side of the NATO alliance decided to develop a different project, the language <a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a>, making its use obligatory for US defense contracts.
ALGOL 68 also had a notable influence in the <a href="/facts/Soviet_Union/m7wWsPto">Soviet Union</a>, details of which can be found in <a href="/facts/Andrey_Terekhov/QD0NNPSQ">Andrey Terekhov</a>'s 2014 paper: "ALGOL 68 and Its Impact on the USSR and Russian Programming",<a class="footnote-ref" id="fnref:4" href="#fn:4">4</a> and "Алгол 68 и его влияние на программирование в СССР и России".<a class="footnote-ref" id="fnref:5" href="#fn:5">5</a>
<a href="/facts/Steve_Bourne/x7p7ALJH">Steve Bourne</a>, who was on the ALGOL 68 revision committee, took some of its ideas to his <a href="/facts/Bourne_shell/wUCh3Qkl">Bourne shell</a> (and thereby, to descendant <a href="/facts/Unix_shell/2G4T2Fb9">Unix shells</a> such as <a href="/facts/Bash_(Unix_shell)/RrYLtEJT">Bash</a>) and to <a href="/facts/C_(programming_language)/Ky2No763">C</a> (and thereby to descendants such as <a href="/facts/C%252B%252B/Et0F2qn9">C++</a>).
The complete history of the project can be found in <a href="/facts/Charles_H._Lindsey/1tu7krTS">C. H. Lindsey</a>'s "A History of ALGOL 68".<a class="footnote-ref" id="fnref:6" href="#fn:6">6</a>
For a full-length treatment of the language, see "Programming ALGOL 68 Made Easy"<a class="footnote-ref" id="fnref:7" href="#fn:7">7</a> by Dr. Sian Mountbatten, or "Learning ALGOL 68 Genie"<a class="footnote-ref" id="fnref:8" href="#fn:8">8</a> by Marcel van der Veer which includes the Revised Report.

<h2 id="history">History</h2>
<h3>Origins</h3>
ALGOL 68, as the name implies, is a follow-on to the <a href="/facts/ALGOL/mw03yQdn">ALGOL</a> language that was first formalized in 1960. That same year the <a href="/facts/International_Federation_for_Information_Processing/RgTMBVN9">International Federation for Information Processing</a> (IFIP) formed and started the Working Group on ALGOL, or WG2.1. This group released an updated ALGOL 60 specification in Rome in April 1962. At a follow-up meeting in March 1964, it was agreed that the group should begin work on two follow-on standards, ALGOL X, which would be a redefinition of the language with some additions, and <a href="/facts/ALGOL_Y/wIHVS6Nq">ALGOL Y</a>, which would have the ability to modify its own programs in the style of the language <a href="/facts/Lisp_(programming_language)/xJHA3CrX">LISP</a>.<a class="footnote-ref" id="fnref:9" href="#fn:9">9</a>

<h3>Definition process</h3>
The first meeting of the ALGOL X group was held in <a href="/facts/Princeton_University/n3EPGHBM">Princeton University</a> in May 1965. A report of the meeting noted two broadly supported themes, the introduction of <a href="/facts/Strong_typing/WYexudnr">strong typing</a> and interest in <a href="/facts/Euler_programming_language/13kHJTae">Euler's</a> concepts of 'trees' or 'lists' for handling collections.<a class="footnote-ref" id="fnref:10" href="#fn:10">10</a> Although intended as a "short-term solution to existing difficulties",<a class="footnote-ref" id="fnref:11" href="#fn:11">11</a> ALGOL X got as far as having a compiler made for it. This compiler was written by <a href="/facts/Douglas_T._Ross/wKbeMNbA">Douglas T. Ross</a> of the <a href="/facts/Massachusetts_Institute_of_Technology/Xk49vNA8">Massachusetts Institute of Technology</a> (MIT) with the Automated Engineering Design (AED-0) system, also termed ALGOL Extended for Design.<a class="footnote-ref" id="fnref:12" href="#fn:12">12</a><a class="footnote-ref" id="fnref:13" href="#fn:13">13</a>
At the second meeting in October in France, three formal proposals were presented, <a href="/facts/Niklaus_Wirth/krsLUB11">Niklaus Wirth</a>'s <a href="/facts/ALGOL_W/xcgYM80d">ALGOL W</a> along with comments about record structures by <a href="/facts/C.A.R._Hoare/vBeb3cmn">C.A.R. (Tony) Hoare</a>, a similar language by Gerhard Seegmüller, and a paper by <a href="/facts/Adriaan_van_Wijngaarden/vobXnR7n">Adriaan van Wijngaarden</a> on "Orthogonal design and description of a formal language". The latter, written in almost indecipherable "W-Grammar", proved to be a decisive shift in the evolution of the language. The meeting closed with an agreement that van Wijngaarden would re-write the Wirth/Hoare submission using his W-Grammar.<a class="footnote-ref" id="fnref:14" href="#fn:14">14</a>
This seemingly simple task ultimately proved more difficult than expected, and the follow-up meeting had to be delayed six months. When it met in April 1966 in <a href="/facts/Kootwijk/k7vYnqxu">Kootwijk</a>, van Wijngaarden's draft remained incomplete and Wirth and Hoare presented a version using more traditional descriptions. It was generally agreed that their paper was "the right language in the wrong formalism".<a class="footnote-ref" id="fnref:15" href="#fn:15">15</a> As these approaches were explored, it became clear there was a difference in the way parameters were described that would have real-world effects, and while Wirth and Hoare protested that further delays might become endless, the committee decided to wait for van Wijngaarden's version. Wirth then implemented their current definition as ALGOL W.<a class="footnote-ref" id="fnref:16" href="#fn:16">16</a>
At the next meeting in <a href="/facts/Warsaw/0cRqN3pw">Warsaw</a> in October 1966,<a class="footnote-ref" id="fnref:17" href="#fn:17">17</a> there was an initial report from the I/O Subcommittee who had met at the <a href="/facts/Oak_Ridge_National_Laboratory/Elq84HKF">Oak Ridge National Laboratory</a> and the <a href="/facts/University_of_Illinois/gusw7HoS">University of Illinois</a> but had not yet made much progress. The two proposals from the previous meeting were again explored, and this time a new debate emerged about the use of <a href="/facts/Pointer_(computer_science)/fPoNzy9b">pointers</a>; ALGOL W used them only to refer to records, while van Wijngaarden's version could point to any object. To add confusion, <a href="/facts/John_McCarthy_(computer_scientist)/ajKU4SdD">John McCarthy</a> presented a new proposal for <a href="/facts/Operator_overloading/hRyHs4Qf">operator overloading</a> and the ability to string together and and or constructs, and <a href="/facts/Klaus_Samelson/l2JMyT6d">Klaus Samelson</a> wanted to allow <a href="/facts/Anonymous_function/2vdyE4zL">anonymous functions</a>. In the resulting confusion, there was some discussion of abandoning the entire effort.<a class="footnote-ref" id="fnref:18" href="#fn:18">18</a> The confusion continued through what was supposed to be the ALGOL Y meeting in <a href="/facts/Zandvoort/nnflPJSh">Zandvoort</a> in May 1967.<a class="footnote-ref" id="fnref:19" href="#fn:19">19</a>

<h3>Publication</h3>
A draft report was finally published in February 1968. This was met by "shock, horror and dissent",<a class="footnote-ref" id="fnref:20" href="#fn:20">20</a> mostly due to the hundreds of pages of unreadable grammar and odd terminology. <a href="/facts/Charles_H._Lindsey/1tu7krTS">Charles H. Lindsey</a> attempted to figure out what "language was hidden inside of it",<a class="footnote-ref" id="fnref:21" href="#fn:21">21</a> a process that took six man-weeks of effort. The resulting paper, "ALGOL 68 with fewer tears",<a class="footnote-ref" id="fnref:22" href="#fn:22">22</a> was widely circulated. At a wider information processing meeting in <a href="/facts/Z%25C3%25BCrich/dXpgq7df">Zürich</a> in May 1968, attendees complained that the language was being forced upon them and that IFIP was "the true villain of this unreasonable situation" as the meetings were mostly closed and there was no formal feedback mechanism. Wirth and <a href="/facts/Peter_Naur/S1X7AHfj">Peter Naur</a> formally resigned their authorship positions in WG2.1 at that time.<a class="footnote-ref" id="fnref:23" href="#fn:23">23</a>
The next WG2.1 meeting took place in <a href="/facts/Tirrenia/g9TIGBNK">Tirrenia</a> in June 1968. It was supposed to discuss the release of compilers and other issues, but instead devolved into a discussion on the language. van Wijngaarden responded by saying (or threatening) that he would release only one more version of the report. By this point Naur, Hoare, and Wirth had left the effort, and several more were threatening to do so.<a class="footnote-ref" id="fnref:24" href="#fn:24">24</a> Several more meetings followed, <a href="/facts/North_Berwick/GQ8wPlWz">North Berwick</a> in August 1968, Munich in December which produced the release of the official Report in January 1969 but also resulted in a contentious Minority Report being written. Finally, at <a href="/facts/Banff%2c_Alberta/SKXba5pV">Banff, Alberta</a> in September 1969, the project was generally considered complete and the discussion was primarily on errata and a greatly expanded Introduction to the Report.<a class="footnote-ref" id="fnref:25" href="#fn:25">25</a>
The effort took five years, burned out many of the greatest names in <a href="/facts/Computer_science/lN3pEyPz">computer science</a>, and on several occasions became deadlocked over issues both in the definition and the group as a whole. Hoare released a "Critique of ALGOL 68" almost immediately,<a class="footnote-ref" id="fnref:26" href="#fn:26">26</a> which has been widely referenced in many works. Wirth went on to further develop the ALGOL W concept and released this as Pascal in 1970.

<h3>Implementations</h3>
<h4>ALGOL 68-R</h4>
The first implementation of the standard, based on the late-1968 draft Report, was introduced by the <a href="/facts/Royal_Radar_Establishment/jsUq834G">Royal Radar Establishment</a> in the UK as <a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a> in July 1970. This was, however, a subset of the full language, and <a href="/facts/Barry_Mailloux/pG65T9Ax">Barry Mailloux</a>, the final editor of the Report, joked that "It is a question of morality. We have a Bible and you are sinning!"<a class="footnote-ref" id="fnref:27" href="#fn:27">27</a> This version nevertheless became very popular on the <a href="/facts/International_Computers_Limited/2ztan410">ICL</a> machines, and became a widely-used language in military coding, especially in the UK.<a class="footnote-ref" id="fnref:28" href="#fn:28">28</a>
Among the changes in 68-R was the requirement for all variables to be declared before their first use. This had a significant advantage that it allowed the compiler to be one-pass, as space for the variables in the <a href="/facts/Activation_record/1sMt713v">activation record</a> was set aside before it was used. However, this change also had the side-effect of demanding the PROCs be declared twice, once as a declaration of the types, and then again as the body of code. Another change was to eliminate the assumed VOID mode, an expression that returns no value (named a statement in other languages) and demanding the word VOID be added where it would have been assumed. Further, 68-R eliminated the explicit <a href="/facts/Parallel_computing/nQzcpzQt">parallel processing</a> commands based on PAR.<a class="footnote-ref" id="fnref:29" href="#fn:29">29</a>

<h4>Others</h4>
The first full implementation of the language was introduced in 1974 by CDC Netherlands for the <a href="/facts/Control_Data/ChfGgfPM">Control Data</a> mainframe series. This saw limited use, mostly teaching in Germany and the Netherlands.<a class="footnote-ref" id="fnref:30" href="#fn:30">30</a>
A version similar to 68-R was introduced from <a href="/facts/Carnegie_Mellon_University/XKd7L2KA">Carnegie Mellon University</a> in 1976 as 68S, and was again a one-pass compiler based on various simplifications of the original and intended for use on smaller machines like the <a href="/facts/DEC_PDP-11/9HkGUzFn">DEC PDP-11</a>. It too was used mostly for teaching purposes.<a class="footnote-ref" id="fnref:31" href="#fn:31">31</a>
A version for <a href="/facts/IBM/QszA7nwd">IBM</a> mainframes did not become available until 1978, when one was released from <a href="/facts/Cambridge_University/0la7aX9o">Cambridge University</a>. This was "nearly complete". Lindsey released a version for small machines including the <a href="/facts/IBM_PC/yhcJGMPL">IBM PC</a> in 1984.<a class="footnote-ref" id="fnref:32" href="#fn:32">32</a>
Three open source Algol 68 implementations are known:<a class="footnote-ref" id="fnref:33" href="#fn:33">33</a>

<ul><li>a68g, <a href="/facts/GPLv3/S75KhLSX">GPLv3</a>, written by Marcel van der Veer.</li>
<li>algol68toc, an <a href="/facts/Open-source_software/HzTaB8E9">open-source software</a> port of <a href="/facts/ALGOL_68RS/rCfL7Mcw">ALGOL 68RS</a>.</li>
<li>experimental Algol68 frontend for <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC</a>, written by Jose E. Marchesi.<a class="footnote-ref" id="fnref:34" href="#fn:34">34</a><a class="footnote-ref" id="fnref:35" href="#fn:35">35</a></li></ul>
<h3>Timeline</h3>
<table><tbody><tr><th scope="col">Year</th><th scope="col">Event</th><th scope="col">Contributor</th></tr><tr><td>March 1959</td><td><a href="/facts/ALGOL_Bulletin/jBPaxT5C">ALGOL Bulletin</a> Issue 1 (First)</td><td><a href="/facts/Peter_Naur/S1X7AHfj">Peter Naur</a> / <a href="/facts/Association_for_Computing_Machinery/abI2atlP">ACM</a></td></tr><tr><td>February 1968</td><td>Draft Report(DR) Published<a class="footnote-ref" id="fnref:36" href="#fn:36">36</a></td><td><a href="/facts/IFIP/RgTMBVN9">IFIP</a> <a href="/facts/IFIP_Working_Group_2.1/JhPYRM7c">Working Group 2.1</a></td></tr><tr><td>March 1968</td><td>Algol 68 Final Reportr0 Presented at Munich Meeting</td><td>IFIP Working Group 2.1</td></tr><tr><td>June 1968</td><td>Meeting in Tirrenia, Italy</td><td>IFIP Working Group 2.1</td></tr><tr><td>Aug 1968</td><td>Meeting in North Berwick, Scotland</td><td>IFIP Working Group 2.1</td></tr><tr><td>December 1968</td><td>ALGOL 68 Final Reportr0 Presented at Munich Meeting</td><td>IFIP Working Group 2.1</td></tr><tr><td>April 1970</td><td><a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a> under <a href="/facts/GEORGE_(operating_system)/VEhyP0UT">GEORGE 3</a> on an <a href="/facts/International_Computers_Limited/2ztan410">ICL</a> <a href="/facts/ICT_1900_series/P5wtuSGU">1907F</a></td><td><a href="/facts/RSRE/G96SheBm">Royal Signals and Radar Est.</a></td></tr><tr><td>July 1970</td><td>ALGOL 68 for the <a href="/facts/Dartmouth_Time-Sharing_System/e0VrIbVP">Dartmouth Time-Sharing System</a><a class="footnote-ref" id="fnref:37" href="#fn:37">37</a><a class="footnote-ref" id="fnref:38" href="#fn:38">38</a></td><td>Sidney Marshall</td></tr><tr><td>September 1973</td><td>Algol 68 Revised Report<a class="footnote-ref" id="fnref:39" href="#fn:39">39</a>r1 Published</td><td>IFIP Working Group 2.1</td></tr><tr><td>1975</td><td><a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a>(C) – transportable compiler (zcode <a href="/facts/Virtual_machine/BLevU3sx">VM</a>)</td><td><a href="/facts/Stephen_R._Bourne/x7p7ALJH">S. Bourne</a>, Andrew Birrell, and <a href="/facts/Michael_Guy_(computer_scientist)/TjWdLhA3">Michael Guy</a></td></tr><tr><td>June 1975</td><td>G. E. Hedrick and Alan Robertson. The Oklahoma State ALGOL 68 Subset Compiler. 1975 International Conference on ALGOL 68.</td></tr><tr><td>June 1977</td><td>Strathclyde ALGOL 68 conference, Scotland</td><td>ACM</td></tr><tr><td>May 1978</td><td>Proposals for ALGOL H – A Superlanguage of ALGOL 68<a class="footnote-ref" id="fnref:40" href="#fn:40">40</a></td><td>A. P. Black, V. J. Rayward-Smith</td></tr><tr><td>1984</td><td>Full <a href="/facts/ALGOL_68S/KqX8jtyx">ALGOL 68S</a>(S) compiler for Sun, SPARC, and PCs</td><td>C. H. Lindsey et al, Manchester</td></tr><tr><td>August 1988</td><td><a href="/facts/ALGOL_Bulletin/jBPaxT5C">ALGOL Bulletin</a> Issue 52 (last)</td><td>Ed. C. H. Lindsey / ACM</td></tr><tr><td>May 1997</td><td>Algol68 S(S) published on the internet<a class="footnote-ref" id="fnref:41" href="#fn:41">41</a></td><td><a href="/facts/Charles_H._Lindsey/1tu7krTS">Charles H. Lindsey</a></td></tr><tr><td>November 2001</td><td>Algol 68 Genie(G) published on the internet<a class="footnote-ref" id="fnref:42" href="#fn:42">42</a> (GNU GPL open source licensing)</td><td><a href="https://jmvdveer.home.xs4all.nl">Marcel van der Veer</a></td></tr><tr><td>January 2025</td><td>Algol 68 GCC Front-End published by Jose E. Marchesi under the GPL<a class="footnote-ref" id="fnref:43" href="#fn:43">43</a><a class="footnote-ref" id="fnref:44" href="#fn:44">44</a></td><td><a href="https://jemarch.net">Jose E. Marchesi</a></td></tr></tbody></table>
<ul><li><a href="https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt">"A Shorter History of Algol 68"</a></li>
<li><a href="https://web.archive.org/web/20110514113912/http://hopl.murdoch.edu.au/showlanguage.prx?exp=311">ALGOL 68 – 3rd generation ALGOL</a></li></ul>
<h3>The Algorithmic Language ALGOL 68 Reports and Working Group members</h3>
<ul><li>March 1968: Draft Report on the Algorithmic Language ALGOL 68<a class="footnote-ref" id="fnref:45" href="#fn:45">45</a> – Edited by: <a href="/facts/Adriaan_van_Wijngaarden/vobXnR7n">Adriaan van Wijngaarden</a>, <a href="/facts/Barry_J._Mailloux/pG65T9Ax">Barry J. Mailloux</a>, <a href="/facts/John_E._L._Peck/eXHd64LA">John Peck</a> and <a href="/facts/Cornelis_H._A._Koster/kIfW8A49">Cornelis H. A. Koster</a>.</li></ul>
<blockquote>"Van Wijngaarden once characterized the four authors, somewhat tongue-in-cheek, as: Koster: transputter, Peck: syntaxer, Mailloux: implementer, Van Wijngaarden: party ideologist." – Koster.</blockquote>
<ul><li>October 1968: Penultimate Draft Report on the Algorithmic Language ALGOL 68 — Chapters 1-9<a class="footnote-ref" id="fnref:46" href="#fn:46">46</a> Chapters 10-12<a class="footnote-ref" id="fnref:47" href="#fn:47">47</a> — Edited by: A. van Wijngaarden, B.J. Mailloux, J. E. L. Peck and C. H. A. Koster.</li>
<li>December 1968: Report on the Algorithmic Language ALGOL 68 — Offprint from Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag.<a class="footnote-ref" id="fnref:48" href="#fn:48">48</a> — Edited by: A. van Wijngaarden, B. J. Mailloux, J. E. L. Peck and C. H. A. Koster.</li>
<li>March 1970: Minority report, ALGOL Bulletin AB31.1.1 — signed by <a href="/facts/Edsger_Dijkstra/910x0MjT">Edsger Dijkstra</a>, Fraser Duncan, Jan Garwick, <a href="/facts/Tony_Hoare/vBeb3cmn">Tony Hoare</a>, <a href="/facts/Brian_Randell/mp6nJuP4">Brian Randell</a>, Gerhard Seegmüller, Wlad Turski, and <a href="/facts/Mike_Woodger/TGkVzuqk">Mike Woodger</a>.</li>
<li>September 1973: Revised Report on the Algorithmic Language Algol 68 — Springer-Verlag 1976<a class="footnote-ref" id="fnref:49" href="#fn:49">49</a> — Edited by: A. van Wijngaarden, B. Mailloux, J. Peck, K. Koster, <a href="/facts/Michel_Sintzoff/duqJbqFy">Michel Sintzoff</a>, <a href="/facts/Charles_H._Lindsey/1tu7krTS">Charles H. Lindsey</a>, <a href="/facts/Lambert_Meertens/cowSqqhC">Lambert Meertens</a> and Richard G. Fisker.</li>
<li>other WG 2.1 members active in ALGOL 68 design:<a class="footnote-ref" id="fnref:50" href="#fn:50">50</a> <a href="/facts/Friedrich_L._Bauer/JlesFToV">Friedrich L. Bauer</a> • Hans Bekic • Gerhard Goos • Peter Zilahy Ingerman • <a href="/facts/Peter_Landin/V7dtseWL">Peter Landin</a> • <a href="/facts/John_McCarthy_(computer_scientist)/ajKU4SdD">John McCarthy</a> • Jack Merner • <a href="/facts/Peter_Naur/S1X7AHfj">Peter Naur</a> • Manfred Paul • <a href="/facts/Willem_van_der_Poel/vAWgjrfY">Willem van der Poel</a> • <a href="/facts/Douglas_T._Ross/wKbeMNbA">Doug Ross</a> • <a href="/facts/Klaus_Samelson/l2JMyT6d">Klaus Samelson</a> • <a href="/facts/Niklaus_Wirth/krsLUB11">Niklaus Wirth</a> • <a href="/facts/Nobuo_Yoneda/P8YgbF3B">Nobuo Yoneda</a>.</li></ul>
<h3>Timeline of standardization</h3>
1968: On 20 December 1968, the "Final Report" (MR 101) was adopted by the Working Group, then subsequently approved by the General Assembly of <a href="/facts/UNESCO/QSbkRv3o">UNESCO</a>'s <a href="/facts/IFIP/RgTMBVN9">IFIP</a> for publication. Translations of the standard were made for <a href="/facts/Russian_language/ETXrTgHV">Russian</a>, <a href="/facts/German_language/oWaQIDA8">German</a>, <a href="/facts/French_language/qe1DnaQh">French</a> and <a href="/facts/Bulgarian_language/susG15pr">Bulgarian</a>, and then later <a href="/facts/Japanese_language/EEv485a5">Japanese</a> and <a href="/facts/Chinese_language/771ruUY1">Chinese</a>.<a class="footnote-ref" id="fnref:51" href="#fn:51">51</a> The standard was also made available in <a href="/facts/Braille/SKtJVCmc">Braille</a>.
1984: <a href="/facts/ISO%2fIEC_JTC_1/hh9xdNtz">TC 97</a> considered ALGOL 68 for standardisation as "New Work Item" TC97/N1642 <a href="http://www.open-std.org/JTC1/sc22/docs/docs0200.html">[1]</a><a href="http://std.dkuug.dk/JTC1/sc22/sc22arc1.txt">[2]</a>. West Germany, Belgium, Netherlands, USSR and Czechoslovakia willing to participate in preparing the standard but the USSR and Czechoslovakia "were not the right kinds of member of the right ISO committees"<a href="http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A50/P1.HTM">[3]</a> and Algol 68's ISO standardisation stalled.<a href="http://www.open-std.org/jtc1/sc22/open/n0200.pdf">[4]</a>
1988: Subsequently ALGOL 68 became one of the <a href="/facts/GOST/Ith9dFHs">GOST</a> standards in Russia.

<ul><li>GOST 27974-88 Programming language ALGOL 68 — Язык программирования АЛГОЛ 68<a class="footnote-ref" id="fnref:52" href="#fn:52">52</a></li>
<li>GOST 27975-88 Programming language ALGOL 68 extended — Язык программирования АЛГОЛ 68 расширенный<a class="footnote-ref" id="fnref:53" href="#fn:53">53</a></li></ul>
<h2 id="notable-language-elements">Notable language elements</h2>

<h3>Bold symbols and reserved words</h3>
The standard language contains about sixty reserved words, typically bolded in print, and some with "brief symbol" equivalents:

MODE, OP, PRIO, PROC,
FLEX, HEAP, LOC, LONG, REF, SHORT,
BITS, BOOL, BYTES, CHAR, COMPL, INT, REAL, SEMA, STRING, VOID,
CHANNEL, FILE, FORMAT, STRUCT, UNION,
AT "@", EITHERr0, IS ":=:", ISNT IS NOTr0 ":/=:" ":≠:", OF "→"r0, TRUE, FALSE, EMPTY, NIL "○", SKIP "~",
CO "¢", COMMENT "¢", PR, PRAGMAT,
CASE ~ IN ~ OUSE ~ IN ~ OUT ~ ESAC "( ~ | ~ |: ~ | ~ | ~ )",
FOR ~ FROM ~ TO ~ BY ~ WHILE ~ DO ~ OD,
IF ~ THEN ~ ELIF ~ THEN ~ ELSE ~ FI "( ~ | ~ |: ~ | ~ | ~ )",
PAR BEGIN ~ END "( ~ )", GO TO, GOTO, EXIT "□"r0.

<h3>Units: Expressions</h3>
The basic language construct is the unit. A unit may be a formula, an enclosed clause, a routine text or one of several technically needed constructs (assignation, jump, skip, nihil). The technical term enclosed clause unifies some of the inherently bracketing constructs known as block, do statement, switch statement in other contemporary languages. When keywords are used, generally the reversed character sequence of the introducing keyword is used for terminating the enclosure, e.g. ( IF ~ THEN ~ ELSE ~ FI, CASE ~ IN ~ OUT ~ ESAC, FOR ~ WHILE ~ DO ~ OD ). This <a href="/facts/Guarded_Command_Language/fpojgtkM">Guarded Command</a> syntax was reused by <a href="/facts/Stephen_R._Bourne/x7p7ALJH">Stephen Bourne</a> in the common <a href="/facts/Unix/0pNL2seI">Unix</a> <a href="/facts/Bourne_shell/wUCh3Qkl">Bourne shell</a>. An expression may also yield a multiple value, which is constructed from other values by a collateral clause. This construct just looks like the parameter pack of a procedure call.

<h3>mode: Declarations</h3>
The basic <a href="/facts/Data_type/fcx5hgVL">data types</a> (called modes in Algol 68 parlance) are real, int, compl (<a href="/facts/Complex_number/2w7mqI7e">complex number</a>), bool, char, bits and bytes. For example:

INT n = 2;
CO n is fixed as a constant of 2. CO
INT m := 3;
CO m is a newly created local variable whose value is initially set to 3. CO
CO This is short for ref int m = loc int := 3; CO
REAL avogadro = 6.0221415⏨23; CO Avogadro number CO
long long real long long pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;
COMPL square root of minus one = 0 ⊥ 1;

However, the declaration REAL x; is just <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a> for REF REAL x = LOC REAL;. That is, x is really the constant identifier for a reference to a newly generated local REAL variable.
Furthermore, instead of defining both float and double, or int and long and short, etc., ALGOL 68 provides modifiers, so that the presently common double would be written as LONG REAL or LONG LONG REAL instead, for example. The prelude constants max real and min long int are provided to adapt programs to different implementations.
All variables need to be declared, but declaration does not have to precede the first use.
primitive-declarer: INT, REAL, COMPL, COMPLEXG, BOOL, CHAR, STRING, BITS, BYTES, FORMAT, FILE, PIPEG, CHANNEL, SEMA

<ul><li>BITS – a "packed vector" of BOOL.</li>
<li>BYTES – a "packed vector" of CHAR.</li>
<li>STRING – a FLEXible array of CHAR.</li>
<li>SEMA – a <a href="/facts/Semaphore_(programming)/BrE1W4Je">SEMAphore</a> which can be initialised with the OPerator LEVEL.</li></ul>
Complex types can be created from simpler ones using various type constructors:

<ul><li>REF mode – a reference to a value of type mode, similar to & in C/C++ and REF in Pascal</li>
<li>STRUCT – used to build structures, like STRUCT in C/C++ and RECORD in Pascal</li>
<li>UNION – used to build unions, like in C/C++ and Pascal</li>
<li>PROC – used to specify procedures, like functions in C/C++ and procedures/functions in Pascal</li></ul>
Other declaration symbols include: FLEX, HEAP, LOC, REF, LONG, SHORT, EVENTS

<ul><li>FLEX – declare the array to be flexible, i.e. it can grow in length on demand.</li>
<li>HEAP – allocate variable some free space from the global heap.</li>
<li>LOC – allocate variable some free space of the local stack.</li>
<li>LONG – declare an INT, REAL or COMPL to be of a LONGer size.</li>
<li>SHORT – declare an INT, REAL or COMPL to be of a SHORTer size.</li></ul>
A name for a mode (type) can be declared using a MODE declaration,
which is similar to TYPEDEF in C/C++ and TYPE in Pascal:

 INT max=99;
 MODE NEWMODE = [0:9][0:max]STRUCT (
 LONG REAL a, b, c, SHORT INT i, j, k, REF REAL r
 );

This is similar to the following C code:

 const int max=99;
 typedef struct {
 double a, b, c; short i, j, k; float *r;
 } newmode[9+1][max+1];

For ALGOL 68, only the NEWMODE mode-indication appears to the left of the equals symbol, and most notably the construction is made, and can be read, from left to right without regard to priorities. Also, the lower bound of Algol 68 arrays is one by default, but can be any integer from -max int to max int.
Mode declarations allow types to be <a href="/facts/Recursive_data_type/fzBvEl6A">recursive</a>: defined directly or indirectly in terms of themselves.
This is subject to some restrictions – for instance, these declarations are illegal:

 MODE A = REF A
 MODE A = STRUCT (A a, B b)
 MODE A = PROC (A a) A

while these are valid:

 MODE A = STRUCT (REF A a, B b)
 MODE A = PROC (REF A a) REF A

<h3>Coercions: casting</h3>
The <a href="/facts/Implicit_type_conversion/FuPD945T">coercions</a> produce a coercee from a coercend according to three criteria: the a priori mode of the coercend before the application of any coercion, the a posteriori mode of the coercee required after those coercions, and the syntactic position or "sort" of the coercee. Coercions may be cascaded.
The six possible coercions are termed deproceduring, dereferencing, uniting, widening, rowing, and voiding. Each coercion, except for uniting, prescribes a corresponding dynamic effect on the associated values. Hence, many primitive actions can be programmed implicitly by coercions.
Context strength – allowed coercions:

<ul><li>soft – deproceduring</li>
<li>weak – dereferencing or deproceduring, yielding a name</li>
<li>meek – dereferencing or deproceduring</li>
<li>firm – meek, followed by uniting</li>
<li>strong – firm, followed by widening, rowing or voiding</li></ul>
<h4>Coercion hierarchy with examples</h4>
ALGOL 68 has a hierarchy of contexts which determine the kind of coercions available at a particular point in the program. These contexts are:

<table><tbody><tr><th rowspan="2">Context</th><th rowspan="2">Context location</th><th colspan="5">Coercions available</th><th rowspan="2">Coercion examples in the context</th></tr><tr><td>Soft</td><td>Weak</td><td>Meek</td><td>Firm</td><td>Strong</td></tr><tr><td>Strong</td><td>Right hand side of:<ul><li>Identity-declarations, as "~" in: REAL x = ~</li><li>Initialisations, as "~" in: REAL x := ~</li></ul>Also:<ul><li>Actual-parameters of calls, as "~" in:PROC: sin(~)</li><li>Enclosed clauses of casts, as "~" in: REAL(~)</li><li>Units of routine-texts</li><li>Statements yielding VOID</li><li>All parts (but one) of a balanced clause</li><li>One side of an identity relation, as "~" in: ~ IS ~</li></ul></td><td rowspan="4"> deproceduring</td><td rowspan="3"> All SOFT then weak dereferencing (dereferencing or deproceduring, yielding a name)</td><td rowspan="2">All WEAK then dereferencing (dereferencing or deproceduring)</td><td rowspan="1"> All MEEK then uniting</td><td> All FIRM then widening, rowing or voiding</td><td colspan="1">Widening is always applied in the INT to REAL to COMPL direction, provided the modes have the same size. For example: An INT will be coerced to a REAL, but not vice versa. Examples:<ul><li>to REAL from INT</li><li>to COMPL from REAL</li><li>to []BOOL from BITS</li><li>to []CHAR from BYTES</li></ul>A variable can also be coerced (rowed) to an array of length 1.For example:<ul><li>to [1]INT from INT</li><li>to [1]REAL from REAL etc.</li></ul></td></tr><tr><td>Firm</td><td><ul><li>Operands of formulas as "~" in:~ OP ~</li><li>Parameters of transput calls</li></ul></td><td colspan="3">Example:UNION(INT,REAL) var := 1</td></tr><tr><td>Meek</td><td><ul><li>Trimscripts (yielding INT)</li><li>Enquiries: e.g. as "~" in the following</li></ul>IF ~ THEN ... FI and FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc<ul><li>Primaries of calls (e.g. sin in sin(x))</li></ul></td><td colspan="4">Examples:<ul><li>to BOOL from REF REF BOOL</li><li>to INT from REF REF REF INT</li></ul></td></tr><tr><td>Weak</td><td><ul><li>Primaries of slices, as in "~" in: ~[1:99]</li><li>Secondaries of selections, as "~" in: value OF ~</li></ul></td><td colspan="5">Examples:<ul><li>to REF INT from REF REF INT</li><li>to REF REAL from REF REF REF REAL</li><li>to REF STRUCT from REF REF REF REF STRUCT</li></ul></td></tr><tr><td>Soft</td><td>The LHS of assignments, as "~" in: ~ := ...</td><td colspan="6">Example:<ul><li>deproceduring of: PROC REAL random: e.g. random</li></ul></td></tr></tbody></table>
For more details about Primaries, Secondaries, Tertiary & Quaternaries refer to Operator precedence.

<h3>pr & co: Pragmats and Comments</h3>
Pragmats are <a href="/facts/Directive_(programming)/RsozxGG0">directives</a> in the program, typically hints to the compiler; in newer languages these are called "pragmas" (no 't'). e.g.

PRAGMAT heap=32 PRAGMAT
PR heap=32 PR

Comments can be inserted in a variety of ways:

¢ The original way of adding your 2 cents worth to a program ¢
COMMENT "bold" comment COMMENT
CO Style i comment CO
# Style ii comment #
£ This is a hash/pound comment for a UK keyboard £

Normally, comments cannot be nested in ALGOL 68. This restriction can be circumvented by using different comment delimiters (e.g. use hash only for temporary code deletions).

<h3>Expressions and compound statements</h3>
ALGOL 68 being an <a href="/facts/Expression-oriented_programming_languages/xI66LFzW">expression-oriented programming language</a>, the value returned by an <a href="/facts/Assignment_(programming)/kLevAoyJ">assignment</a> statement is a reference to the destination. Thus, the following is valid ALGOL 68 code:

 REAL half pi, one pi; one pi := 2 * ( half pi := 2 * arc tan(1) )

This notion is present in <a href="/facts/C_(programming_language)/Ky2No763">C</a> and <a href="/facts/Perl/fx31kjlT">Perl</a>, among others. Note that as in earlier languages such as <a href="/facts/Algol_60/QnpxUYQm">Algol 60</a> and <a href="/facts/FORTRAN/m1KqjcMU">FORTRAN</a>, spaces are allowed in identifiers, so that half pi is a single identifier (thus avoiding the underscores versus <a href="/facts/Camel_case_(programming)/NtrmzwqN">camel case</a> versus all lower-case issues).
As another example, to express the mathematical idea of a sum of f(i) from i=1 to n, the following ALGOL 68 integer expression suffices:

 (INT sum := 0; FOR i TO n DO sum +:= f(i) OD; sum)

Note that, being an integer expression, the former block of code can be used in any context where an integer value can be used. A block of code returns the value of the last expression it evaluated; this idea is present in <a href="/facts/Lisp_(programming_language)/xJHA3CrX">Lisp</a>, among other languages.
Compound statements are all terminated by distinctive closing brackets:

<ul><li>IF choice clauses:</li></ul>
 IF condition THEN statements [ ELSE statements ] FI
 "brief" form: ( condition | statements | statements )

IF condition1 THEN statements ELIF condition2 THEN statements [ ELSE statements ] FI
 "brief" form:  ( condition1 | statements |: condition2 | statements | statements )

This scheme not only avoids the <a href="/facts/Dangling_else/LMGLxbsf">dangling else</a> problem but also avoids having to use BEGIN and END in embedded <a href="/facts/Statement_(programming)/bEkBufqX">statement</a> sequences.

<ul><li>CASE choice clauses:</li></ul>
 CASE switch IN statements, statements,... [ OUT statements ] ESAC
 "brief" form: ( switch | statements,statements,... | statements )

CASE switch1 IN statements, statements,... OUSE switch2 IN statements, statements,... [ OUT statements ] ESAC
 "brief" form of CASE statement:  ( switch1 | statements,statements,... |: switch2 | statements,statements,... | statements )

Choice clause example with Brief symbols:

PROC days in month = (INT year, month)INT:
 (month|
 31,
 (year÷×4=0 ∧ year÷×100≠0 ∨ year÷×400=0 | 29 | 28 ),
 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 );

Choice clause example with Bold symbols:

PROC days in month = (INT year, month)INT:
 CASE month IN
 31,
 IF year MOD 4 EQ 0 AND year MOD 100 NE 0 OR year MOD 400 EQ 0 THEN 29 ELSE 28 FI,
 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 ESAC;

Choice clause example mixing Bold and Brief symbols:

PROC days in month = (INT year, month)INT:
 CASE month IN
¢Jan¢ 31,
¢Feb¢ ( year MOD 4 = 0 AND year MOD 100 ≠ 0 OR year MOD 400 = 0 | 29 | 28 ),
¢Mar¢ 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ¢ to Dec. ¢
 ESAC;

Algol68 allowed the switch to be of either type INT or (uniquely) UNION. The latter allows the enforcing <a href="/facts/Strong_typing/WYexudnr">strong typing</a> onto UNION variables. cf. union below for example.

<ul><li><a href="/facts/For_loop/cwV2nRzp">do</a> loop clause:</li></ul>
 [ FOR index ] [ FROM first ] [ BY increment ] [ TO last ] [ WHILE condition ] DO statements OD
 The minimum form of a "loop clause" is thus: DO statements OD

This was considered the "universal" loop, the full syntax is:

FOR i FROM 1 BY -22 TO -333 WHILE i×i≠4444 DO ~ OD

The construct have several unusual aspects:

<ul><li>only the DO ~ OD portion was compulsory, in which case the loop will iterate indefinitely.</li>
<li>thus the clause TO 100 DO ~ OD, will iterate only 100 times.</li>
<li>the WHILE "syntactic element" allowed a programmer to break from a FOR loop early. e.g.</li></ul>
INT sum sq:=0;
FOR i
WHILE
 print(("So far:",i,newline));
 sum sq≠70↑2
DO
 sum sq+:=i↑2
OD

Subsequent "extensions" to the standard Algol68 allowed the TO syntactic element to be replaced with UPTO and DOWNTO to achieve a small optimisation. The same compilers also incorporated:

<ul><li>UNTIL(C) – for late loop termination.</li>
<li>FOREACH(S) – for working on arrays in <a href="/facts/Parallel_computing/nQzcpzQt">parallel</a>.</li></ul>
Further examples can be found in the code examples below.

<h3>struct, union & [:]: Structures, unions and arrays</h3>
ALGOL 68 supports <a href="/facts/Array_data_structure/BKGvF8AM">arrays</a> with any number of dimensions, and it allows for the slicing of whole or partial rows or columns.

 MODE VECTOR = [1:3] REAL; # vector MODE declaration (typedef) #
 MODE MATRIX = [1:3,1:3]REAL; # matrix MODE declaration (typedef) #
 VECTOR v1  := (1,2,3); # array variable initially (1,2,3) #
 []REAL v2 = (4,5,6); # constant array, type equivalent to VECTOR, bounds are implied #
 OP + = (VECTOR a,b) VECTOR: # binary OPerator definition #
 (VECTOR out; FOR i FROM ⌊a TO ⌈a DO out[i] := a[i]+b[i] OD; out);
 MATRIX m := (v1, v2, v1+v2);
 print ((m[,2:])); # a slice of the 2nd and 3rd columns #

Matrices can be sliced either way, e.g.:

 REF VECTOR row = m[2,]; # define a REF (pointer) to the 2nd row #
 REF VECTOR col = m[,2]; # define a REF (pointer) to the 2nd column #

ALGOL 68 supports multiple field structures (STRUCT) and <a href="/facts/United_modes/uMFenvCQ">united modes</a>. Reference variables may point to any MODE including array slices and structure fields.
For an example of all this, here is the traditional linked list declaration:

 MODE NODE = UNION (VOID, REAL, INT, COMPL, STRING),
 LIST = STRUCT (NODE val, REF LIST next);

Usage example for UNION CASE of NODE:

<table><tbody><tr><th>Algol68r0 as in the 1968 Final Report</th><th>Algol68r1 as in the 1973 Revised Report</th></tr><tr><td> NODE n := "1234"; REAL r; INT i; COMPL c; STRING s CASE r,i,c,s::=n IN print(("real:", r)), print(("int:", i)), print(("compl:", c)), print(("string:", s)) OUT print(("?:", n)) ESAC</td><td> NODE n := "1234"; # or n := EMPTY; # CASE n IN (VOID): print(("void:", "EMPTY")), (REAL r): print(("real:", r)), (INT i): print(("int:", i)), (COMPL c): print(("compl:", c)), (STRING s): print(("string:", s)) OUT print(("?:", n)) ESAC</td></tr></tbody></table>

<h3>proc: Procedures</h3>
Procedure (PROC) declarations require type specifications for both the parameters and the result (VOID if none):

 PROC max of real = (REAL a, b) REAL:
 IF a > b THEN a ELSE b FI;

or, using the "brief" form of the conditional statement:

 PROC max of real = (REAL a, b) REAL: (a>b | a | b);

The return value of a proc is the value of the last expression evaluated in the procedure. References to procedures (ref proc) are also permitted. <a href="/facts/Call_by_reference/Pc9kLWgs">Call-by-reference</a> parameters are provided by specifying references (such as ref real) in the formal argument list. The following example defines a procedure that applies a function (specified as a parameter) to each element of an array:

 PROC apply = (REF [] REAL a, PROC (REAL) REAL f):
  
 FOR i FROM LWB a TO UPB a DO a[i] := f(a[i]) OD

This simplicity of code was unachievable in ALGOL 68's predecessor <a href="/facts/ALGOL_60/QnpxUYQm">ALGOL 60</a>.

<h3>op: Operators</h3>
The programmer may define new <a href="/facts/Operator_(programming)/7TnU5LKu">operators</a> and both those and the pre-defined ones may be <a href="/facts/Overloading_(programming)/S3cCKsVT">overloaded</a> and their priorities may be changed by the coder. The following example defines operator MAX with both dyadic and monadic versions (scanning across the elements of an array).

 PRIO MAX = 9;
  
 OP MAX = (INT a,b) INT: ( a>b | a | b );
 OP MAX = (REAL a,b) REAL: ( a>b | a | b );
 OP MAX = (COMPL a,b) COMPL: ( ABS a > ABS b | a | b );
  
 OP MAX = ([]REAL a) REAL:
 (REAL out := a[LWB a];
 FOR i FROM LWB a + 1 TO UPB a DO ( a[i]>out | out:=a[i] ) OD;
 out)

<h4>Array, Procedure, Dereference and coercion operations</h4>
<table><tbody><tr><th>PRIOrity</th><th>Operation r0&r1</th><th>+Algol68r0</th><th>+Algol68G</th></tr><tr><td>Effectively 12(Primary)</td><td>dereferencing, deproceduring(~,~), subscripting[~], rowing[~,], slicing[~:~], size denotations LONG & SHORT</td><td>proceduring</td><td>currying(~,,,), DIAG, TRNSP, ROW, COL</td></tr><tr><td>Effectively 11(Secondary)</td><td>OF (selection), LOC & HEAP (generators)</td><td>→ (selection)</td><td>NEW (generators)</td></tr></tbody></table>
These are technically not operators, rather they are considered "<a href="https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html#52">units associated with names</a>"

<h4>Monadic operators</h4>
<table><tbody><tr><th>PRIOrity(Tertiary)</th><th>Algol68 "Worthy characters<a href="https://en.wikipedia.org/wiki/ALGOL_68#endnote_worthy">[5]</a>"r0&r1</th><th>+Algol68r0&r1</th><th>+Algol68C,G</th><th>+Algol68r0</th></tr><tr><td>10</td><td>NOT ~, UP, DOWN, LWB, UPB,-, ABS, ARG, BIN, ENTIER, LENG, LEVEL, ODD, REPR, ROUND, SHORTEN</td><td>¬, ↑, ↓, ⌊, ⌈</td><td>NORM, TRACE, T, DET, INV</td><td>LWS, UPS, ⎩, ⎧, BTB, CTB</td></tr></tbody></table>
<h4>Dyadic operators with associated priorities</h4>
<table><tbody><tr><th>PRIOrity(Tertiary)</th><th>Algol68 "Worthy characters"r0&r1</th><th>+Algol68r0&r1</th><th>+Algol68C,G</th><th>+Algol68r0</th></tr><tr><td>9</td><td>+*, I</td><td>+×, ⊥</td><td></td><td>!</td></tr><tr><td>8</td><td>SHL, SHR, **, UP, DOWN, LWB, UPB</td><td>↑, ↓, ⌊, ⌈</td><td></td><td>××, ^, LWS, UPS, ⎩, ⎧</td></tr><tr><td>7</td><td>*, /,  %, OVER,  %*, MOD, ELEM</td><td>×, ÷, ÷×, ÷*, %×, □</td><td></td><td>÷:</td></tr><tr><td>6</td><td>-, +</td><td></td><td></td><td></td></tr><tr><td>5</td><td><, LT, <=, LE, >=, GE, >, GT</td><td>≤, ≥</td><td></td><td></td></tr><tr><td>4</td><td>EQ =, NE ~= /=</td><td>≠, ¬=</td><td></td><td></td></tr><tr><td>3</td><td>&, AND</td><td>∧</td><td></td><td>/\</td></tr><tr><td>2</td><td>OR</td><td>∨</td><td></td><td>\/</td></tr><tr><td>1</td><td>MINUSAB, PLUSAB, TIMESAB, DIVAB, OVERAB, MODAB, PLUSTO,-:=, +:=, *:=, /:=, %:=, %*:=, +=:</td><td>×:=, ÷:=, ÷×:=, ÷*:=,  %×:=</td><td></td><td>MINUS, PLUS, DIV, OVERB, MODB, ÷::=, PRUS</td></tr></tbody></table>
Specific details:

<ul><li>Tertiaries include names NIL and ○.</li>
<li>LWS: In Algol68r0 the operators LWS and ⎩ ... both return TRUE if the lower state of the dimension of an array is fixed.</li>
<li>The UPS and ⎧ operators are similar on the upper state.</li>
<li>The LWB and UPB operators are automatically available on UNIONs of different orders (and MODEs) of arrays. eg. UPB of union([]int, [,]real, flex[,,,]char)</li></ul>
<h4>Assignation and identity relations, etc.</h4>
These are technically not operators, rather they are considered "<a href="https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html#052">units associated with names</a>"

<table><tbody><tr><th>PRIOrity(Quaternaries)</th><th>Algol68 "Worthy characters"r0&r1</th><th>+Algol68r0&r1</th><th>+Algol68C,G,R</th><th>+Algol68r0</th></tr><tr><td>Effectively 0</td><td>:=, IS :=:, ISNT :/=: :~=:, AT @, ":", ";"</td><td>:≠: :¬=:</td><td>:=:=C, =:=R</td><td>..=, .=, CT, ::, CTAB, ::=, .., is not, "..", ".,"</td></tr></tbody></table>
Note: Quaternaries include names SKIP and ~.
:=: (alternatively IS) tests if two pointers are equal; :/=: (alternatively ISNT) tests if they are unequal.

<h5>Why :=: and :/=: are needed</h5>
Consider trying to compare two pointer values, such as the following variables, declared as pointers-to-integer:

REF INT ip, jp 
Now consider how to decide whether these two are pointing to the same location, or whether one of them is pointing to NIL. The following expression

ip = jp 
will dereference both pointers down to values of type INT, and compare those, since the = operator is defined for INT, but not REF INT. It is not legal to define = for operands of type REF INT and INT at the same time, because then calls become ambiguous, due to the implicit coercions that can be applied: should the operands be left as REF INT and that version of the operator called? Or should they be dereferenced further to INT and that version used instead? Therefore the following expression can never be made legal:

ip = NIL 
Hence the need for separate constructs not subject to the normal coercion rules for operands to operators. But there is a gotcha. The following expressions:

ip :=: jp 
ip :=: NIL 
while legal, will probably not do what might be expected. They will always return FALSE, because they are comparing the actual addresses of the variables ip and jp, rather than what they point to. To achieve the right effect, one would have to write

ip :=: REF INT(jp) 
ip :=: REF INT(NIL) 
<h4>Special characters</h4>

Most of Algol's "special" characters (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ and □) can be found on the <a href="/facts/IBM_2741/2dFo6C0b">IBM 2741</a> keyboard with the <a href="/facts/APL_(programming_language)/E2sb98gC">APL</a> "golf-ball" print head inserted; these became available in the mid-1960s while ALGOL 68 was being drafted. These characters are also part of the <a href="/facts/Unicode/DDu3MfPV">Unicode</a> standard and most of them are available in several popular <a href="/facts/Font/04Q7sE8J">fonts</a>.

<h3>transput: Input and output</h3>
Transput is the term used to refer to ALGOL 68's input and output facilities. It includes pre-defined procedures for unformatted, formatted and binary transput. Files and other transput devices are handled in a consistent and machine-independent manner. The following example prints out some unformatted output to the standard output device:

 print ((newpage, "Title", newline, "Value of i is ",
 i, "and x[i] is ", x[i], newline))

Note the predefined procedures newpage and newline passed as arguments.

<h4>Books, channels and files</h4>
The TRANSPUT is considered to be of BOOKS, CHANNELS and FILES:

<ul><li>Books are made up of pages, lines and characters, and may be backed up by files.
<ul><li>A specific book can be located by name with a call to match.</li></ul></li>
<li>CHANNELs correspond to physical devices. e.g. card punches and printers.
<ul><li>Three standard channels are distinguished: stand in channel, stand out channel, stand back channel.</li></ul></li>
<li>A FILE is a means of communicating between a program and a book that has been opened via some channel.
<ul><li>The MOOD of a file may be read, write, char, bin, and opened.</li>
<li>transput procedures include: establish, create, open, associate, lock, close, scratch.</li>
<li>position enquires: char number, line number, page number.</li>
<li>layout routines include:
<ul><li>space, backspace, newline, newpage.</li>
<li>get good line, get good page, get good book, and PROC set=(REF FILE f, INT page,line,char)VOID:</li></ul></li>
<li>A file has event routines. e.g. on logical file end, on physical file end, on page end, on line end, on format end, on value error, on char error.</li></ul></li></ul>
<h4>formatted transput</h4>
"Formatted transput" in ALGOL 68's transput has its own syntax and patterns (functions), with FORMATs embedded between two $ characters.<a class="footnote-ref" id="fnref:54" href="#fn:54">54</a>
Examples:

 printf (($2l"The sum is:"x, g(0)$, m + n)); ¢ prints the same as: ¢
 print ((new line, new line, "The sum is:", space, whole (m + n, 0))

<h3>par: Parallel processing</h3>
ALGOL 68 supports programming of parallel processing. Using the keyword PAR, a collateral clause is converted to a parallel clause, where the synchronisation of actions is controlled using <a href="/facts/Semaphore_(programming)/BrE1W4Je">semaphores</a>. In A68G the parallel actions are mapped to threads when available on the hosting <a href="/facts/Operating_system/8XTuvMh2">operating system</a>. In A68S a different paradigm of parallel processing was implemented (see below).

PROC
 eat = VOID: ( muffins-:=1; print(("Yum!",new line))),
 speak = VOID: ( words-:=1; print(("Yak...",new line)));
 
INT muffins := 4, words := 8;
SEMA mouth = LEVEL 1;
 
PAR BEGIN
 WHILE muffins > 0 DO
 DOWN mouth;
 eat;
 UP mouth
 OD,
 WHILE words > 0 DO
 DOWN mouth;
 speak;
 UP mouth
 OD
END

<h3>Miscellaneous</h3>
For its technical intricacies, ALGOL 68 needs a cornucopia of methods to deny the existence of something:

SKIP, "~" or "?"C – an undefined value always syntactically valid,
EMPTY – the only value admissible to VOID, needed for selecting VOID in a UNION,
VOID – syntactically like a MODE, but not one,
NIL or "○" – a name not denoting anything, of an unspecified reference mode,
() or specifically [1:0]INT – a vacuum is an empty array (here specifically of MODE []INT).
undefined – a standards reports procedure raising an exception in the runtime system.
ℵ – Used in the standards report to inhibit <a href="/facts/Type_introspection/c0tKqdYB">introspection</a> of certain types. e.g. SEMA

The term NIL IS var always evaluates to TRUE for any variable (but see above for correct use of IS :/=:), whereas it is not known to which value a comparison x < SKIP evaluates for any integer x.
ALGOL 68 leaves intentionally undefined what happens in case of <a href="/facts/Integer_overflow/sVNnSolT">integer overflow</a>, the integer bit representation, and the degree of numerical accuracy for floating point.
Both official reports included some advanced features that were not part of the standard language. These were indicated with an ℵ and considered effectively private. Examples include "≮" and "≯" for templates, the OUTTYPE/INTYPE for crude <a href="/facts/Duck_typing/tcuo8Ywq">duck typing</a>, and the STRAIGHTOUT and STRAIGHTIN operators for "straightening" nested arrays and structures

<h2 id="examples-of-use">Examples of use</h2>
<h3>Code sample</h3>
This sample program implements the <a href="/facts/Sieve_of_Eratosthenes/ACzqmLGE">Sieve of Eratosthenes</a> to find all the <a href="/facts/Prime_number/L20FLkgn">prime numbers</a> that are less than 100. NIL is the ALGOL 68 analogue of the null pointer in other languages. The notation x OF y accesses a member x of a STRUCT y.

BEGIN # Algol-68 prime number sieve, functional style #
  
 PROC error = (STRING s) VOID:
 (print(( newline, " error: ", s, newline)); GOTO stop);
 PROC one to = (INT n) LIST:
 (PROC f = (INT m,n) LIST: (m>n | NIL | cons(m, f(m+1,n))); f(1,n));
  
 MODE LIST = REF NODE;
 MODE NODE = STRUCT (INT h, LIST t);
 PROC cons = (INT n, LIST l) LIST: HEAP NODE := (n,l);
 PROC hd = (LIST l) INT: ( l IS NIL | error("hd NIL"); SKIP | h OF l );
 PROC tl = (LIST l) LIST: ( l IS NIL | error("tl NIL"); SKIP | t OF l );
 PROC show = (LIST l) VOID: ( l ISNT NIL | print((" ",whole(hd(l),0))); show(tl(l)));
  
 PROC filter = (PROC (INT) BOOL p, LIST l) LIST:
 IF l IS NIL THEN NIL
 ELIF p(hd(l)) THEN cons(hd(l), filter(p,tl(l)))
 ELSE filter(p, tl(l))
 FI;
  
 PROC sieve = (LIST l) LIST:
 IF l IS NIL THEN NIL
 ELSE
 PROC not multiple = (INT n) BOOL: n MOD hd(l) ~= 0;
 cons(hd(l), sieve( filter( not multiple, tl(l) )))
 FI;
  
 PROC primes = (INT n) LIST: sieve( tl( one to(n) ));
  
 show( primes(100) )
END

<h3>Operating systems written in ALGOL 68</h3>
<ul><li><a href="/facts/Cambridge_CAP_computer/1lfkx6BA">Cambridge CAP computer</a> – All procedures constituting the operating system were written in <a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a>, although several other closely associated protected procedures, such as a paginator, are written in <a href="/facts/BCPL/GkBV2hXy">BCPL</a>.<a class="footnote-ref" id="fnref:55" href="#fn:55">55</a></li>
<li>Eldon 3 – Developed at <a href="/facts/Leeds_University/XxFJF9Qh">Leeds University</a> for the <a href="/facts/ICT_1900_series/P5wtuSGU">ICL 1900</a> was written in <a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a>.<a class="footnote-ref" id="fnref:56" href="#fn:56">56</a></li>
<li><a href="/facts/Flex_machine/9E5ugBay">Flex machine</a> – The hardware was custom and microprogrammable, with an operating system, (modular) compiler, editor, garbage collector and filing system all written in <a href="/facts/ALGOL_68RS/rCfL7Mcw">ALGOL 68RS</a>. The command shell Curt<a class="footnote-ref" id="fnref:57" href="#fn:57">57</a> was designed to access typed data similar to Algol-68 modes.</li>
<li><a href="/facts/ICL_VME/6rICze0T">VME</a> – <a href="/facts/S3_(programming_language)/QDfn25ha">S3</a> was the implementation language of the <a href="/facts/Operating_system/8XTuvMh2">operating system</a> VME. S3 was based on ALGOL 68 but with data types and operators aligned to those offered by the <a href="/facts/ICL_2900_Series/ka6K2NFC">ICL 2900 Series</a>.</li></ul>
Note: The Soviet Era computers <a href="/facts/Elbrus_(computer)/cFAIaDlB">Эльбрус-1 (Elbrus-1)</a> and Эльбрус-2 were created using high-level language Эль-76 (AL-76), rather than the traditional assembly. Эль-76 resembles Algol-68, The main difference is the dynamic binding types in Эль-76 supported at the hardware level. Эль-76 is used for application, job control, system programming.<a class="footnote-ref" id="fnref:58" href="#fn:58">58</a>

<h3>Applications</h3>
Both <a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a> and <a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a> are written in ALGOL 68, effectively making ALGOL 68 an application of itself. Other applications include:

<ul><li><a href="/facts/ELLA_(programming_language)/FbYawPf5">ELLA</a> – a hardware description language and support toolset. Developed by the <a href="/facts/Royal_Signals_and_Radar_Establishment/G96SheBm">Royal Signals and Radar Establishment</a> during the 1980s and 1990s.</li>
<li><a href="/facts/RAF_Strike_Command/hVAfK3jJ">RAF Strike Command</a> System – "... 400K of error-free <a href="/facts/ALGOL_68-RT/9Ed1AtrD">ALGOL 68-RT</a> code was produced with three man-years of work. ..."<a class="footnote-ref" id="fnref:59" href="#fn:59">59</a></li></ul>
<h3>Libraries and APIs</h3>
<ul><li><a href="/facts/NAG_Numerical_Libraries/PKd05xdo">NAG Numerical Libraries</a> – a <a href="/facts/Software_library/xRzL3P7q">software library</a> of <a href="/facts/Numerical_analysis/QT9cYa9z">numerical analysis</a> routines. Supplied in ALGOL 68 during the 1980s.</li>
<li>TORRIX – a programming system for operations on vectors and matrices over arbitrary fields and of variable size by S. G. van der Meulen and M. Veldhorst.<a class="footnote-ref" id="fnref:60" href="#fn:60">60</a></li></ul>
<h2 id="program-representation">Program representation</h2>
A feature of ALGOL 68, inherited from the <a href="/facts/ALGOL/mw03yQdn">ALGOL</a> tradition, is its different representations. Programs in the strict language (which is rigorously defined in the Report) denote production trees in the form of a sequence of grammar symbols, and should be represented using some representation language, of which there are many and tailored to different purposes.

<ul><li>Representation languages that are intended to describe algorithms in printed works are known as publication languages and typically make use of rich typography to denote bold words and operator indications.</li>
<li>Representation languages that are intended to be used in compiler input, what we would call programming languages, are limited by the restrictions imposed by input methods and character sets and have to resort to stropping regimes to distinguish between bold and non bold letters and digits.</li>
<li>Representation languages that are intended to be both produced and consumed by computers, known as hardware languages, would typically use a binary compact representation.</li></ul>
The Revised Report defines a reference language and it is recommended for representation languages that are intended to be read by humans to be close enough to the reference language so symbols can be distinguished "without further elucidation". These representation languages are called implementations of the reference language.
For example, the construct in the strict language bold-begin-symbol could be represented as begin in a publication language, as BEGIN in a programming language or as the bytes 0xC000 in some hardware language. Similarly, the strict language differs from symbol could be represented as ≠ or as /=.
ALGOL 68's reserved words are effectively in a different <a href="/facts/Namespace/9efXwMtV">namespace</a> from identifiers, and spaces are allowed in identifiers in most stropping regimes, so this next fragment is legal:

 INT a real int = 3 ;

The programmer who writes executable code does not always have an option of BOLD typeface or underlining in the code as this may depend on hardware and cultural issues. Different methods to denote these identifiers have been devised. This is called a <a href="/facts/Stropping_(programming)/fyfK3KkV">stropping</a> regime. For example, all or some of the following may be available programming representations:

'INT'A REAL INT = 3; # QUOTE stropping style #
.INT A REAL INT = 3; # POINT stropping style #
 INT a real int = 3; # UPPER stropping style #
 int a_real_int = 3; # RES stropping style, there are 61 accepted reserved words #

All implementations must recognize at least POINT, UPPER and RES inside PRAGMAT sections. Of these, POINT and UPPER stropping are quite common. QUOTE (single apostrophe quoting) was the original recommendation.
It may seem that RES stropping is a contradiction to the specification, as there are no reserved words in Algol 68. This is not so. In RES stropping the representation of the bold word (or keyword) begin is begin, and the representation of the identifier begin is begin_. Note that the underscore character is just a representation artifact and not part of the represented identifier. In contrast, in non-stropped languages with reserved words, like for example C, it is not possible to represent an identifier if, since the representation if_ represents the identifier if_, not if.
The following characters were recommended for portability, and termed "worthy characters" in the <a href="http://algol68-lang.org/docs/standard-hardware-representation.pdf">Report on the Standard Hardware Representation of Algol 68</a> :

<ul><li>^ Worthy Characters: ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "#$%'()*+,-./:;<=>@[ ]_|</li></ul>
This reflected a problem in the 1960s where some hardware didn't support lower-case, nor some other non-<a href="/facts/ASCII/vGUI33Qu">ASCII</a> characters, indeed in the 1973 report it was written: "Four worthy characters — "|", "_", "[", and "]" — are often coded differently, even at installations which nominally use the same character set."

<ul><li>Base characters: "Worthy characters" are a subset of "base characters".</li></ul>
<h3>Example of different program representations</h3>
<table><tbody><tr><th scope="col">Representation</th><th scope="col">Code</th></tr><tr><th scope="row">Algol68 as typically published</th><td>¢ underline or bold typeface ¢ mode xint = int; xint sum sq:=0; for i while sum sq≠70×70 do sum sq+:=i↑2 od</td></tr><tr><th scope="row">Quote stropping(like <a href="/facts/Lightweight_markup_language/2N0GJx5b">wikitext</a>)</th><td>'pr' quote 'pr''mode' 'xint' = 'int';'xint' sum sq:=0;'for' i 'while' sum sq≠70×70'do' sum sq+:=i↑2'od'</td></tr><tr><th scope="row">For a <a href="/facts/List_of_binary_codes/NbrH3nk1">7-bit</a> character code compiler</th><td>PR UPPER PRMODE XINT = INT;XINT sum sq:=0;FOR i WHILE sum sq/=70*70DO sum sq+:=i**2OD</td></tr><tr><th scope="row">For a <a href="/facts/Six-bit_character_code/98y42p1u">6-bit</a> character code compiler</th><td>.PR POINT .PR.MODE .XINT = .INT;.XINT SUM SQ:=0;.FOR I .WHILE SUM SQ .NE 70*70.DO SUM SQ .PLUSAB I .UP 2.OD</td></tr><tr><th scope="row">Algol68 using RES stropping(reserved word)</th><td>.PR RES .PRmode .xint = int;.xint sum sq:=0;for i while sum sq≠70×70do sum sq+:=i↑2od</td></tr></tbody></table>
ALGOL 68 allows for every natural language to define its own set of keywords Algol-68. As a result, programmers are able to write programs using keywords from their native language. Below is an example of a simple procedure that calculates "the day following", the code is in two languages: English and German.

 # Next day date - English variant #
 MODE DATE = STRUCT(INT day, STRING month, INT year);
 PROC the day following = (DATE x) DATE:
 IF day OF x < length of month (month OF x, year OF x)
 THEN (day OF x + 1, month OF x, year OF x)
 ELIF month OF x = "December"
 THEN (1, "January", year OF x + 1)
 ELSE (1, successor of month (month OF x), year OF x)
 FI;

# Nachfolgetag - Deutsche Variante #
 MENGE DATUM = TUPEL(GANZ tag, WORT monat, GANZ jahr);
 FUNKTION naechster tag nach = (DATUM x) DATUM:
 WENN tag VON x < monatslaenge(monat VON x, jahr VON x)
 DANN (tag VON x + 1, monat VON x, jahr VON x)
 WENNABER monat VON x = "Dezember"
 DANN (1, "Januar", jahr VON x + 1)
 ANSONSTEN (1, nachfolgemonat(monat VON x), jahr VON x)
 ENDEWENN;

Russian/Soviet example:
In English Algol68's case statement reads CASE ~ IN ~ OUT ~ ESAC, in <a href="/facts/Cyrillic/0btN3oWC">Cyrillic</a> this reads выб ~ в ~ либо ~ быв.

<h2 id="revisions">Revisions</h2>
Except where noted (with a superscript), the language described above is that of the "Revised Report(r1)".

<h3>The language of the unrevised report</h3>
The original language (As per the "Final Report"r0) differs in syntax of the mode cast, and it had the feature of proceduring, i.e. coercing the value of a term into a procedure which evaluates the term. Proceduring would be intended to make evaluations lazy. The most useful application could have been the short-circuited evaluation of Boolean operators. In:

OP ANDF = (BOOL a,PROC BOOL b)BOOL:(a | b | FALSE);
OP ORF = (BOOL a,PROC BOOL b)BOOL:(a | TRUE | b);

b is only evaluated if a is true.
As defined in ALGOL 68, it did not work as expected, for example in the code:

IF FALSE ANDF CO proc bool: CO ( print ("Should not be executed"); TRUE)
THEN ...

against the programmers naïve expectations the print would be executed as it is only the value of the elaborated enclosed-clause after ANDF that was procedured. Textual insertion of the commented-out PROC BOOL: makes it work.
Some implementations emulate the expected behaviour for this special case by extension of the language.
Before revision, the programmer could decide to have the arguments of a procedure evaluated serially instead of collaterally by using semicolons instead of commas (<a href="https://groups.google.com/group/comp.lang.misc/msg/03af5063e1662d4d">gomma</a>s).
For example in:

PROC test = (REAL a; REAL b) :...
...
test (x PLUS 1, x);

The first argument to test is guaranteed to be evaluated before the second, but in the usual:

PROC test = (REAL a, b) :...
...
test (x PLUS 1, x);

then the compiler could evaluate the arguments in whatever order it felt like.

<h3>Extension proposals from IFIP WG 2.1</h3>
After the revision of the report, some extensions to the language have been proposed to widen the applicability:

<ul><li>partial parametrisation (aka <a href="/facts/Currying/AmD3PP5B">Currying</a>): creation of functions (with fewer parameters) by specification of some, but not all parameters for a call, e.g. a function logarithm of two parameters, base and argument, could be specialised to natural, binary or decadic log,<a class="footnote-ref" id="fnref:61" href="#fn:61">61</a></li>
<li>module extension: for support of external linkage, two mechanisms were proposed, bottom-up definition modules, a more powerful version of the facilities from <a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a> and top-down holes, similar to the ENVIRON and USING clauses from <a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a><a class="footnote-ref" id="fnref:62" href="#fn:62">62</a></li>
<li>mode parameters: for implementation of limited parametrical polymorphism (most operations on data structures like lists, trees or other data containers can be specified without touching the pay load).<a class="footnote-ref" id="fnref:63" href="#fn:63">63</a></li></ul>
So far, only partial parametrisation has been implemented, in Algol 68 Genie.

<h3>True ALGOL 68s specification and implementation timeline</h3>
<table><tbody><tr><th>Name</th><th>Year</th><th>Purpose</th><th>State</th><th>Description</th><th>Target CPU</th><th>Licensing</th><th>Implementation language</th></tr><tr><td>Generalized ALGOL</td><td>1962</td><td>Scientific</td><td> <a href="/facts/Netherlands/y8xn5stT">NLD</a></td><td>ALGOL for generalised grammars</td><td></td><td></td><td></td></tr><tr><td><a href="/facts/ALGOL_Y/wIHVS6Nq">ALGOL Y</a>Y</td><td>1966</td><td>Draft proposal</td><td>Intl</td><td>First version of Algol 68</td><td>Specification</td><td><a href="/facts/Association_for_Computing_Machinery/abI2atlP">ACM</a></td><td></td></tr><tr><td>ALGOL 68DR</td><td>1968</td><td>Draft proposal</td><td>Intl</td><td>IFIP WG 2.1 Draft Report</td><td>Specification – March</td><td>ACM</td><td></td></tr><tr><td>ALGOL 68r0</td><td>1968</td><td>Standard</td><td>Intl</td><td>IFIP WG 2.1 Final Report</td><td>Specification – August</td><td>ACM</td><td></td></tr><tr><td><a href="/facts/ALGOL_68-R/9Ed1AtrD">ALGOL 68-R</a>R</td><td>1970</td><td>Military</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td></td><td><a href="/facts/ICT_1900_series/P5wtuSGU">ICL 1900</a></td><td></td><td>ALGOL 60</td></tr><tr><td>EPOS ALGOLE</td><td>1971</td><td>Scientific</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td><a href="/facts/ALGOL_68RS/rCfL7Mcw">ALGOL 68RS</a>RS</td><td>1972</td><td>Military</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>Portable compiler system</td><td>ICL 2900/Series 39, Multics, VMS & C generator (1993)</td><td><a href="/facts/Crown_Copyright/JFrgyxae">Crown Copyright</a></td><td>ALGOL 68RS</td></tr><tr><td>Algol 68 with areas</td><td>1972</td><td>Experimental & other</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>Addition of areas to Algol 68</td><td></td><td></td><td></td></tr><tr><td>Mini ALGOL 68</td><td>1973</td><td>Research</td><td> <a href="/facts/Netherlands/y8xn5stT">NLD</a></td><td>Interpreter for ALGOL 68 subset<a class="footnote-ref" id="fnref:64" href="#fn:64">64</a></td><td>Portable interpreter</td><td><a href="/facts/Mathematisch_Centrum/GkPrQHzL">Mathematisch Centrum</a></td><td><a href="/facts/ALGOL_60/QnpxUYQm">ALGOL 60</a></td></tr><tr><td>OREGANO</td><td>1973</td><td>Research</td><td> <a href="/facts/United_States/P0sCdLe5">US</a></td><td>"The importance of implementation models."</td><td></td><td><a href="/facts/UCLA/KwPz7AK1">UCLA</a></td><td></td></tr><tr><td><a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a>C</td><td>1975</td><td>Scientific</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>Cambridge Algol 68</td><td><a href="/facts/International_Computers_Limited/2ztan410">ICL</a>, IBM 360, PDP-10 & Unix, <a href="/facts/Telefunken/y3fA4t3J">Telefunken</a>, TESLA 200,<a class="footnote-ref" id="fnref:65" href="#fn:65">65</a> <a href="/facts/Z80/Jeqe2h55">Z80</a> (1980)<a class="footnote-ref" id="fnref:66" href="#fn:66">66</a></td><td>Cambridge</td><td>ALGOL 68C</td></tr><tr><td>ALGOL 68 Revised Reportr1</td><td>1975</td><td>Standard</td><td>Intl</td><td>IFIP WG 2.1 Revised Report</td><td>Specification</td><td>ACM</td><td></td></tr><tr><td>Algol HH</td><td>1975</td><td>Experimental & other</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>Proposed extensions to the mode system of Algol 68</td><td>Specification</td><td></td><td><a href="/facts/ALGOL_W/xcgYM80d">ALGOL W</a></td></tr><tr><td><a href="/facts/Odra_(computer)/Nz2Yg7E3">Odra</a> Algol 68</td><td>1976</td><td>practical uses</td><td> <a href="/facts/Soviet_Union/m7wWsPto">Soviet Union</a>/ <a href="/facts/Poland/eXJ7fd0D">Poland</a></td><td></td><td>Odra 1204/IL</td><td><a href="/facts/Copyright_law_of_the_Soviet_Union/bBk97cmm">Soviet</a></td><td><a href="/facts/ALGOL_60/QnpxUYQm">ALGOL 60</a></td></tr><tr><td>Oklahoma ALGOL 68</td><td>1976</td><td>programming instruction</td><td> <a href="/facts/United_States/P0sCdLe5">USA</a></td><td><a href="/facts/Oklahoma_State_University/g0FHuPh3">Oklahoma State University</a> implementation<a class="footnote-ref" id="fnref:67" href="#fn:67">67</a><a class="footnote-ref" id="fnref:68" href="#fn:68">68</a></td><td><a href="/facts/IBM_1130/zQ9Acd05">IBM 1130</a> and <a href="/facts/System%2f370/TRo1jaFw">System/370</a>/158</td><td>Unknown</td><td>ANSI <a href="/facts/Fortran_66/m1KqjcMU">Fortran 66</a>.</td></tr><tr><td>Berlin ALGOL 68</td><td>1977</td><td>Research</td><td> <a href="/facts/Germany/paluuWBX">DE</a></td><td>Portable compiler for System/370, Siemens S4004, and <a href="/facts/PDP-11/9HkGUzFn">PDP-11</a><a class="footnote-ref" id="fnref:69" href="#fn:69">69</a><a class="footnote-ref" id="fnref:70" href="#fn:70">70</a></td><td>Machine-independent compiler</td><td><a href="/facts/Technische_Universit%25C3%25A4t_Berlin/Ao7c79ru">Technische Universität Berlin</a></td><td><a href="/facts/Compiler_Description_Language/xGNVxUok">CDL 2</a></td></tr><tr><td><a href="/facts/FLACC/H4GVnW50">FLACC</a>F</td><td>1977</td><td>Multi-purpose</td><td> <a href="/facts/Canada/D5P9yqs6">CAN</a></td><td>Revised Report complete implementation with debug features</td><td>System/370</td><td>lease, Chion Corporation</td><td>Assembler</td></tr><tr><td><a href="/facts/ALGOL_68-RT/9Ed1AtrD">ALGOL 68-RT</a>RT</td><td>1979</td><td>Scientific</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>Parallel ALGOL 68-R</td><td></td><td></td><td></td></tr><tr><td>RS Algolrs</td><td>1979</td><td>Scientific</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td></td><td></td><td></td><td></td></tr><tr><td>ALGOL 68+</td><td>1980</td><td>Scientific</td><td> <a href="/facts/Netherlands/y8xn5stT">NLD</a></td><td>Proposed superlanguage of ALGOL 68<a class="footnote-ref" id="fnref:71" href="#fn:71">71</a></td><td></td><td></td><td></td></tr><tr><td><a href="/facts/M-220/PfJnJQDn">M-220</a> ALGOL 68</td><td></td><td></td><td> <a href="/facts/Soviet_Union/m7wWsPto">Soviet Union</a></td><td></td><td>M-220</td><td><a href="/facts/Copyright_law_of_the_Soviet_Union/bBk97cmm">Soviet</a></td><td>EPSILON</td></tr><tr><td>Leningrad ALGOL 68L</td><td>1980</td><td>Telecommunications</td><td> <a href="/facts/Soviet_Union/m7wWsPto">Soviet Union</a></td><td>Full language + modules</td><td>IBM, DEC, CAMCOH, PS 1001 & PC</td><td><a href="/facts/Copyright_law_of_the_Soviet_Union/bBk97cmm">Soviet</a></td><td></td></tr><tr><td><a href="/facts/Interactive_ALGOL_68/ejabpPRs">Interactive ALGOL 68</a>I</td><td>1983</td><td></td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td><a href="/facts/Incremental_compilation/wJNodal0">Incremental compilation</a></td><td>PC</td><td>Noncommercial <a href="/facts/Shareware/TAhIvJXt">shareware</a></td><td></td></tr><tr><td><a href="/facts/ALGOL_68S/KqX8jtyx">ALGOL 68S</a>S</td><td>1985</td><td>Scientific</td><td>Intl</td><td>Sun version of ALGOL 68</td><td><a href="/facts/Sun-3/G6kAvXgK">Sun-3</a>, Sun <a href="/facts/SPARC/m7KhEtET">SPARC</a> (under <a href="/facts/SunOS/oWMcGLqc">SunOS</a> 4.1 & <a href="/facts/Solaris_(operating_system)/KPfT98EJ">Solaris</a> 2), <a href="/facts/Atari/XK95bfqH">Atari</a> ST (under <a href="/facts/Atari_ST/9GsYSlaM">GEMDOS</a>), <a href="/facts/Acorn_Archimedes/BxInoqjT">Acorn Archimedes</a> (under <a href="/facts/RISC_OS/Pc96teso">RISC OS</a>), <a href="/facts/VAX-11/prkm7jvA">VAX-11</a> under <a href="/facts/Ultrix-32/NWH3Udfj">Ultrix-32</a></td><td></td><td></td></tr><tr><td>Algol68toC<a class="footnote-ref" id="fnref:72" href="#fn:72">72</a> (ctrans)</td><td>1985</td><td>Electronics</td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td>ctrans from <a href="/facts/ELLA_(programming_language)/FbYawPf5">ELLA</a> <a href="/facts/ALGOL_68RS/rCfL7Mcw">ALGOL 68RS</a></td><td>Portable C generator </td><td><a href="/facts/Open-source_software/HzTaB8E9">Open-source software</a> (1995)</td><td>ALGOL 68RS</td></tr><tr><td>MK2 <a href="/facts/Interactive_ALGOL_68/ejabpPRs">Interactive ALGOL 68</a></td><td>1992</td><td></td><td> <a href="/facts/United_Kingdom/kuPAILt2">UK</a></td><td><a href="/facts/Incremental_compilation/wJNodal0">Incremental compilation</a></td><td>PC</td><td>Noncommercial shareware<a class="footnote-ref" id="fnref:73" href="#fn:73">73</a></td><td></td></tr><tr><td>Algol 68 GenieG</td><td>2001</td><td>Full language</td><td> <a href="/facts/Netherlands/y8xn5stT">NLD</a></td><td>Includes standard collateral clause</td><td>Portable interpreter</td><td><a href="/facts/GPL/S75KhLSX">GPL</a></td><td><a href="/facts/C_(programming_language)/Ky2No763">C</a></td></tr><tr><td>Algol 68 Genie version 2.0.0</td><td>2010</td><td>Full language</td><td> <a href="/facts/Netherlands/y8xn5stT">NLD</a></td><td></td><td>Portable interpreter; optional compilation of selected units</td><td><a href="/facts/GPL/S75KhLSX">GPL</a></td><td><a href="/facts/C_(programming_language)/Ky2No763">C</a></td></tr><tr><td><a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC</a> (ga68)</td><td>2025</td><td>Full language</td><td> <a href="/facts/Spain/bIyrB8EY">ESP</a></td><td>GCC Front-End</td><td>Portable compiler</td><td><a href="/facts/GPL/S75KhLSX">GPL</a></td><td><a href="/facts/C_(programming_language)/Ky2No763">C</a></td></tr></tbody></table>
The <a href="/facts/S3_(programming_language)/QDfn25ha">S3 language</a> that was used to write the <a href="/facts/ICL_VME/6rICze0T">ICL VME</a> operating system and much other system software on the <a href="/facts/ICL_2900_Series/ka6K2NFC">ICL 2900 Series</a> was a direct derivative of Algol 68. However, it omitted many of the more complex features, and replaced the basic modes with a set of data types that mapped directly to the 2900 Series hardware architecture.

<h3>Implementation specific extensions</h3>
ALGOL 68R from <a href="/facts/Royal_Radar_Establishment/jsUq834G">RRE</a> was the first ALGOL 68 subset implementation, running on the <a href="/facts/ICT_1900_series/P5wtuSGU">ICL 1900</a>. Based on the original language, the main subset restrictions were definition before use and no parallel processing. This compiler was popular in <a href="/facts/United_Kingdom/kuPAILt2">UK</a> universities in the 1970s, where many <a href="/facts/Computer_science/lN3pEyPz">computer science</a> students learnt ALGOL 68 as their first programming language; the compiler was renowned for good error messages.
ALGOL 68RS(RS) from <a href="/facts/Royal_Signals_and_Radar_Establishment/G96SheBm">RSRE</a> was a portable compiler system written in ALGOL 68RS (bootstrapped from ALGOL 68R), and implemented on a variety of systems including the <a href="/facts/ICL_2900_Series/ka6K2NFC">ICL 2900</a>/<a href="/facts/ICL_Series_39/nC53rNBg">Series 39</a>, <a href="/facts/Multics/y7A5peyu">Multics</a> and <a href="/facts/VAX/N3r13IHH">DEC VAX/VMS</a>. The language was based on the Revised Report, but with similar subset restrictions to ALGOL 68R. This compiler survives in the form of an Algol68-to-C compiler.
In ALGOL 68S(S) from <a href="/facts/Carnegie_Mellon_University/XKd7L2KA">Carnegie Mellon University</a> the power of parallel processing was improved by adding an orthogonal extension, eventing. Any variable declaration containing keyword EVENT made assignments to this variable eligible for parallel evaluation, i.e. the right hand side was made into a procedure which was moved to one of the processors of the <a href="/facts/C.mmp/1YtX3NJl">C.mmp</a> multiprocessor system. Accesses to such variables were delayed after termination of the assignment.
<a href="/facts/University_of_Cambridge/0la7aX9o">Cambridge</a> <a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a>(C) was a portable compiler that implemented a subset of ALGOL 68, restricting operator definitions and omitting garbage collection, flexible rows and formatted transput.
Algol 68 Genie(G) by M. van der Veer is an ALGOL 68 implementation for today's computers and operating systems.
"Despite good intentions, a programmer may violate portability by inadvertently employing a local extension. To guard against this, each implementation should provide a PORTCHECK pragmat option. While this option is in force, the compiler prints a message for each construct that it recognizes as violating some portability constraint."<a class="footnote-ref" id="fnref:74" href="#fn:74">74</a>

<h2 id="quotes">Quotes</h2>
<ul><li>... The scheme of type composition adopted by C owes considerable debt to Algol 68, although it did not, perhaps, emerge in a form that Algol's adherents would approve of. The central notion I captured from Algol was a type structure based on atomic types (including structures), composed into arrays, pointers (references), and functions (procedures). Algol 68's concept of unions and casts also had an influence that appeared later. <a href="/facts/Dennis_Ritchie/I1yu1UWU">Dennis Ritchie</a> Apr 1993.<a class="footnote-ref" id="fnref:75" href="#fn:75">75</a></li>
<li>... C does not descend from Algol 68 is true, yet there was influence, much of it so subtle that it is hard to recover even when I think hard. In particular, the union type (a late addition to C) does owe to A68, not in any details, but in the idea of having such a type at all. More deeply, the type structure in general and even, in some strange way, the declaration syntax (the type-constructor part) was inspired by A68. And yes, of course, "long". <a href="/facts/Dennis_Ritchie/I1yu1UWU">Dennis Ritchie</a>, 18 June 1988<a class="footnote-ref" id="fnref:76" href="#fn:76">76</a></li>
<li>"Congratulations, your Master has done it" – <a href="/facts/Niklaus_Wirth/krsLUB11">Niklaus Wirth</a><a class="footnote-ref" id="fnref:77" href="#fn:77">77</a></li>
<li>The more I see of it, the more unhappy I become – E. W. Dijkstra, 1968<a class="footnote-ref" id="fnref:78" href="#fn:78">78</a></li>
<li>[...] it was said that A68's popularity was inversely proportional to [...] the distance from Amsterdam – <a href="/facts/Guido_van_Rossum/xADcJVjl">Guido van Rossum</a><a class="footnote-ref" id="fnref:79" href="#fn:79">79</a></li>
<li>[...] The best we could do was to send with it a minority report, stating our considered view that, "... as a tool for the reliable creation of sophisticated programs, the language was a failure." [...] – <a href="/facts/Tony_Hoare/vBeb3cmn">C. A. R. Hoare</a> in his Oct 1980 <a href="/facts/Turing_Award/HbEEp0GF">Turing Award</a> Lecture<a class="footnote-ref" id="fnref:80" href="#fn:80">80</a></li>
<li>"[...] More than ever it will be required from an adequate programming tool that it assists, by structure, the programmer in the most difficult aspects of his job, viz. in the reliable creation of sophisticated programs. In this respect we fail to see how the language proposed here is a significant step forward: on the contrary, we feel that its implicit view of the programmer's task is very much the same as, say, ten years ago. This forces upon us the conclusion that, regarded as a programming tool, the language must be regarded as obsolete. [...]" 1968 Working Group minority report on 23 December 1968.<a class="footnote-ref" id="fnref:81" href="#fn:81">81</a></li></ul>
<h2 id="see-also">See also</h2>

<ul><li><a href="/facts/ALGOL_60/QnpxUYQm">ALGOL 60</a></li>
<li><a href="/facts/ALGOL_Y/wIHVS6Nq">ALGOL Y</a></li>
<li><a href="/facts/ALGOL_N/UJuhLmBD">ALGOL N</a></li>
<li><a href="/facts/ALGOL_68C/XMd0oYIK">ALGOL 68C</a></li>
<li><a href="/facts/C_(programming_language)/Ky2No763">C (programming language)</a></li>
<li><a href="/facts/C%252B%252B/Et0F2qn9">C++</a></li>
<li><a href="/facts/Bourne_shell/wUCh3Qkl">Bourne shell</a></li>
<li><a href="/facts/Bash_(Unix_shell)/RrYLtEJT">Bash (Unix shell)</a></li>
<li><a href="/facts/Steelman_language_requirements/VxNee2wJ">Steelman language requirements</a></li>
<li><a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada (programming language)</a></li>
<li><a href="/facts/Python_(programming_language)/YbuGqofa">Python (programming language)</a></li></ul>

<h3>Citations</h3>

<h3>Works cited</h3>

<ul><li>Brailsford, D. F. and Walker, A. N., Introductory ALGOL 68 Programming, Ellis Horwood/Wiley, 1979</li>
<li>Lindsey, C. H. and van der Meulen, S. G., Informal Introduction to ALGOL 68, North-Holland, 1971</li>
<li>Lindsey, C. H. (1993-03-02). <a href="https://doi.org/10.1145%2F155360.155365">"A History of ALGOL 68"</a>. ACM SIGPLAN Notices. 28 (3): 97–132. <a href="/facts/Doi_(identifier)/muM9Etpq">doi</a>:<a href="https://doi.org/10.1145%2F155360.155365">10.1145/155360.155365</a>.</li>
<li>McGettrick, A. D., ALGOL 68, A First and Second Course, Cambridge Univ. Press, 1978</li>
<li>Peck, J. E. L., An ALGOL 68 Companion, Univ. of British Columbia, October 1971</li>
<li>Tanenbaum, A. S., A Tutorial on ALGOL 68, Computing Surveys 8, 155-190, June 1976 and 9, 255-256, September 1977, <a href="http://vestein.arb-phys.uni-dortmund.de/~wb/RR/tanenbaum.pdf">[6]</a>[permanent dead link]</li>
<li>Woodward, P. M. and Bond, S. G., ALGOL 68-R Users<a href="/facts/Sic/qB9MUUWF">sic</a> Guide, London, Her Majesty's Stationery Office, 1972</li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="http://www.softwarepreservation.org/projects/ALGOL/report/Algol68_revised_report-AB.pdf">Revised Report on the Algorithmic Language ALGOL 68</a> The official reference for users and implementors of the language (large pdf file, scanned from Algol Bulletin)</li>
<li><a href="https://web.archive.org/web/20150906170502/http://jmvdveer.home.xs4all.nl/algol68/report.html">Revised Report on the Algorithmic Language ALGOL 68</a> Hyperlinked HTML version of the Revised Report</li>
<li><a href="http://portal.acm.org/citation.cfm?id=356671">A Tutorial on Algol 68</a>, by <a href="/facts/Andrew_S._Tanenbaum/fFuDWfaR">Andrew S. Tanenbaum</a>, in Computing Surveys, Vol. 8, No. 2, June 1976, with <a href="http://portal.acm.org/citation.cfm?id=356706">Corrigenda</a> (Vol. 9, No. 3, September 1977)</li>
<li><a href="https://jmvdveer.home.xs4all.nl/en.algol-68-genie.html">Algol 68 Genie – a GNU GPL Algol 68 compiler-interpreter</a></li>
<li><a href="http://algol68.sourceforge.net/">Open source ALGOL 68 implementations, on SourceForge</a></li>
<li><a href="http://www.fh-jena.de/~kleine/history/languages/Algol68-RR-HardwareRepresentation.pdf">Algol68 Standard Hardware representation (.pdf)</a> <a href="https://web.archive.org/web/20140102201013/http://www.fh-jena.de/~kleine/history/languages/Algol68-RR-HardwareRepresentation.pdf">Archived</a> 2014-01-02 at the <a href="/facts/Wayback_Machine/nmQ3a6JC">Wayback Machine</a></li>
<li><a href="http://www.computer-museum.ru/histsoft/algol68.htm">Из истории создания компилятора с Алгол 68</a></li>
<li><a href="http://www.computer-museum.ru/english/algol68.htm">Algol 68 – 25 Years in the USSR</a></li>
<li><a href="https://web.archive.org/web/20060310003954/http://ant.tepkom.ru/newsite/disser/doc/Ruchlin.htm">Система программ динамической поддержки для транслятора с Алгол 68</a></li>
<li><a href="https://web.archive.org/web/19980220175804/http://cm.bell-labs.com/cm/cs/who/dmr/chist.html">C history with Algol68 heritage</a></li>
<li>McJones, Paul, <a href="http://www.softwarepreservation.org/projects/ALGOL/algol68impl">"Algol 68 implementations and dialects"</a>, Software Preservation Group, <a href="/facts/Computer_History_Museum/Y9Q5XevR">Computer History Museum</a>, 2011-07-05</li>
<li><a href="https://archive.today/20150416164933/http://vintagebigblue.org/Compilerator/ALGOL68C/mvsAlgol68CCompile.php">Web enabled ALGOL 68 compiler for small experiments</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1">Veer, Marcel van der (2023-04-05). "Revised Report on the Algorithmic Language Algol 68". jmvdveer.home.xs4all.nl/. 0.1. Aims and principles of design. Archived from the original on 2013-03-17. <a href="https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#011" target="_blank">https://web.archive.org/web/20130317015548/http://jmvdveer.home.xs4all.nl/report.html#011</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></li>
<li id="fn:2">"Gommas?". <a href="https://groups.google.com/group/comp.lang.misc/msg/03af5063e1662d4d" target="_blank">https://groups.google.com/group/comp.lang.misc/msg/03af5063e1662d4d</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></li>
<li id="fn:3">Revised Report on the Algorithmic Language Algol 68 Archived 2013-03-17 at the Wayback Machine. jmvdveer.home.xs4all.nl (1968-12-20). Retrieved on 2013-07-21. <a href="http://jmvdveer.home.xs4all.nl/report.html#03B" target="_blank">http://jmvdveer.home.xs4all.nl/report.html#03B</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></li>
<li id="fn:4">Terekhov, Andrey (2014). ALGOL 68 and Its Impact on the USSR and Russian Programming. 2014 Third International Conference on Computer Technology in Russia and in the Former Soviet Union. pp. 97–106. doi:10.1109/SoRuCom.2014.29. ISBN 978-1-4799-1799-0. S2CID 16097093. <a href="978-1-4799-1799-0" target="_blank">978-1-4799-1799-0</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></li>
<li id="fn:5">Терехов, Андрей Николаевич (2014). Алгол 68 и его влияние на программирование в СССР и России [Algol 68 and its influence on programming in the USSR and Russia] (PDF). Третья Международная конференция, Развитие вычислительной техники и ее программного обеспечения в России и странах бывшего СССР: история и перспективы (in Russian). pp. 336–347. <a href="https://sorucom.iis.nsk.su/files/news/sorucom2014.pdf" target="_blank">https://sorucom.iis.nsk.su/files/news/sorucom2014.pdf</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></li>
<li id="fn:6">Lindsey, Charles H. (1996). "A History of ALGOL 68". In Bergin, T. J.; Gibson, R. G. (eds.). History of Programming Languages II. ACM Press. pp. 27–96. ISBN 978-0-201-89502-5. Also in Lindsey, C. H. (March 1993). "A history of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. Includes a comprehensive bibliography of the meetings and discussions before, during and after development of ALGOL 68. <a href="978-0-201-89502-5" target="_blank">978-0-201-89502-5</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></li>
<li id="fn:7">Programming Algol 68 Made Easy <a href="http://www.nunan.myzen.co.uk/algol68/pame.pdf" target="_blank">http://www.nunan.myzen.co.uk/algol68/pame.pdf</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></li>
<li id="fn:8">Veer, Marcel van der. "Marcel van der Veer - Algol 68 Genie". jmvdveer.home.xs4all.nl/. <a href="https://jmvdveer.home.xs4all.nl//en.algol-68-genie.html" target="_blank">https://jmvdveer.home.xs4all.nl//en.algol-68-genie.html</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></li>
<li id="fn:9">Lindsey 1993, p. 7. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></li>
<li id="fn:10">Lindsey 1993, p. 9. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></li>
<li id="fn:11">Lindsey 1993, p. 4. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></li>
<li id="fn:12">Ross, Douglas T. (October 1966). "An Algorithmic Theory of Language (AB26.2.2)". Defense Technical Information Center. Massachusetts Institute of Technology. p. 6. Archived from the original on 2013-06-26. Retrieved 2020-08-12. <a href="https://web.archive.org/web/20130626171225/http://www.dtic.mil/cgi-bin/GetTRDoc?AD=AD0296998" target="_blank">https://web.archive.org/web/20130626171225/http://www.dtic.mil/cgi-bin/GetTRDoc?AD=AD0296998</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></li>
<li id="fn:13">Ross, D. T. (August 1967). "AB26.2.2 Features Essential for a Workable ALGOL X". ACM SIGPLAN Notices: ALGOL Bulletin. 26 (2). Association for Computing Machinery: Digital Library. doi:10.1145/1139498.1139500. S2CID 38156680. Retrieved 2020-08-12. <a href="https://dl.acm.org/doi/abs/10.1145/1139498.1139500" target="_blank">https://dl.acm.org/doi/abs/10.1145/1139498.1139500</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></li>
<li id="fn:14">Lindsey 1993, p. 9. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></li>
<li id="fn:15">Lindsey 1993, p. 24. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></li>
<li id="fn:16">Lindsey 1993, p. 10. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></li>
<li id="fn:17">"The Algol Bulletin". <a href="http://archive.computerhistory.org/resources/text/algol/algol_bulletin/" target="_blank">http://archive.computerhistory.org/resources/text/algol/algol_bulletin/</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></li>
<li id="fn:18">Lindsey 1993, p. 10. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></li>
<li id="fn:19">Lindsey 1993, p. 9. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></li>
<li id="fn:20">Lindsey 1993, p. 9. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></li>
<li id="fn:21">Lindsey 1993, p. 12. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></li>
<li id="fn:22">Lindsey, C. H. (1972). "ALGOL 68 with fewer tears" (PDF). The Computer Journal. 15 (1): 176–188. doi:10.1093/comjnl/15.2.176. <a href="https://academic.oup.com/comjnl/article-pdf/15/2/176/1002964/15-2-176.pdf" target="_blank">https://academic.oup.com/comjnl/article-pdf/15/2/176/1002964/15-2-176.pdf</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></li>
<li id="fn:23">Lindsey 1993, p. 12. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></li>
<li id="fn:24">Lindsey 1993, p. 13. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></li>
<li id="fn:25">Lindsey 1993, p. 15. - Lindsey, C. H. (1993-03-02). "A History of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. <a href="https://doi.org/10.1145%2F155360.155365" target="_blank">https://doi.org/10.1145%2F155360.155365</a> <a href="#fnref:25" class="footnote-back-ref">↩</a></li>
<li id="fn:26">Hoare, C. A. R. (November 1968). "Critique of MR93 (Critique of ALGOL 68)". ALGOL Bulletin. 29: 27–29. <a href="/wiki/Tony_Hoare" target="_blank">/wiki/Tony_Hoare</a> <a href="#fnref:26" class="footnote-back-ref">↩</a></li>
<li id="fn:27">Peck, J. E. L., ed. (1970), Proceedings of the IFIP working conference on ALGOL 68 Implementation, Munich: North-Holland, ISBN 0-7204-2045-8 <a href="0-7204-2045-8" target="_blank">0-7204-2045-8</a> <a href="#fnref:27" class="footnote-back-ref">↩</a></li>
<li id="fn:28">Koster, C. H. A. "A Shorter History of Algol 68". Archived from the original on 2007-12-17. <a href="https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt" target="_blank">https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt</a> <a href="#fnref:28" class="footnote-back-ref">↩</a></li>
<li id="fn:29">Peck, J. E. L., ed. (1970), Proceedings of the IFIP working conference on ALGOL 68 Implementation, Munich: North-Holland, ISBN 0-7204-2045-8 <a href="0-7204-2045-8" target="_blank">0-7204-2045-8</a> <a href="#fnref:29" class="footnote-back-ref">↩</a></li>
<li id="fn:30">Koster, C. H. A. "A Shorter History of Algol 68". Archived from the original on 2007-12-17. <a href="https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt" target="_blank">https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt</a> <a href="#fnref:30" class="footnote-back-ref">↩</a></li>
<li id="fn:31">Koster, C. H. A. "A Shorter History of Algol 68". Archived from the original on 2007-12-17. <a href="https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt" target="_blank">https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt</a> <a href="#fnref:31" class="footnote-back-ref">↩</a></li>
<li id="fn:32">Koster, C. H. A. "A Shorter History of Algol 68". Archived from the original on 2007-12-17. <a href="https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt" target="_blank">https://web.archive.org/web/20071217203826/http://npt.cc.rsu.ru/user/wanderer/ODP/ALGOL68.txt</a> <a href="#fnref:32" class="footnote-back-ref">↩</a></li>
<li id="fn:33">van der Veer, Marcel. "Open source Algol 68 implementations". algol68.sourceforge.net. <a href="http://algol68.sourceforge.net/" target="_blank">http://algol68.sourceforge.net/</a> <a href="#fnref:33" class="footnote-back-ref">↩</a></li>
<li id="fn:34">E. Marchesi, Jose. "Algol 68 Front-End". gcc.gnu.org. <a href="https://gcc.gnu.org/wiki/Algol68FrontEnd" target="_blank">https://gcc.gnu.org/wiki/Algol68FrontEnd</a> <a href="#fnref:34" class="footnote-back-ref">↩</a></li>
<li id="fn:35">E. Marchesi, Jose. "An Algol 68 front end for GCC". lwn.net. <a href="https://lwn.net/Articles/1003916/" target="_blank">https://lwn.net/Articles/1003916/</a> <a href="#fnref:35" class="footnote-back-ref">↩</a></li>
<li id="fn:36">Van Wijngaarden, A.; Mailloux, B. J.; Peck, J.; Koster, C. H. A. (1968-03-01). "Draft Report on the Algorithmic Language ALGOL 68". ALGOL Bulletin (Sup 26): 1–84. Retrieved 2023-04-07 – via Mar. 1968. <a href="https://dl.acm.org/doi/10.5555/1064072.1064073" target="_blank">https://dl.acm.org/doi/10.5555/1064072.1064073</a> <a href="#fnref:36" class="footnote-back-ref">↩</a></li>
<li id="fn:37">Sidney Marshall, "ALGOL 68 Implementation", Proceedings of the IFIP Working Conference on ALGOL 68 Implementation, Munich, 20–24 July 1970, J. E. L. Peck, editor, North Holland, pages 239–243. <a href="#fnref:37" class="footnote-back-ref">↩</a></li>
<li id="fn:38">Sidney Marshall, On the implementation of ALGOL 68, PhD Thesis, Dartmouth College, 1972. <a href="#fnref:38" class="footnote-back-ref">↩</a></li>
<li id="fn:39">Algol 68 Revised Report <a href="https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html" target="_blank">https://web.archive.org/web/20130101062456/http://jmvdveer.home.xs4all.nl/report.html</a> <a href="#fnref:39" class="footnote-back-ref">↩</a></li>
<li id="fn:40">Black, A. P.; Rayward-Smith, V. J. (1978-05-01). "Proposals for ALGOL H - A Superlanguage of ALGOL 68". ALGOL Bulletin (42): 36–49. Retrieved 2023-04-07 – via May. 1978. <a href="https://dl.acm.org/doi/10.5555/1061701.1061711" target="_blank">https://dl.acm.org/doi/10.5555/1061701.1061711</a> <a href="#fnref:40" class="footnote-back-ref">↩</a></li>
<li id="fn:41">"Algol68 S(S) published on the internet". Archived from the original on 2005-12-03. Retrieved 2004-08-30. <a href="https://web.archive.org/web/20051203193706/http://www.cs.man.ac.uk/~chl/index.html#ALGOL%2068" target="_blank">https://web.archive.org/web/20051203193706/http://www.cs.man.ac.uk/~chl/index.html#ALGOL%2068</a> <a href="#fnref:41" class="footnote-back-ref">↩</a></li>
<li id="fn:42">Veer, Marcel van der. "The Algol 68 Genie project". jmvdveer.home.xs4all.nl. Retrieved 2023-04-07. <a href="https://jmvdveer.home.xs4all.nl/en.algol-68-genie.html" target="_blank">https://jmvdveer.home.xs4all.nl/en.algol-68-genie.html</a> <a href="#fnref:42" class="footnote-back-ref">↩</a></li>
<li id="fn:43">E. Marchesi, Jose. "An Algol 68 front end for GCC". lwn.net. <a href="https://lwn.net/Articles/1003916/" target="_blank">https://lwn.net/Articles/1003916/</a> <a href="#fnref:43" class="footnote-back-ref">↩</a></li>
<li id="fn:44">E. Marchesi, Jose. "Algol 68 Front-End". gcc.gnu.org. <a href="https://gcc.gnu.org/wiki/Algol68FrontEnd" target="_blank">https://gcc.gnu.org/wiki/Algol68FrontEnd</a> <a href="#fnref:44" class="footnote-back-ref">↩</a></li>
<li id="fn:45">"Draft Report on the Algorithmic Language ALGOL 68". March 1968. Archived from the original on 2007-09-30. Retrieved 2007-06-22. <a href="http://archive.computerhistory.org/resources/text/algol/algol_bulletin/AS26/" target="_blank">http://archive.computerhistory.org/resources/text/algol/algol_bulletin/AS26/</a> <a href="#fnref:45" class="footnote-back-ref">↩</a></li>
<li id="fn:46">"Penultimate Draft Report on the Algorithmic Language ALGOL 68 – Chapters 1-9" (PDF). October 1968. Retrieved 2007-06-22.[permanent dead link] <a href="http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9180A.pdf" target="_blank">http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9180A.pdf</a> <a href="#fnref:46" class="footnote-back-ref">↩</a></li>
<li id="fn:47">"Penultimate Draft Report on the Algorithmic Language ALGOL 68 – Chapters 10-12" (PDF). October 1968. Retrieved 2007-06-22.[permanent dead link] <a href="http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9179A.pdf" target="_blank">http://repos.project.cwi.nl:8888/cwi_repository/docs/I/09/9179A.pdf</a> <a href="#fnref:47" class="footnote-back-ref">↩</a></li>
<li id="fn:48">"Report on the Algorithmic Language ALGOL 68" (PDF). December 1968. Archived from the original (PDF) on 2008-04-06. Retrieved 2007-12-30. <a href="https://web.archive.org/web/20080406061108/http://www.fh-jena.de/~kleine/history/languages/Algol68-Report.pdf" target="_blank">https://web.archive.org/web/20080406061108/http://www.fh-jena.de/~kleine/history/languages/Algol68-Report.pdf</a> <a href="#fnref:48" class="footnote-back-ref">↩</a></li>
<li id="fn:49">"Revised Report on the Algorithmic Language Algol 68". September 1973. Archived from the original on 2007-09-27. Retrieved 2007-04-30. <a href="http://burks.brighton.ac.uk/burks/language/other/a68rr/rrtoc.htm" target="_blank">http://burks.brighton.ac.uk/burks/language/other/a68rr/rrtoc.htm</a> <a href="#fnref:49" class="footnote-back-ref">↩</a></li>
<li id="fn:50">Lindsey, Charles H. (1996). "A History of ALGOL 68". In Bergin, T. J.; Gibson, R. G. (eds.). History of Programming Languages II. ACM Press. pp. 27–96. ISBN 978-0-201-89502-5. Also in Lindsey, C. H. (March 1993). "A history of ALGOL 68". ACM SIGPLAN Notices. 28 (3): 97–132. doi:10.1145/155360.155365. Includes a comprehensive bibliography of the meetings and discussions before, during and after development of ALGOL 68. <a href="978-0-201-89502-5" target="_blank">978-0-201-89502-5</a> <a href="#fnref:50" class="footnote-back-ref">↩</a></li>
<li id="fn:51">Lu Hu-quan (1971). "The Translation of Algol 68 into Chinese" (PDF). Peking, China: Institute of Mathematics, Academia Sinica. Retrieved 2012-08-17. <a href="http://archive.computerhistory.org/resources/text/algol/ACM_Algol_bulletin/1061739/p33-ru_ian.pdf" target="_blank">http://archive.computerhistory.org/resources/text/algol/ACM_Algol_bulletin/1061739/p33-ru_ian.pdf</a> <a href="#fnref:51" class="footnote-back-ref">↩</a></li>
<li id="fn:52">"GOST 27974-88 Programming language ALGOL 68 – Язык программирования АЛГОЛ 68" (PDF) (in Russian). GOST. 1988. Archived from the original (PDF) on 2008-11-15. Retrieved 2008-11-15. <a href="https://web.archive.org/web/20081115035038/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf" target="_blank">https://web.archive.org/web/20081115035038/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27974-88.pdf</a> <a href="#fnref:52" class="footnote-back-ref">↩</a></li>
<li id="fn:53">"GOST 27975-88 Programming language ALGOL 68 extended – Язык программирования АЛГОЛ 68 расширенный" (PDF) (in Russian). GOST. 1988. Archived from the original (PDF) on 2011-04-29. Retrieved 2008-11-15. <a href="https://web.archive.org/web/20110429001243/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27975-88.pdf" target="_blank">https://web.archive.org/web/20110429001243/http://vak.ru/lib/exe/fetch.php/book/gost/pdf/gost-27975-88.pdf</a> <a href="#fnref:53" class="footnote-back-ref">↩</a></li>
<li id="fn:54">"Format syntax in ALGOL 68G". Archived from the original on 2008-01-09. Retrieved 2023-04-07. <a href="https://web.archive.org/web/20080109161728/http://www.xs4all.nl/~jmvdveer/syntax.html#formats" target="_blank">https://web.archive.org/web/20080109161728/http://www.xs4all.nl/~jmvdveer/syntax.html#formats</a> <a href="#fnref:54" class="footnote-back-ref">↩</a></li>
<li id="fn:55">Needham, R. M.; Wilkes, M. V. (January 1979). "The Cambridge CAP Computer and its Operating System" (PDF). Microsoft Research. <a href="http://research.microsoft.com/pubs/72418/cap.pdf" target="_blank">http://research.microsoft.com/pubs/72418/cap.pdf</a> <a href="#fnref:55" class="footnote-back-ref">↩</a></li>
<li id="fn:56">David Holdsworth (Winter 2009–2010). "KDF9 Time Sharing: Eldon 2 is not EGDON!". Computer Resurrection – Number 49. Computer Conservation Society. Retrieved 2010-10-03. <a href="http://www.cs.man.ac.uk/CCS/res/res49.htm#e" target="_blank">http://www.cs.man.ac.uk/CCS/res/res49.htm#e</a> <a href="#fnref:56" class="footnote-back-ref">↩</a></li>
<li id="fn:57">I F Currie; J M Foster (September 1982). "RSRE Memorandum" (PDF). vitanuova.com. Retrieved 2023-04-07. <a href="http://www.vitanuova.com/dist/doc/rsre-3522-curt.pdf" target="_blank">http://www.vitanuova.com/dist/doc/rsre-3522-curt.pdf</a> <a href="#fnref:57" class="footnote-back-ref">↩</a></li>
<li id="fn:58">Эльбрус Бабаяна и Pentium Пентковского. Ixbt.com. Retrieved 21 July 2013. <a href="http://www.ixbt.com/cpu/e2k-spec.html" target="_blank">http://www.ixbt.com/cpu/e2k-spec.html</a> <a href="#fnref:58" class="footnote-back-ref">↩</a></li>
<li id="fn:59">Oliver, J. R.; Newton, R. S. (1979). "Practical experience with ALGOL 68-RT". The Computer Journal. 22 (2): 114–118. doi:10.1093/comjnl/22.2.114. <a href="https://doi.org/10.1093%2Fcomjnl%2F22.2.114" target="_blank">https://doi.org/10.1093%2Fcomjnl%2F22.2.114</a> <a href="#fnref:59" class="footnote-back-ref">↩</a></li>
<li id="fn:60">Applications, libraries, and test suites — Software Preservation Group. Softwarepreservation.org. Retrieved 21 July 2013. <a href="http://www.softwarepreservation.org/projects/ALGOL/applications#ALGOL_68_Libraries" target="_blank">http://www.softwarepreservation.org/projects/ALGOL/applications#ALGOL_68_Libraries</a> <a href="#fnref:60" class="footnote-back-ref">↩</a></li>
<li id="fn:61">Lindsey, C. H. (July 1974). "Partial Parametrization". ALGOL Bulletin (37): 24–26. Retrieved 2022-09-19. <a href="https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A37/P42.HTM" target="_blank">https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A37/P42.HTM</a> <a href="#fnref:61" class="footnote-back-ref">↩</a></li>
<li id="fn:62">Lindsey, C. H.; Boom, H. J. (December 1978). "A Modules and Separate Compilation facility for ALGOL 68". ALGOL Bulletin (43): 19–53. Retrieved 2020-01-29. Comments errata <a href="https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A43/P32.HTM" target="_blank">https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A43/P32.HTM</a> <a href="#fnref:62" class="footnote-back-ref">↩</a></li>
<li id="fn:63">Lindsey, C. H. (July 1974). "Modals". ALGOL Bulletin (37): 26–29. Retrieved 2022-09-19. <a href="https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A37/P43.HTM" target="_blank">https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A37/P43.HTM</a> <a href="#fnref:63" class="footnote-back-ref">↩</a></li>
<li id="fn:64">"An interpreter for simple Algol 68 Programs" (PDF). Archived from the original (PDF) on 2011-07-18. <a href="https://web.archive.org/web/20110718172314/http://oai.cwi.nl/oai/asset/9494/9494A.pdf" target="_blank">https://web.archive.org/web/20110718172314/http://oai.cwi.nl/oai/asset/9494/9494A.pdf</a> <a href="#fnref:64" class="footnote-back-ref">↩</a></li>
<li id="fn:65">Nadrchal, J. (May 1978). "AB42.2.1 Implementation on TESLA 200". Algol Bulletin (42). <a href="https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A42/P21.HTM" target="_blank">https://archive.computerhistory.org/resources/text/algol/algol_bulletin/A42/P21.HTM</a> <a href="#fnref:65" class="footnote-back-ref">↩</a></li>
<li id="fn:66">Anderson, Raymond (March 1980). "ALGOL68C on the Z80" (PDF). Liverpool Software Gazette (Third ed.): 52–57. Archived from the original (PDF) on 2010-04-15. Retrieved 2010-03-20. <a href="https://web.archive.org/web/20100415194813/http://www.80bus.co.uk/publications/magazines/LSG3.pdf" target="_blank">https://web.archive.org/web/20100415194813/http://www.80bus.co.uk/publications/magazines/LSG3.pdf</a> <a href="#fnref:66" class="footnote-back-ref">↩</a></li>
<li id="fn:67">Hedrick, G.E.; Robertson, Alan (10–12 June 1975). The Oklahoma State ALGOL 68 Subset Compiler. 1975 International Conference on ALGOL 68. Stillwater, OK. <a href="#fnref:67" class="footnote-back-ref">↩</a></li>
<li id="fn:68">Hedrick, G.E. (August 1977). "ALGOL68 instruction at Oklahoma State University". ACM SIGCSE Bulletin. 9 (3). New York, NY, USA: ACM: 16–20. doi:10.1145/382175.803425. <a href="/wiki/Doi_(identifier)" target="_blank">/wiki/Doi_(identifier)</a> <a href="#fnref:68" class="footnote-back-ref">↩</a></li>
<li id="fn:69">Koch, Wilfried; Oeters, Christoph (1977). "The Berlin ALGOL 68 implementation". ACM SIGPLAN Notices. 12 (6): 102–108. doi:10.1145/872738.807149. <a href="/wiki/Doi_(identifier)" target="_blank">/wiki/Doi_(identifier)</a> <a href="#fnref:69" class="footnote-back-ref">↩</a></li>
<li id="fn:70">Koch, W.; Oeters, C. (1975). Mülbacher, J. (ed.). An abstract ALGOL 68 machine and its application in a machine independent compiler. GI — 5. Jahrestagung. Lecture Notes in Computer Science. Vol. 34. Berlin, Heidelberg: Springer. pp. 642–653. doi:10.1007/3-540-07410-4_665. <a href="/wiki/Doi_(identifier)" target="_blank">/wiki/Doi_(identifier)</a> <a href="#fnref:70" class="footnote-back-ref">↩</a></li>
<li id="fn:71">"The Encyclopedia of Computer Languages". Archived from the original on 2011-03-10. Retrieved 2010-03-20. <a href="https://web.archive.org/web/20110310110439/http://hopl.murdoch.edu.au/showlanguage2.prx?exp=4351" target="_blank">https://web.archive.org/web/20110310110439/http://hopl.murdoch.edu.au/showlanguage2.prx?exp=4351</a> <a href="#fnref:71" class="footnote-back-ref">↩</a></li>
<li id="fn:72">Open source Algol 68 implementations – Browse Files at. Sourceforge.net. Retrieved on 2013-07-21. <a href="https://sourceforge.net/projects/algol68/files/" target="_blank">https://sourceforge.net/projects/algol68/files/</a> <a href="#fnref:72" class="footnote-back-ref">↩</a></li>
<li id="fn:73">"ZIP archive of MK2.1 release". Archived from the original on 2006-08-29. <a href="https://web.archive.org/web/20060829235643/http://www.nunan.fsnet.co.uk/algol68/a68mk2.zip" target="_blank">https://web.archive.org/web/20060829235643/http://www.nunan.fsnet.co.uk/algol68/a68mk2.zip</a> <a href="#fnref:73" class="footnote-back-ref">↩</a></li>
<li id="fn:74">Hansen, Wilfred J.; Boom, Hendrik. "The Report on the Standard Hardware Representation for Algol 68" (PDF). Archived from the original (PDF) on 2014-01-02. Retrieved 2005-08-27. <a href="https://web.archive.org/web/20140102201013/http://www.fh-jena.de/~kleine/history/languages/Algol68-RR-HardwareRepresentation.pdf" target="_blank">https://web.archive.org/web/20140102201013/http://www.fh-jena.de/~kleine/history/languages/Algol68-RR-HardwareRepresentation.pdf</a> <a href="#fnref:74" class="footnote-back-ref">↩</a></li>
<li id="fn:75">Dennis Ritchie (April 1993). "The Development of the C Language" (PDF). Archived from the original (PDF) on 2005-11-06. Retrieved 2007-04-26. The central notion I captured from Algol was a type structure based on atomic types (including structures), composed into arrays, pointers (references), and functions (procedures). Algol 68's concept of unions and casts also had an influence that appeared later. <a href="/wiki/Dennis_Ritchie" target="_blank">/wiki/Dennis_Ritchie</a> <a href="#fnref:75" class="footnote-back-ref">↩</a></li>
<li id="fn:76">Dennis Ritchie (June 1988). "C and Algol 68". Archived from the original on 2009-08-27. Retrieved 2006-09-15. In particular, the union type (a late addition to C) does owe to A68, not in any details, but in the idea of having such a type at all. More deeply, the type structure in general and even, in some strange way, the declaration syntax (the type-constructor part) was inspired by A68. And yes, of course, "long". <a href="/wiki/Dennis_Ritchie" target="_blank">/wiki/Dennis_Ritchie</a> <a href="#fnref:76" class="footnote-back-ref">↩</a></li>
<li id="fn:77">C. H. A. Koster (1993). The Making of Algol 68. Lecture Notes in Computer Science. CiteSeerX 10.1.1.76.2072. <a href="/wiki/CiteSeerX_(identifier)" target="_blank">/wiki/CiteSeerX_(identifier)</a> <a href="#fnref:77" class="footnote-back-ref">↩</a></li>
<li id="fn:78">Dijkstra, E. W. "To the Editor ALGOL 68 Mathematische Centrum". Archived from the original on 2007-04-21. Retrieved 2007-04-28. <a href="/wiki/Edsger_Dijkstra" target="_blank">/wiki/Edsger_Dijkstra</a> <a href="#fnref:78" class="footnote-back-ref">↩</a></li>
<li id="fn:79">van Rossum, Guido (June 2005). "Python-Dev Wishlist: dowhile". Retrieved 2007-04-28. <a href="/wiki/Guido_van_Rossum" target="_blank">/wiki/Guido_van_Rossum</a> <a href="#fnref:79" class="footnote-back-ref">↩</a></li>
<li id="fn:80">Hoare, C. A. R. (February 1981) [based on his 1980 Turing Award lecture]. "The emperor's old clothes". Communications of the ACM. 24 (2): 75–83. doi:10.1145/358549.358561. S2CID 97895. Alt URL Archived 2017-10-02 at the Wayback Machine <a href="/wiki/Tony_Hoare" target="_blank">/wiki/Tony_Hoare</a> <a href="#fnref:80" class="footnote-back-ref">↩</a></li>
<li id="fn:81">"ALGOL Bulletin (referred to in AB30.1.1.1)". March 1970. Archived from the original on 2007-09-30. Retrieved 2007-03-01. <a href="http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A31/P111.HTM" target="_blank">http://archive.computerhistory.org/resources/text/algol/algol_bulletin/A31/P111.HTM</a> <a href="#fnref:81" class="footnote-back-ref">↩</a></li>
</ol>

ALGOL 68 open-in-new

ALGOL 68