From Wikipedia, the free encyclopedia
Jump to: navigation, search
WikiProject Computer science (Rated C-class, High-importance)
WikiProject icon This article is within the scope of WikiProject Computer science, a collaborative effort to improve the coverage of Computer science related articles on Wikipedia. If you would like to participate, please visit the project page, where you can join the discussion and see a list of open tasks.
C-Class article C  This article has been rated as C-Class on the project's quality scale.
 High  This article has been rated as High-importance on the project's importance scale.

Old discussion without headings[edit]

The Algo programming language? When has it ever been called that? Are you sure you don't mean the "Algol programming language"? -- JanHidders

There is no programming language Algo. I am sure it is a typo. Have moved page. Will attempt to fix references now. Of course, you'll never find _this_ page (/Talk) except by looking at Recent Changes now... :) --drj

Actualy, there is a programming language Algo. It was an algebraic language loosely modeled on ALGOL 58 and released in the early 1960's by Bendix for their G-15. I plan to put in a complete article Real Soon Now. --User:DJBrantley

  • Good to know. I had the old Algo page marked for deletion. Is there any paper about Algo on the ACM library? — danakil 21:34, Sep 13, 2004 (UTC)

I just removed this text, added by User:

This is also a pun on the latin word algol, meaning pain, since programming is a painful process.

Probably just a joke, but might be legit. Does anyone know if algol is Latin for "pain"? If so, does anyone know if this influenced the choice of name? Couldn't find anything on Google. Tualha 23:48, 15 Dec 2003 (UTC)

I don't believe it influenced the choice of name. Never heard that stated during the period when Algol was popular. I agree the reference should be removed. Geoff97 08:44, 16 Dec 2003 (UTC)

Never heard of that one, it's simply short form of "ALGOrithmic Language". --Palapala 17:25, 2004 Mar 9 (UTC)
Algos is a Greek word for pain (verb algeO, to suffer), from which we get the word analgesic. Algol is not Latin or Greek at all, but rather that other classical language, Arabic: al-ghul, meaning the demon — or, transliterated, the ghoul. —FOo 18:00, 12 Sep 2004 (UTC)

Algol vs ALGOL (all-caps)[edit]

Don't want to start an edit war, but surely the name of the language was always in all-caps during the time when it was an important language? I bow to those who say that "Lisp" is now normally in mixed-case but I think the articles on these languages should state and document the proper capitalization of the languages and the date when the capitalization changed officially (if it changed officially) or the approximate time of transition in usage (if the change was informal). Dpbsmith 14:15, 9 Mar 2004 (UTC) Cursory googling convinces me it was indeed ALGOL, all-caps. I'll leave this here for a while, and if nobody responds I'll change it to all-caps eventually. Dpbsmith 14:17, 9 Mar 2004 (UTC)

No need to quarrel - it's definitively all-caps; I should know, I grew up with it (I'm an old hand :) --Palapala 17:15, 2004 Mar 9 (UTC)
Given that the two references in the External Links (including the one to ALGOL 68) give it in all-caps, and given that Rosen's 1967 "Programming Systems and Languages" includes the ALGOL 60 report which gives it in all caps, I'm going to go ahead. Dpbsmith 23:04, 9 Mar 2004 (UTC)
It is of little interest to me, but the articles for the specific dialects of ALGOL are all in lowercase. One convention should be standardized throughout the encyclopedia. --Prosfilaes 01:17, 31 May 2004 (UTC)
What articles are those? I see redirects from Algol 60 and Algol 68 and have now added redirects from ALGOL 60 and ALGOL 68. By the way, I don't believe it's a "convention, the name of the language is ALGOL, all-caps. Dpbsmith 02:15, 31 May 2004 (UTC)
Algol W. Looking at the articles I have copies of from that time, Algol (in small caps) is most common in running text, but ALGOL and Algol both appear. The TeX version of the Revised Report on the Algorithmic Language Algol 60 clearly uses the lowercase form. I don't have an original, so I don't know how authentic that is. The original Algol material I have usually uses capitals in the title and small caps in the text. One of the references sited in Knuth's article uses Algol in the title, whereas the others use ALGOL.
I have the original, published in 1964 by A/S REGNECENTRALEN, which writes ALGOL always in capitals througout the book. — Preceding unsigned comment added by (talk) 20:47, 20 November 2013 (UTC)

right|thumb|220px|Revised Report on the Algorithmic Language - ALGOL 68 Edited by: A. van Wijngaarden & al, Sep 1973 For Algol 68 there are two principal reports that differ in CAPs:

  • 1968: "Report on the Algorithmic Language ALGOL 68" [1]
  • 1973: "Revised Report on the Algorithmic Language Algol 68" [2]

NevilleDNZ 09:01, 1 May 2007 (UTC)

Still vital[edit]

The language is still in use today; for example, in its 5th decade, ALGOL is still used to calculate the brix in the manufacture of orange juice, for example, by certain corporations, on the East Coast of the US. Ancheta Wis 18:34, 12 Aug 2004 (UTC)

Algol 68 was not disliked primarily because of pointers; most stuff I've read blamed it for excess complexity and the second stage effect. I think pointers were really a minor part of it. --Prosfilaes 07:40, 28 Feb 2005 (UTC)

C.A.R. Hoare (now senior researcher at Microsoft Research in Cambridge, England) stated:

About Algol W: "It was not only a worthy successor of ALGOL 60, it was even a worthy predecessor of PASCAL[...] I was astonished when the [ALGOL 68] working group, consisting of all the best known international experts of programming languages, resolved to lay aside the commissioned draft on which we had all been working and swallow a line with such an unattractive bait." - Wiki Quotes - NevilleDNZ 07:29, 28 October 2005 (UTC)

More Examples ?[edit]

I've got a few more examples of ALGOL 60 programs written for the Elliott 803. If any one is interested I'll add some. I've also got the original 803 ALGOL 60 compiler (co-written by C.A.R. Hoare) running on an 803 emulator. PeterO 22:40, 4 October 2005 (UTC)

PeterO - please contact me ( as I'ld like to provide an online home for the compiler sources you mention above. Incidentally have you seen the page ?

By the way here is Edinburgh University's ALGOL60 compiler source (written in Edinburgh IMP) and the accompanying grammar and grammar table converter. I'm using that grammar at the moment to write an ALGOL60 source code formatter - don't suppose anyone has the source of the original SOAP program? I could also use any ALGOL60 example programs you might find as test data. (Later update: Formatter works and example programs are here: )

An excellent compiler test program can be found in Merner & Knuth's "Algol 60 Confidential". It is available on online if you persuade an ACM member to forward the PDF to you. Procedure is called GPS and it can evaluate any computable function (with a suitable call). When I wrote the FP6000 Algol compiler I used the call which computed the N=th prime number as part of my test suite. Roger D Moore Rdmoore6 22:14, 28 December 2005 (UTC)

Are the Elliot algol characters available in Unicode?[edit]

An alternative example, using Elliott Algol I/O is as follows. In fact, Elliott Algol used different characters for 'open-string-quote' and 'close-string-quote', but ASCII does not allow these to be shown here.

Are these characters now available in the Unicode characterset? In that case we could fix the example.

Kim Bruning 13:01, 20 April 2006 (UTC)

We certainly could use proper quotes like “quote” which I suspect should match the Elliott characters.--Prosfilaes 01:55, 21 April 2006 (UTC)

The other character (miss by unicode) that was part of Algol was the ALCOR "subscript 10". eg.

real n; n := 6.0221415₁₀23;

The one "byte" (6/7 bit) subscript-"₁₀" became a backslash-"\" in the 1967 version of ascii and thus never made it into unicode.

real n; n := 6.0221415\23;

Oddly the tens {⑽, ⒑, ⑩} do exist in unicode... something to do with the British wanting to support 12 pennys in a shilling. But the subscript 10 needs two characters in unicode.

Note "₁₀" was part of the ALCOR paper tape standard for Algol, also has been included in a German norm (DIN66006), it has been discussed in ACM: comm.ACM 7 No 7(424,447) (there called "subscript 10") and "₁₀" is part of a couple of Russian GOST standards. A nice web page about the cyrillic codes includes their "lower ten":


NevilleDNZ 11:23, 22 April 2006 (UTC)

the "lower ten" has been proposedunder the name DECIMAL EXPONENT SYMBOL (see [1]) and accepted for (the yet unreleased) unicode 5.2 as (Ammendment 6, with currently unofficial codepoint 23E8 as shown in this draft: [2] ). Frédéric Grosshans (talk) 17:44, 14 April 2009 (UTC)

OK... I confess, I have not managed to figure out what the Runic Cross was for in Algol60? Any hints? I am guessing that it was either:

  1. A format string delimiter. eg. WRITE(LP, "MEAN =",F6.2 ,MEAN);
  2. A return statement from a procedure, or a loop break? eg. IF X>Y THEN ;

Both the AT&T and teletype paper tape has a $ in place of the ALCOR iron/runic cross eg [3], this suggests that the runic-cross was for format/string quoting. Eg ALGOL 68#formatted_transput. NevilleDNZ 23:58, 29 April 2006 (UTC)

"Subject of the famous Turing lecture"[edit]

The proper noun, "Turing" in the "True ALGOL 60s specification and implementation timeline" table currently points to a disambiguation page. I'd like to improve the wikification here, but I don't know what the "the famous Turing lecture" is. So, two things: (1) "famous" might be an inaccurate adjective for the "Turing lecture" (I have a degree in Computer Engineering and I haven't heard about it before now) and (2) "Turing" needs to point to something somehow related to this lecture. Any advice? --InformationalAnarchist 15:31, 5 December 2006 (UTC)

There is but one Turing in computer science; that is, Alan Turing.--Prosfilaes 15:44, 5 December 2006 (UTC)
True, but there also is but one Turing Lecture, which is the one given by the recipient of the Turing Award. Presented by the ACM, the Turing Award is sometimes described as the Nobel Prize of Computer Science -- a somewhat hyperbolic description but not totally unapt, as the current award is $250,000. There should be more information on if it's not on WP. The WP page on C A R Hoare has some info (and some of that page is copied from, whether legally I'm not sure). There's also a WP page on the Turing Award. The text is available on the ACM web site, but only with a Digital Library subscription AFAIK. The note in the article could use a link to the Turing Award page and/or the Hoare page, but I don't see any need for any other change. I don't have time to do it right now. (I had the privilege of attending this lecture, though I have to admit that I no longer remember much from it.)--Paleolith (talk) 04:07, 13 February 2008 (UTC)


I reverted "These strategies facilitated recursion, avoided anomalous side effects that followed from the then-prevalent call-by-reference, and provided some polymorphism." back to "Call-by-name had certain limitations in contrast to call-by-reference, making it an undesirable feature in imperative language design. For example, it is impossible in ALGOL 60 to develop a procedure that will swap the values of two parameters if the actual parameters that are passed in are an integer variable and an array that is indexed by that same integer variable. However, call-by-name is still beloved of ALGOL implementors for the interesting “thunks” that are used to implement it." Call by reference is an option in Ada, C++ and Fortran, among other languages, so it's not exactly "then-prevalent". IIRC, it was a mistake in standardization to create call-by-name, and in retrospect, it was clearly the wrong choice. Every serious programming language designer has read about ALGOL 60 and call-by-name; none of them have used it in their programming languages.--Prosfilaes 19:56, 21 March 2007 (UTC)

Well, not really. Call-by-name in the form of lazy evaluation is the preferred calling mechanism for modern functional languages such as Miranda, Clean and Haskell. I'm guessing this was Sadorrest's intent in mentioning imperative languages. Simple call-by-name is inefficient because the same expression may be evaluated multiple times, but this is avoided in lazy evaluation. The mechanism is still avoided in imperative languages because it doesn't serve much purpose within that framework. The situation is different with a functional approach where lazy evaluation provides a theoretically cleaner mechanism and supports notions like infinite data structures.
It's unfortunate that Mdmi simply deleted the remarks critical of ALGOL and replaced them with an opposing set. There look to be valid points in both sets of remarks that can be made without violating NPOV. It certainly makes sense to indicate the reasons why call-by-name was avoided in imperative languages, but that does require saying that it was simply wrong. A B Carter (talk) 20:40, 21 March 2007 (UTC)
It was simply wrong, though. Call-by-name as a tool has some advantages in certain environments. However, in ALGOL--in this article--it was a poorly thought-out choice that was widely agreed upon afterwards to have had little to no upside. I don't have access to a great library for this stuff anymore, but there was some stuff I copied off when I did that I'll try and summerize and cite in the next few days.--Prosfilaes 15:05, 23 March 2007 (UTC)
Still learning about ALGOL and my knowledge of its usages is weak. A quick search indicates that you're probably right, but I would be very interested in further comments and any references you have. What got me wound up was your final statement that call-by-name has not be used in any language developed after ALGOL. A B Carter (talk) 15:41, 23 March 2007 (UTC)

For example, it is impossible in ALGOL 60 to develop a procedure that will swap the values of two parameters if the actual parameters that are passed in are an integer variable and an array that is indexed by that same integer variable.

I would assume this sentence belongs into the evaluation strategy article, like most of the discussion in this section. I would like to see a practical example (code) for this.  Andreas  (T) 22:30, 28 March 2007 (UTC)

Of course it is possible. This example does not work:

  integer i,j;
  integer array a[1:10];
  procedure swap(x,y); real x,y;
     real z;
  for i:=1 step 1 until 10 do a[i]:=-i;

However, when the original array value is saved first, it works OK:

  integer i,j;
  integer array a[1:10];
  procedure swap(x,y); real x,y;
     real z;
  for i:=1 step 1 until 10 do a[i]:=-i;

The output of this code is -3 3. I tested it using marst-2.4.

I wonder when this case is relevant in real life. I would think that if an expression is to be used as a parameter, it would be declared value anyway. The only reason why call by name is undesirable is because it is expensive; apart from that, it is theoretically the best solution, it gives the value that corresponds to the situation at the time when the parameter is needed. This is why the fathers of ALGOL implemented it. In any case, as long as the above statement is not documented somewhere, it is original research and therefore should not be included in Wikipedia.  Andreas  (T) 00:58, 29 March 2007 (UTC)

To be a little harsh: it's an example of good programming, but irrelevant for the criticism against ALGOL:s name parameters – which is "that you cannot construct a swap procedure that takes care of this saving for the programmer who calls swap". However my gut now tells me that one actually can! Said: Rursus 08:44, 28 June 2007 (UTC)
I spake crap! Pardon! Your example is perfectly relevant, I just didn't understand it immediatelly. For symmetry I propose:
              integer i,j;
              integer array a[1:10];
              procedure swap(x,y); real x,y;
                real x2, y2;
                x2:=x; y2:=y;
                x:=y2; y:=x2;
              for i:=1 step 1 until 10 do a[i]:=-i;
              outinteger(1,i); outinteger(1,a[j]); outterminator(1)
which takes care of both calling swap(i,a[i]); and swap(a[i],i);. Maybe (?)... Said: Rursus 08:51, 28 June 2007 (UTC)
No, the second last example does not work either. I knew it would not (I've been programming extensively in Burroughs Algol since 1972), but I tested it anyway (changing the I/O of course). It faults when it reaches y:=x2 because the global i has already been assigned the value -3, which is not a valid subscript for the array. I'm guessing that you missed one of these critical points: 1) that an assignment to a call-by-name formal parameter alters the actual parameter immediately, or 2) that when a call-by-name formal parameter is referenced, the entire expression of the actual parameter is re-evaluated, including subscripts -- it doesn't just reload a referenced location. Point 1 is the same as for call-by-reference, whereas point 2 is a critical difference. I'm not absolutely certain, but I believe that the current version of the page is correct in saying that a swap procedure is not possible in pure Algol. (Burroughs Algol has a couple of extensions which enable it -- an intrinsic procedure called either READLOCK or EXCHANGE, and a :=: assignment operator.)
In 35 years of Burroughs Algol programming, I don't think I have ever used the capabilities of call-by-name that go beyond call-by-reference. In theory it has additional capabilities; in practice using those capabilities is limited by the opaqueness of the resulting code and the rarity of actually needing them. I don't think it's wrong to say that call-by-name was a mistake -- it was a mistake which generated a great deal of productive thought, but no useful code. The modern version of Burroughs Algol also has a reference specifier to invoke call-by-reference, but call-by-name remains the default for backward compatibility. --Paleolith (talk) 06:08, 12 December 2007 (UTC)

Yet another attempt to make everything US centric in this international encyclopaedia![edit]

Removed "Of these, ALGOL 60 was the most widely known in the United States". —The preceding unsigned comment was added by (talk) 07:49, 1 May 2007 (UTC).

I doubt it was an intentional attempt. ~a (usertalkcontribs) 22:33, 2 May 2007 (UTC)
I agree. It seems that many Americans do this sort of thing without thinking. —The preceding unsigned comment was added by (talk) 18:44, 9 May 2007 (UTC).
Many non-Americans have your anti-American complex. — Preceding unsigned comment added by (talk) 19:37, 2 July 2011 (UTC)

Propose brief timeline of innovations in Algol 58,60,X,Y,68,M,W & specific ALGOL 60 page[edit]

My proposal is:

  • this ALGOL page should contain a summary of the chief innovations as Algol evolved through its various versions.
    • include a brief timeline of the decendents. Algol 58,60,X,Y,68,M,W, Pascal etc etc
  • Move Algol 60 specific details to a Algol 60 specific page
    • on Algol 60 page: add a more details descriptions of the ALGOL 60 implementations and features.

I am hoping that someone can work with me on this and help point out chief Algol version innovations.

NevilleDNZ 09:01, 1 May 2007 (UTC)

Front cover of the ALGOL 60 Final Report[edit]

Does anyone have a copy from which they can scan the ALGOL 60 cover page?

NevilleDNZ 09:04, 1 May 2007 (UTC)

Maybe, but such an image would be an unfree image (covered by copyright) so it wouldn't be of use to Wikipedia. Paul Koning 14:45, 10 August 2007 (UTC)



  • 6502: You shoot yourself in the foot.
  • 8086: You foot yourself in the shoot.
  • 68000: You can't decide which gun and which bullet to use, so you hang yourself.
  • ALGOL 58/IAL: You shoot yourself in the foot with a musket. The musket is aesthetically fascinating, and the wound baffles the adolescent medic in the emergency room.
  • ALGOL 60: You spend hours trying to figure out how to fire the gun since it doesn't have any provision for input or output.
  • ALGOL 68: You mildly deprocedure the gun, the bullet gets firmly dereferenced, and your foot is strongly coerced to void.

An implementation: Algol 68 - Parallel processing

NevilleDNZ 12:26, 17 June 2007 (UTC)


  1. ^ "Report on the Algorithmic Language ALGOL 68" (PDF). August 1968. Retrieved 30 April 2007. 
  2. ^ "Revised Report on the Algorithmic Language Algol 68". September 1973. Retrieved 30 April 2007. 

Source highlighting in ALGOL, and some other issues.[edit]

There are currently various ways of doing syntax highlighting of ALGOL 60 in wikipedia, eg.

plain text
begin integer i; real y; real array a[0:10];
real procedure f(t); real t; value t;
  f := sqrt(abs(t))+5×t↑3;
for i := 0 step 1 until 10 do read(a[i]);
for i := 10 step -1 until 0 do
  begin y := f(a[i]);
        if y > 400 then write(i, "TOO LARGE")
        else write(i,y);

Plain text is unacceptable. The above would never happen in real life because there are no reserved words in Algol60. Variables are allowed to contain spaces (which are stripped by the compiler's pre-processing line reconstruction stage) and keywords may be run together, eg 'BEGIN' 'INTEGER' MYINTEGER; could equally acceptably be written as 'BEGININTEGER' MY INTEGER;

stropped keywords (several styles available)
'begin' 'integer' i; 'real' y; 'real' 'array' a[0:10];
'real' 'procedure' f(t); 'real' t; 'value' t;
  f := sqrt(abs(t))+5*t^3;
'for' i := 0 'step' 1 'until' 10 'do' read(a[i]);
'for' i := 10 'step' -1 'until' 0 'do'
  'begin' y := f(a[i]);
        'if' y > 400 'then' write(i, "TOO LARGE")
        'else' write(i,y);

Keywords could be stropped in any system-dependent manner. Single quotes. HASH marks. Two single quotes. Quote before but not after (Non-alpha terminates the keyword). Percent before (Ditto). Double quotes.

Flexowriter style. In this example, very similar to the reference syntax.
   integer I;
   real Y;
   real array A[0 : 10];
   real procedure F(T);
     value T;
     real T;
   F := SQRT(ABS(T)) + 5 × t ↑ 3;
   for I := 0 step 1 until 10 do READ(A[I]);
   for I := 10 step -1 until 0 do
       Y := F(A[I]);
       if Y > 400 then WRITE(I, "too large") else WRITE(I, Y);

The style above is more appropriate when there are complex relations etc using characters not in the Flexowriter set.

<code lang="algol"> plus '''wiki''' annointments
   begin integer i; real y; real array a[0:10];
   real procedure f(t); real t; value t;
     f := sqrt(abs(t))+5*t^3;
   for i := 0 step 1 until 10 do read(a[i]);
   for i := 10 step -1 until 0 do
     begin y := f(a[i]);
           if y > 400 then write(i, "TOO LARGE")
           else write(i,y);

Acceptable, but underlining was more common in representing Algol-60 in print than bolding.

<source lang="pascal"> no wiki annointments
begin integer i; real y; real array a[0:10];
real procedure f(t); real t; value t;
  f := sqrt(abs(t))+5×t3;
for i := 0 step 1 until 10 do read(a[i]);
for i := 10 step -1 until 0 do
  begin y := f(a[i]);
        if y > 400 then write(i, "TOO LARGE")
        else write(i,y);

Just plain ugly.

Ideally either of the following work perfectly a) <code lang="algol60"> OR b) <source lang="algol60">, but without forcing one to '''annoint''' with quotes. The tag <source lang="pascal"> works surprisingly well and leads the way. Can someone can give me a hint on how to improve/extent [[mediawiki]]'s <source lang="algol60"> to correctly handle algol60. Any hints welcome and I will give it a go..

Don't! Pascal style assumes reserved keywords, which as explained above Algol60 does not use. The formatter should take stropped keywords as input.

ALSO A) Algol60 predates ASCII-1967, indeed ASCII-1963 has the arror (↑) and in place of the ASCII-1983 circumflex accent (^) so (me thinks) lines like:

 f := sqrt(abs(t))+5*t^3;

Should read:

 f := sqrt(abs(t))+5×t↑3;

that's right, but it depends on whether you are describing a reference syntax code sample or a machine syntax one. In the latter it is only correct within the context of some specific named system and I/O device (eg the Flexowriter on the Atlas)

ALSO B): The comment:

  • (The way the bolded text has to be written depends on the implementation, e.g. 'INTEGER' (including the quotation marks) for integer.)

I know this stropping apllies to ALGOL 68, does it also apply to ALGOL 60? - Yes, it did. Also CORAL66 and IMP.

ALSO C): Can someone confirm that ALGOL 58 had no standard File/IO? (As with ALGOL 60).

NevilleDNZ 08:09, 20 June 2007 (UTC)

It seems to me that the best way to publish information on ALGOL is to use the publication standard, viz keywords in bold. I can't see any reason to consider using the particular coding convention of any particular machine implementation unless one is specifically writing about that implementation. Using the official ALGOL 60 publication standard seems to me to have 3 advantages: (1) it IS the standard, (2) it is consistent with the majority of information published on the language when it was in common use, (3) it is the most readable: at least it is to me. JamesBWatson 13:43, 4 December 2007 (UTC)

Wikipedia uses the GeSHi - Generic Syntax Highlighter:

NevilleDNZ 23:38, 20 June 2007 (UTC)

As you've probably already noticed, MediaWiki talk:Geshi.css has some information on how to modify GeSHi. I've been nagging some admins off and on to either fix GeSHi or open up the process so ordinary people can fix it, but so far no luck. Basically, to add a new language you'll need to get an account on [4], write a PHP file called "algol60.php" based on one of the existing ones like "pascal.php", and then get it included in the official SyntaxHighlight_GeSHi distribution (otherwise Wikipedia won't use it).
This bug indicates that in the future, <source lang="algol60"> (or any other unrecognized lang) might gracefully degrade to <pre>, which would at least be a small step in the right direction. Until then, using the old standard method of <code> is the right thing to do.
By the way, 5×t↑3 looks silly in Courier New, the font most readers use to view code. I'd stick with the ASCII caret ^ in place of the arrow, at least. Just my two cents. --Quuxplusone 02:04, 21 June 2007 (UTC)
ALGOL-60 wasn't tied to ASCII, not any form of it. As the article mentions, it was viewed, at least in part, as a publication language. The standard doesn't give any guidance for how to represent its character set in a computer. Bold keywords are just one part of that problem. "Stropping" is one solution: the original EL-X1 and EL-X8 implementations by Edsger Dijkstra used underlining, with the help of Friden Flexowriters with a custom character set. When the Technical University Eindhoven moved from EL-X8 to Burroughs, they modified the stock Burroughs ALGOL compiler to use quoted keywords. Burroughs used the reserved word approach, with no stropping.
Another oddball in ALGOL-60 was the "scientific notation" numbers: one version had subscripted "10" as the marker: 0.3141610+1 but most implementations used the Fortran "E" notation.
ALGOL-68 addresses these issues explicitly; it does not prescribe a single answer but the Report suggests several approaches. For example, for keywords both stropping and the reserved word approach are mentioned.
Paul Koning 14:56, 10 August 2007 (UTC)

ALGOL object code – merger??[edit]

Someone proposed that ALGOL object code merged to ALGOL!? Who!? Why!? ... OK, I can say: I think it's a good idea, since I believe that ALGOL object code never was an independent concept discussed in any other context than the ALGOL language, but that is what I believe, I'm not old enough to have been in actual contact with ALGOL except one University laboration in the then still not deceased Simula. Said: Rursus 08:58, 28 June 2007 (UTC)

I disagree. It belongs in a piece on intermediate codes along with others such as UNCOL, P-Code, Z-Code, CINTCODE, JANUS, I-Code, OCODE, CIL, and maybe JVM.

No objection to a link to it though. —Preceding comment was added at 18:34, 22 October 2007 (UTC)

An Algol-60 interpreter[edit]

HERE. It is a true and valid Algol-60, since it implements name parameters and the thunking required for Jensen's device to work. From 1990. Said: Rursus 09:39, 18 July 2007 (UTC)

I previously (December 2007) placed a statement here that the link given was dead. I have now discovered that the link has been resurrected, and once again does lead to a copy of NASE Algol60. JamesBWatson (talk) 19:39, 25 November 2008 (UTC)

Reinsert Simula in Algol list[edit]

I reinserted Simula in the Algol list. It's a true and faithful Algol 60, despite it's name. It has much more, true, but that is related in C++ and Simula. Said: Rursus 09:12, 21 July 2007 (UTC)


True ALGOL 60s specification and implementation timeline, too many red links to dialects and implementations of varying quality. My proposed improvements:

  1. the table shall try to list the most important implementations: which may mean that the implementation has a big theoretical interest, or was used extensively, or [add your own estimates here],
  2. links to implementations articles should be provided only if it is heavily needed/wished, or already exist.

Said: Rursus 10:36, 21 July 2007 (UTC)

I made Category:ALGOL 60 dialects for this. I'm a little confused on what should be regarded as "ALGOL 60 dialect". If all the criteria below are fulfilled, the language is certainly an ALGOL 60 dialect:
  1. Name parameters with thunking and Jensen's device,
  2. More than C-ish type control,
  3. Var declarations within the begin ... end frame - not outside, like the Pascals,
  4. Declaration defaults, such that arrays by default are reals,
  5. Procedural parameters.
But if a language doesn't fulfill all these, then it might still be a true Algol 60. Said: Rursus 09:28, 27 July 2007 (UTC)

My observations are inserted:

1. Name parameters with thunking and Jensen's device,

This only existed in Algol 60. Only Algol 68 went for a more functional language approach with procedures as parameters, and pass by reference.

2. More than C-ish type control,

Array declarations in Algol-60 were more akin to what is found in Fortran IV. Only in Algol-68 could one create a new type. Indeed when Borne joined AT&T he was the catalyst for removing the PL-I style declarations in C which were replaced with ALGOL 68C style declarations, including the void.

3. Var declarations within the begin ... end frame - not outside, like the Pascals,

Algol-60 was kind of a hybrid, with procedure parameters before the begin, and local variables after. Algol-68 by contrast allowed declarations anywhere within a block. Much like what C99 finally adopted in May 2000 for local declarations.

4. Declaration defaults, such that arrays by default are reals,

Only Algol-60 had this, Algol-68 strictly enforced strong typing. Oddly Algol-68 also had strong-dynamic typing with the form of Tagged unions. BTW: tagged unions have recently been reintroduced to the D programming language.

5. Procedural parameters.

Here I am thinking all languages have Procedural parameters, except for maybe cobol and perl :-)

IMHO: Between Algol-60 and Algol-68 where appears to have been a major divergence into two separate threads. Basically:

Algol-X and Algol-Y were prototype specifications that fueled some rather intense "discussion" between the designers and the incumbents. eg [5] - from which you can draw your own conclusions.

Maybe we could have Category: ALGOL 60 dialects and Category: ALGOL 68 dialects for Algol-X and Algol-Y decedents respectively.

  • (Basically we need some kind of Girl or boy test to help differentiate X from Y "divergents". :-)

NevilleDNZ 23:12, 23 October 2007 (UTC)

One other thought, in the case of ALGOL 68, there are "compiler based" dialects - basically Extensions to the official language (recommended extensions, and improvised extensions)- or compilers that designed to be the official "sub-language". These are quite different to languages influenced by ALGOL 68. This leaves me a "in the air" about the meaning of "dialect". Any hints? NevilleDNZ 00:02, 24 October 2007 (UTC)

Elliott vs Burroughs[edit]

Current text of the page claims that Burroughs systems used and use Elliott Algol. Does anyone know where this claim came from? It's incorrect per se -- I've been programming in Burroughs Algol since 1972, attended over 40 conferences of CUBE and UNITE (the Burroughs and Unisys user groups), and have known many Burroughs/Unisys software engineers, and have never heard such a thing mentioned. I never used a B5000, which would be the system referenced by the "as far back as 1961" remark, but the snippets of Elliott Algol shown look quite different from anything handed down to later generations of MCP systems and certain look nothing like the Burroughs Algol which I first encountered in 1972.

However, I realize that some link may have been intended but badly stated, so I don't want to just wipe it out without asking first. --Paleolith (talk) 06:18, 12 December 2007 (UTC)

I figured out that the Elliott link was added by Danakil, who made about twenty edits to the page over a few days along with huge numbers of edits to other pages, and who disappeared from Wikipedia a couple of years later. Some of his edits were good and others bad. The other bad ones appear to have been corrected since then. Someone posted a note on Danakil's discussion page questioning the Burroughs/Elliott link, but didn't follow up on it. That post was unsigned, but it appears to have been created by the same person who corrected the spelling of Elliott (not Elliot) here at a later date.
I have revised this paragraph to remove the false linkage between Elliott and Burroughs, and also to try to make the entire paragraph clearer. The paragraph is a bit odd as it does not really fit in this section, but it's important in the history of ALGOL and doesn't have another good place that I can see.--Paleolith (talk) 08:34, 18 December 2007 (UTC)
Years later...I have removed the tag suggesting a merge. Elliot and Burroughs Algol compilers were different products from different companies in different countries, we don't need to combine them. --Wtshymanski (talk) 18:49, 9 August 2011 (UTC)

undid random (?) anonymous edit about name[edit]

Someone posting anonymously removed the sentence "Note: Throughout its effective life, the name of the programming language ALGOL was always presented in all-uppercase letters, and this is the practice adopted here." Since no reason was given, I undid the removal. If someone has a reason to remove the sentence, please give a reason -- I'm not defending the text, just saying that I don't see any reason to delete it and that no reason was given.--Paleolith (talk) 22:07, 7 January 2008 (UTC)

Thanks for restoring this. It turns out to be false. I have added a real Note citing sources that show both Algol and ALGOL are used. --Jtir (talk) 23:21, 7 January 2008 (UTC)

True ALGOL 60s specification and implementation timeline[edit]

I see no mention of (UK) ICT/ICL 1900-series Algol, mid-60s. I have a manual for it, price 12/6.

Nor of EE/EELM/Elliott? 4100 Algol.

There was Algol for the Elliott 903/905.

There was also, from Oxford, an Algol for the PDP/LSI-11, after mid-70s; the language system was written in a subset of Algol, and the subset compiler could compile itself and the full compiler (the machine was too small for the full copiler to compile itself). For compiler read interpreter? (talk) 13:33, 4 February 2008 (UTC)

Reworked the table, removing the blank column, adding the most successful implementations and removing EMIDEC as it essentially had no info. (talk) 20:27, 5 July 2008 (UTC)

Syntax vs. Representation?[edit]

In the History section it says "It specified three different syntaxes: a reference syntax, a publication syntax, and an implementation syntax. The different syntaxes permitted it to use different keyword names and conventions for decimal points (commas vs periods) for different languages.".

Would it not be better to say something like "It specified the syntax of the language but allowed for differing representations of that syntax imposed by the limited character sets available at the time"?

There is only one syntax of the reference language. All else is just a representation of that syntax, surely? (talk) 14:09, 29 October 2008 (UTC)


For a language so influential (C/C++, Java, etc all claim descent) there's not much in here to explain why it was groundbreaking. Just some cryptic comments about the 'failings of FORTRAN' and so on. I think this page needs a paragraph or two on why it was - for its time - so advanced.

Olivetti Algol derivative[edit]

While translating and editing an article on the Olivetti Elea , I ran across references to their Algol-derived language apparently called "Palgol" or "Palgo" (sources differ), some time before Olivetti left the mainframe business. If this existed and was an Algol language, it perhaps should be documetned and added to the table. --Wtshymanski (talk) 20:22, 21 June 2010 (UTC)

Agreed... Add some specific details, esp anything that makes it unique. Also you may also consider posting details to

You might alternatively consider adding Palgol to ALGOL 60 (or ALGOL 68) if it is clearly Algol 60 (or Algol 68) derived.

Note: Algol 68 influenced languages tend to have the reversed (and somewhat reverent) closing brackets, eg: for ~ while ~ do ~ od, if ~ then ~ else ~ fi & case ~ in ~ out ~ esac

NevilleDNZ (talk) 13:44, 24 June 2010 (UTC)

Influenced by ?[edit]

Shouldn't be mentioned in page header that Algol was influenced by FORTRAN ? At least there is sentence "Algol was designed to avoid some of the perceived problems with FORTRAN" - this clearly shows to me that Algol was built upon the foundation of FORTRAN. —Preceding unsigned comment added by (talk) 21:16, 18 December 2010 (UTC)

special characters: backarrow[edit]

Section should probably mention the "back arrow" character used for assignment by Burroughs (looked something like <- ). This character was replaced by underscore on many terminals. Peter Flass (talk) 11:59, 24 May 2012 (UTC)

Regnecentralen implementation[edit]

Th Regnecentralen implementation was for the Gier computer - Geodetisk Instituts Elektron Regnemaskine. A large number of Giers were sold in Eastern Europe in the 1960s and 1970s (when American companies were not allowed to sell there), and the solid Algol implementation was one of its important selling points. Don Wagner — Preceding unsigned comment added by (talk) 14:31, 1 February 2014 (UTC)


Pretty sure it's algorithmic not algebraic, but not gonna put any time into it. I've always said and will continue to say ALGOrithmic. Lycurgus (talk) 19:29, 19 May 2015 (UTC)

ALGOL or IAL? It was going to be Algebraic (and thus IAL) but this was never used and so the name actually used was Algorithmic, thus ALGOL. There was never an I-Algorithmic-L. Andy Dingley (talk) 19:48, 19 May 2015 (UTC)
Preliminary report: international algebraic language --Northernhenge (talk) 22:15, 19 May 2015 (UTC)
Yes and no. Confirmed that the CACM article says Algebraic in the title but after that it only refers to "algorithmic language". In fact, "International Algorithmic Language" was the common usage as for instance in "JOVIAL". But I do see that 'Algebraic' was commonly used including in Schwartz's paper on Jovial. Now know that Algebraic is formally correct. Lycurgus (talk) 16:38, 21 May 2015 (UTC)

Most successful?[edit]

This part of the lede really needs a reference:

it was arguably the most successful of the four high-level programming languages with which it was roughly contemporary: Fortran, Lisp, and COBOL.

This is because ALGOL influenced so many languages after it, including C and Pascal. However, Fortran is still in common use in scientific computing; COBOL is also still used for mainframe applications (although I doubt that many new applications are written in it); Lisp variants have revivals every so often.

I don't see the claim in the source for the previous section either, though I may have missed it in skimming the text. In fact, that source even quotes Reynolds as saying that the Pascal family is not ALGOL-like, and neither is ALGOL 68, with which the lede concurs when it states that 'in general "Algol" means Algol 60 and dialects thereof'. QVVERTYVS (hm?) 07:57, 13 August 2015 (UTC)

Problems with this article[edit]

Oh, my god does this article suck. It contains virtually no detail about constructs in the language, then it launches into a follow on, Algol 68, which was completely different than original Algol and was a complete failure besides. — Preceding unsigned comment added by 2601:646:8A02:7201:99A8:929F:905E:BC9C (talk) 02:01, 27 December 2015 (UTC)

This article is about the Algol family. Members of the family have their own articles so to read about "original Algol" see ALGOL 58 or ALGOL 60 depending on which one you mean. Perhaps the lede needs to be clarified to make the purpose of this particular article more explicit. Certainly the second paragraph needs some work. I can see that "It was arguably the most successful of the four high-level programming languages" could certainly lead to confusion about the purpose of this article. --Northernhenge (talk) 17:01, 27 December 2015 (UTC)
I've just re-read paragraph 2 and IMHO it should be deleted or moved further down the article but I won't do that without consensus, especially as it's many years since I studied this. --Northernhenge (talk) 17:05, 27 December 2015 (UTC)

External links modified[edit]

Hello fellow Wikipedians,

I have just modified 2 external links on ALGOL. Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:

When you have finished reviewing my changes, please set the checked parameter below to true or failed to let others know (documentation at {{Sourcecheck}}).

You may set the |checked=, on this template, to true or failed to let other editors know you reviewed the change. If you find any errors, please use the tools below to fix them or call an editor by setting |needhelp= to your help request.

  • If you have discovered URLs which were erroneously considered dead by the bot, you can report them with this tool.
  • If you found an error with any archives or the URLs themselves, you can fix them with this tool.

If you are unable to use these tools, you may set |needhelp=<your help request> on this template to request help from an experienced user. Please include details about your problem, to help other editors.

Cheers.—InternetArchiveBot (Report bug) 05:09, 1 October 2016 (UTC)