Thinking about Go documentation - Language Specification through the years ... Algol68 then, then C89 & Go now. (From: Google Groups/golang-nuts, with links to original A68 & C89 specs&books as PDFs)

“	ALGOL 68 was the first (and possibly one of the last) major language for which a full formal definition was made before it was implemented.	”
—C.H.A. Koster Algol68 Report co-editor, [7]

Sadly Koster was killed in a motorcycle accident last week. c.f. http://www.ru.nl/icis/news/memoriam-kees-koster

1960s was a time for Informaticians to blaze a path and the construction of the Algol68 Report was a very early example of collaborations that has left echos in how collaborations have been done ever since.  Aside from being the first as above, it was early IT days so the actual report may well have been the first in several other areas.  It was certainly pioneering.

For example:

• "Translations of the standard were made for Russian, German, French and Bulgarian, and then later Japanese and Chinese.  The standard was also made available in Braille."
• The report "invented" its own vocabulary as was mentioned above.  
• My favourite is GOMMA, for a ";" meaning "Go on comma", i.e. sequentially (vs in parallel or collaterally)
• Arguably this vocabulary aided in the documents translation, moreover served as a technical blue print for actual implementation in other countries on other disparate computer systems (6-bit, 7-bit, 8-bit chars, 16-bit, 24-bit, 36-bit CPUs etc.)
• (Maybe) As a result there are at least 20 independently constructed Algo68 compilers, plus a few interesting dialects such as S3 & Mary.
•  c.f. http://www.softwarepreservation.org/projects/ALGOL/algol68impl

• IMHO the report was targeted at compiler implementers not end users. 
• e.g. Algol68's description is not just a 4 page BNF description as it includes lots of language semantic rules, hence it is not just purely about syntax.  
• {Iconically here the Algol68 Report breaks "Wadler's Law": http://www.haskell.org/haskellwiki/Wadlers_Law about semantics vs syntax.}
• Moreover the alternative could have been be to "code" these semantics in "English", hope they survive linguistic translations, or implement them in a 3GL like C then wait 10+ years for a the formal "English" version to be drafted as a actual formal standard.
• The "Data Security" requirement allowed detecting semantic errors at compile time.
• Compile time detection is better then run time cure (such as type error exception handling while code is in production)
• Most of these "Data Security" semantics are specifically detailed in the actual "Algol68 Report" and were a language requirement.

Regarding documentation, here are some links:

• Here is the "Algol 68 Report" initially refered to:
•  http://jmvdveer.home.xs4all.nl/report.html
• Note: it is 220 A5 pages or 110 A4 pages
• about half of which is example code to give clarification.
• Here is a link to the original published Report scanned straight from the actual AB Journal:
• http://www.softwarepreservation.org/projects/ALGOL/report/Algol68_revised_report-AB.pdf
• (Warning: this scanned report is a raw 26MB in download size)
• Moreover there is also "A Tutorial on Algol 68", by Andrew S. Tanenbaum. 
• This article is a more useful guide/overview and is easier to read at mere 38 pages:
• http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.4668&rep=rep1&type=pdf
• This link is an Algol68 syntax chart (PDF Size 516.6 kB, 9 pages)
• http://www.softwarepreservation.org/projects/ALGOL/book/Lindsey_van_der_Meulen-IItA68-Revised-SyntaxOnly.pdf
• Another good book: "Informal Introduction to ALGOL 68" (by C. H. Lindsey and S. G. van der Meulen)" is much easier to read then the language standard:
• http://www.softwarepreservation.org/projects/ALGOL/book/Lindsey_van_der_Meulen-IItA68-Revised.pdf
• (Warning: a 18Mb PFD, 380 pages)
• Chapter 0: appears to aimed at coders that have only ever used assembler.
• {This is probably for typical coders of the 1960s}
• Chapter 1 etc: The IItA68 is quite readable, maybe even modern.

Some people prefer to learn a language by reading source code:

• Cambridge CAP Computer Operating System - actually code written in Algol68
• http://research.microsoft.com/pubs/72418/cap.pdf (177 pages, 8Mb)
• Rosettacode: http://rosettacode.org/wiki/ALGOL_68
• 300+ Algol68 code samples, compared C, Go and others.
• Maybe some prefer to learn by coding:
• http://rosettacode.org/wiki/Reports:Tasks_not_implemented_in_ALGOL_68
• (Complete a Rosettacode task, and remove it from your bucket list)

Don't get me wrong, the Algol68 Report is hard to read, especially to non-compiler writers.

• Compare with the first C standard
• http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf
• It took 20 years and at 1990 it was 552 pages long.
• Not so easy to read...
• However K&R's "The C programming language" is a total joy.
• The Go Programming Language Specification, Version of September 4, 2012
• http://golang.org/ref/spec 110 pages of A4 as at March 2013.
• Clear and easy to read.
• Some of "English" semantics
• Fortunately(?) only one implementation of Go will ever need exist
• Good syntax description, but not much in the way of "Formal Semantics",

Confession: I have not learned Go yet... I'm itching to give it a go as I like many of the ideas incorporated.

All the best and enjoy
NevilleDNZ