"Approximate text of a talk at the informal implementers conference in Vancouver, August 1969."
"This conference was the third of what is turning out to be a series of annual conferences on ALGOL 68 held in British Universities."
"The ALGOL68C compiler was developed in Cambridge by a team led, until January 1975, by S. R. Bourne. Since then it has been maintained and further developed by C. J. Cheney for the University of Cambridge Computing Service. Throughout the development of the compiler much advice and much work has been given by M. J. T. Guy, I. Walker, and myself. Much of the work has been funded by the Science Research Council, and the maintenance is now supported by the Computer Board. Help has been given by our various users and by I. Wand of York University. Much of our terminology, and some of the ideas, are based on those of P. Branquart." [Birrell SIGPLAN Notices 1977]
Describes versions for IBM 370, DECsystem-10/-20, and Telefunken TR440/TR445.
"Therefore ALGOL68 was implemented on the CYBER 205 in Bochum, a language which is more suitable for new machine architectures. On one hand it contains vector operations (like the assignation of rows) and on the other it allows the definition of new operators within the existing language. Together with the adaption of the ALGOL68C compiler (from the University of Cambridge) a prelude with vector operations has been designed which allows an efficient use of the special CYBER 205 hardware."
"Algol 68 Genie (a68g) is a well-featured Algol 68 interpreter. It can be used for executing Algol 68 programs or scripts. Algol 68 is a rather lean orthogonal general-purpose language that is a beautiful means for denoting algorithms." [van der Veer]
"About 40 years ago I had been writing an Algol 68 compiler. I started it at the University of Alberta. It wasn't finished after I spent about two and a half years on it, and I decided that was enough. I has essentially a complete, functioning front end, and a fairly incomplete draft of a code generator. The whole thing was written in Algol W.
When I moved to the Mathematical Centre in Amsterdam it didn't take long for one of its directors to get wind of the incomplete compiler. He had access to an IBM 370, which was compatible with the machine I had first implemented on, so he prevailed on me to resume work on it. I agreed. I now look at that as a mistake. The facilities available weren't as good as they had been in Alberta (TSO instead of MTS, which meant slow turnaround whether I took the train to Delft every day of stayed in Amsterdam and used a 300 bps phone line.) Over the next few years I got the compiler to the point that it correctly handled about half the test set, but it really wasn't ready for serious use.
Then funding ran out, I left the Netherlands, and after that I had essentially no opportunity to continue work on it. Perhaps I could have reimplemented Algol W and then rewrote the code generator for another machine, but in new jobs I had other responsibilities." [Boom 2010]
"The general approach to object code generation in the Algol 68 H compiler is presented. Algol 68 H is to be a compiler for all of Algol 68, written by one man in two or three years. The various intermediate languages used internally are explained, showing a gradual descent from a parse tree to a relocatable object module. ...
Although the author is now at the Mathematisch Centrum, the work reported here was done at the University of Alberta, Edmonton, Canada."
"Algol 68H uses the Janus intermediate language to generate object code for the IBM 370.
The general strategy used in the code generation process, and the mutual impact of Algol 68H and Janus on each other are described."
"A68H was written in the 70's on IBM hardware. Two versions have been located -- project dumps dated 1974 and 1978. I'm trying to restore it to proper functioning on today's hardware -- PC's running Linux. The recent appearance of a new Algol W compiler provides a real boost to this project; that's the language it was written in. The main development branch is a68h.trunk.tar. The a68h.1974.tar and a68h.1978.tar branches are repositories of mainly historical interest."
"Being implementations of the original language, neither of these compilers [Munich nor MBLE] ever came into use outside their home bases. The Malvern ALGOL 68R compiler, on the other hand, restricted the language so as to permit l-pass compilation and also made numerous small language changes, for convenience of implementation. Some, but not all, of these changes were subsequently blessed by inclusion within [ALGOL 68 revised report]. Thus [ALGOL 68 report], [ALGOL 68 revised report], and ALGOL 68R could be regarded as three vertices of an equilateral triangle. It was available from 1970 onwards on ICL 1900 series machines, and became the most widely used implementation, especially in Great Britain." [Lindsey 1996]
"The Algol 68-R system is available in two versions, one which runs under GEORGE 3 (or GEORGE 4), and one which runs under Operators Executive (or any other operating system)."
A section covers Developing the World's First ALGOL 68 Compiler.
"Next, Malvern produced their second attempt, ALGOL 68RS, for their own in-house machines and available from 1977. This was much closer to [RR] than their first product, it was written to be machine independent, and it has been ported to the ICL 2900 series, to MULTICS and to VMS Vaxen. It is still the best starting point, should anyone wish a new (almost) full implementation." [Lindsey 1996]
"This paper describes the portable compiler for Algol 68 developed at RSRE by Currie and Morison. Chapter 2 defines the language extensions handled by the compiler, and the system of modular compilation as seen by the user. Chapter 3 outlines the structure of a complete system, emphasizing the design of the intermediate language produced by the compiler for input to a machine-dependent translator. Though factual, this paper is not the system documentation."
"Although a Subcommittee on Sublanguages had been formed at Manchester, it never produced anything concrete, and it was an independent effort by Peter Hibbard, implementing on a minicomputer with only 16K words at Liverpool, which eventually bore fruit. Hibbard's sublanguage, first introduced to the WG at Vienna, was intended for mainly numerical applications, and the features omitted from it were intended to simplify compilation. It was discussed by the WG and the Support Subcommittee on several occasions, and finally formulated as an addendum to the Report and released for publication as an IFIP Document at Munich. However, the final polishing lasted for some time until it eventually appeared as [Hibbard 1977]. ...
...
Hibbard's Liverpool implementation, around which his sublanguage ... was designed, was rewritten in BLISS for a PDP-11 when he moved to Carnegie Mellon, and was rewritten again by myself in Pascal and now runs on various machines. On the way, it acquired heap-generators (not in the original sublanguage), giving it nearly the functionality of the full language." [Lindsey 1996]
"A one-pass compiler for ALGOL 68 on the PDP 11 Computer operating under both UNIX and RSX-11M Operating Systems is now available for distribution.
The Compiler itself was written and developed at Liverpool University (U.K.) and Carnegie-Mellon University. The operating-system interfaces were provided by the University of Manitoba (Canada). The system has been successfully used in a number of programming language courses and as a general programming and research tool.
The source language is an extended version of ALGOL 68S (the official IFIP subset of ALGOL 68). Thus, the major restrictions on the full ALGOL 68 language are the lack of formatted transput, flexible multiples (though strings are provided) and some one-pass implied restrictions on structured and multiple types and on the coercions (implicit type changes) allowed. Features provided which go beyond full ALGOL 68 include parallel processing using "eventual variables" and an interface to Macro 11 procedures.
The system requires no special facilities beyond those available on the simplest PDP 11s. The version currently being distributed requires a space of 32K words (in addition to the operating system) to run. A second version incorporating a loader (thus requiring considerably less space) is in preparation. Those who order the existing system will receive the new version at no additional cost; this version should be available in late Spring 1978.
Documentation on both source language and installation instructions for either or both operating systems will accompany the distribution tapes."
"This compiler makes use of the Amsterdam Compiler Kit, and permission has been given to include binaries of the necessary parts of the kit (see COPYRIGHT Notice)."
ACK was originally developed by a project led by A. S. Tanenbaum at the Department of Mathematics and Computer Science, Vrije Universiteit, Amsterdam, The Netherlands.
“A68S is part of the ACK and an old version can be found on sourceforge: http://tack.cvs.sourceforge.net/viewvc/tack/Ack/lang/a68s/.” [Neville Dempsey, personal communication, May 2010]
"The Japanese were also active in language design, and produced their own "ALGOL N" [AB30.3.2], a simplified form of ALGOL 68 with a simplified method of description." [Lindsey 1988]
"The promising 'BETA project'' in Novosibirsk primarily designed by Dr. A. P. Ershov, M. Shvartsman, A. A. Baehrs was intended to produce compilers from language descriptions almost automatically, and it had Algol 68, PL/I and Simula 67 as its first objectives [9]. The system has really been created, but not in the form initially thought of, and the languages it now encompasses are Simula 67, Pascal (these languages being implemented by G. G. Stepanov and S. B. Pokrovsky), Modula 2 (L. A. Zakharov), a subset of Ada (S. V. Ten), but not Algol 68 or PL/I [10]. Nevertheless, the concepts of Algol 68 were used in the BETA system for creating both its universal compiling scheme and its internal language."
"The most successful commercial implementation was by CDC Netherlands, first delivered in 1977 in response to a threat from several Dutch universities to buy only machines with ALGOL 68 available. It was an excellent compiler, but the parent company in the USA never showed any interest in it." [Lindsey 1996]
"Describes the CDC Algol 68 implementation, which was produced under the supervision of the author. The compiler and the run-time system are treated equally extensively. Some special attention is given to the garbage collector, which uses self-describing references (pointers)." [Grune, Compiler Construction 1980-1989]
"Chris Thomson and Colin Broughton established the Chion Corporation,ß which developed and marketed FLACC (Full Language Algol 68 Checkout Compiler). This compiler and run-time system conformed exactly to the Revised Report, ran on IBM 370 and compatible mainframes, and included debugging features derived from WATFIV. It was released in 1977.
Chris was a student of Barry J. Mailloux, who studied at Amsterdam's Mathematisch Centrum from 1966 under Adriaan van Wijngaarden. His work on the Algol 68 language established the University of Alberta as a center for Algol 68-related activity." [http://en.wikipedia.org/wiki/FLACC]
"You know, we only ever got 22 copies installed, and less than 5 of those in North America. Even though it ran on 370's under MVS, CMS and MTS, and was cheap and reliable. Talk about a marketing disaster. " [Chris Thomson, comp.lang.misc, November 27, 1988]
"The final commercial-strength product, called FLACC and first shipped in 1978, was a checkout compiler for IBM machines. This was produced by two of Mailloux's ex-students who set up their own company. Again, this was an excellent product (not fast, being a checkout system), but it did not spread far because they completely misjudged the price the market would pay." [Lindsey 1996]
Published in ALGOL 68 Implementation, pages 239-243.
Volume 2, starting on page 205, is the full source code in assembly language.
"One of the first implementations of Algol 68 was done in a Kiev computer-producing factory in the end of seventies for Siemens computers. Its authors are S. I. Shtitelman, M. G. Shteinbukh, L. A. Makogon. The implementation was oriented to an information management system called "START'', for which Algol 68 was the only language it used. The authors of the project were interested in Algol 68 primarily as in a source of a data base language. The Kiev implementation anticipated many features of modern languages of that sort: persistent objects, an elaborated system of types, orthogonal design, a large share of interpretativity, and so on. The system of types and orthogonality were in fact due to the Algol 68 itself but the persistence feature urged for some corrections of the language. Namely an "everlasting block'' has been introduced, meant to preserve between the executions of the program those objects that could be used by different programs. In fact it was a data base. Some other variations were also done without any regards to the standardization efforts for Algol 68: all arrays were considered to be flexible, a control variable of a loop was long int rather than int, complex values were absent and so on. Accepted by the Working Group in 1979 this system exists no more because of replacement of hardware in the factory."
ALGOL 68/19 was a subset of ALGOL 68. Version 1 (November 1973) ran on IBM 360/30 under DOS. It had the ALGOL 68 modes except unions and structures; there was no mode definition mechanism or operator definition mechanism. All procedures were void (no functions). It had a non-standard set of physical i/o routines. There were no formats, but there were conversion routines to/from strings. There was dynamic storage but no heap. There was separate compilation.
Version 2 (March 1974) added non-void functions, a set of mathematical functions in the standard prelude, formatted i/o on the standard devices, a fast link-and-go compiler (without separate compilation), and more.
Version 3 (November 1975), by Guy Louis, ran on an IBM 370/158 under VM/CMS. It added checking of modes of separately-compiled procedures, and more.
[From Gennard and Louis 1976]
"The design and the implementation of ALGOL 68/19 are the work of Guy LOUIS and Piet RYPENS. They received a valuable programming aid from A. M. DOYEN and A. MICHAUX."
Project led by G. S. Tseytin of Leningrad State University.
"E.g. in our Leningrad ALGOL 68/Riad implementation we decided ..."
"In Leningrad, Tseitin is implementing ALGOL68 for the Ryad series of computers, compatible with the IBM 360."
"Mostly developed were the works on Algol 68 implementation in the Leningrad University, in the group headed by Dr. G. S. Tseytin and Dr. A. N. Terekhov. Primarily these works were coordinated with the work on BETA system in the frame of a strategy elaborated by the Working Group. It was supposed that the Leningrad group would construct a debugging compiler, a sort of an avant-garde, meant to win new application areas for main forces, namely basic compiler to be constructed in Novosibirsk. A natural presumption was that any application program, debugged by the Leningrad compiler should run on the Novosibirsk compiler without a need to be modified.
...
In 1978 the first bootstrapping has been done and the resulting compiler has been yielded to many users in different fields (mathematical physics, radar techniques, simulation). Immediately afterwards the second bootstrapping began. At that moment the designers realized necessity of library preludes and separate compilation of procedures. Therefore a new construct has been added to Algol 68, which appeared to be rather like nest not yet known to the authors.
..."
"Mary was a programming language designed and implemented by RUNIT at Trondheim, Norway in the 1970s. It borrowed many features from ALGOL 68 but was designed for machine-oriented programming. ... The original Mary compiler was written in NU ALGOL, ran on the Univac-1100 series and was used to bootstrap a native compiler for ND-100/SINTRAN-III." [http://en.wikipedia.org/wiki/Mary_(programming_language)]
"Mary was an Algol68 derivative for embedded systems ... There was a Mary/1 done at NTH, targeting the NDE and KV minicomputers, which were almost identical at the ISE level. We wrote an OS for those machines in Mary, which wound up being used in telephone switches made by NDE. ... Mary2 was done at Penobscot Research Center in Maine, running on Data General and Harris machines [and written in Mary/2]." [Ivan Godard (formerly known as Mark Rain), personal communication to Paul McJones, May 2010]
"Branquart's compiler [on an Electrologica X8] was a piece of research into compiler methodology rather than a serious production tool, but it did establish many features necessary to all compilers, particularly the storage of values and the layout of the stack, all documented in a series of MBLE Reports that were finally collated into [Branquart 1976]. The project consumed 20 man-years of effort, spread over the years 1967 to 1973." [Lindsey 1996]
"[By 1974], the X8 had already disappeared from the lab, but a microprogrammed simulator was available (on a prototype Philips machine that was never marketed)." [Georges M. Louis, email to Paul McJones, 25 April 2017]
Abstract: "An interpretative implementation for a sublanguage of ALGOL 68 is informally described in this report. Since the implementation has been written in ALGOL 60 and there is no translation from ALGOL 68 source text to an object program, a high degree of machine independence has been achieved. The report includes both the text of the interpreter and some typical ALGOL 68 programs, along with the output produced by the interpreter."
"Mini ALGOL 68 is a sublanguage of ALGOL 68 ...
The compiler was first written in ALGOL 60, and then, for reasons of efficiency, rewritten in an ALGOL 60-like subset of PASCAL. It produces assembler code for the CONTROL DATA 6000 and CYBER machines. Some care has been taken, however, to facilitate modifications, if wanted, for the generation of code for other machines."
"At the same time [as Kiev Algol 68] Algol 68 was being implemented on the base of the DEC architecture. This implementation was being performed under guidance of Dr. M. Levinson. Though uncompleted it brought some original ideas into the implementation technique. The main distinction of this implementation was in the scope checking: the life-time of any object was not restricted by the execution time of the block, in which the object was declared."
"An implementation of Algol 68 compiler for "Elbrus'' computer complex had been designed by V. V. Brol, V. M. Gushchin, V. B. Yakovlev (Moscow). Its source language is the full Algol 68 defined by the Revised Report and extended by some facilities of module handling. The compiler provides a good quality of the object code, a rather complete error diagnostic. It makes a good use of similarity between main concepts of Algol 68 and those of "Elbrus'' architecture and operating system. The compiler has been accepted by the national Working Group in 1985. The Leningrad group participated actively in testing of that compiler. About ten large application packages developed in Leningrad University were ported almost without a problem to the "Elbrus''. But the tragedy of the "Elbrus'' compiler was that these were practically the only real-life programs that were processed by it."
"The implementations by Goos at Munich on a Telefunken TR4, and by Branquart at MBLE on an Electrologica-X8, were well under way by the appearance of [ALGOL 68 report]." [Lindsey 1996]
"The 'ALGOL 68 group' of the Technical University of Munich has been concerned for the past two years with the implementation of ALGOL 68. Essentially, the full language is handled, without the facilities of parallel processing and the synchronization operations, and with some further 'technical' restrictions. The implementation is nearly completed, and we expect that the compiler will go into multi-test-phase during 1971. The following pages attempt to summarize our experiences resulting from this intensive effort with ALGOL 68."
Written in ANSI Fortran 1966, and run on an IBM 370/158 and an IBM 1130.
Written in Fortran V for Univac 1100 series.
"The ALGOL-68 compiler of the University of Paris-XI (Orsay) has been implemented for Univac's 1110-series, under EXEC-VIII. It can compile the 'full language' (including formats, unions, flexible arrays, recursive modes, parallel computation, etc.). It consists in 8 passes and yields usual relocatable code. Minor restrictions concern equivalence recognition of crossed recursive modes, multiple precision and short modes, and scope checking."
"The Rennes implementation [Leroy et al. 1975] containes a form of transput which is tailored to their SIRIS 7 operating system ..." [J. C. van Vliet. Towards a machine-independent transput section. In Proceedings of the Strathclyde ALGOL 68 conference. ACM, New York, NY, USA, pages 71-77. ACM Digital Library]
"In Rennes, computer science bloomed suddenly toward 1970, as a result of local initiatives combined with political decisions ; no less than eight software specialists who had passed their doctorates in Grenoble, Paris or Nancy, then spent a few years teaching in Montreal or working on Simula with Control Data, received positions at the Rennes university. Their main project was the development of an operating system written in Algol 68 for the big CII computer (SDS Sigma 7) of the faculty. They took on the challenge of designing an Algol 68 compiler*, which became the topic of 5 doctoral dissertations ; operational in the mid-1970s, the Rennes compiler was brought to similar machines in other universities, and remained widely used until 1981, when Multics machines replaced Plan Calcul computers... and received a new Algol 68 compiler.
* Project SAR (Système Algol Rennes) included several particular features: A new compiling method ("by events", with only one pass on the source text), an original "garbage collector", a new kind of block ("prolators"). The team also developed a compiler for a subset of Algol 68 (SERA, Sous-Ensemble Rennais d'Algol 68), which was used in Rennes and in Paris to teach programming. These were the only French implementations of Algol 68 actually put into service (correspondence with L. Trilling, 27 September 2010)."
"History: the Interpreter originates from the one made by L. Ammeraal in the Mathematical Center, Amsterdam, in 1973. It was written in Algol-60. The interpreter was debugged and implemented on an ICL 1903A machine by L. Csirmaz in 1974. The present competely revised version was written in C. The lexical analyzer was written by Sam Rebelsky, the other parts by L. Csirmaz, both at the University of Chicago. Later it has been ported to DOS and Linux by L. Csirmaz." [Csirmaz, 1987]
"S3 is a structured, imperative high-level computer programming language. It was developed by the UK company International Computers Limited (ICL) for its 2900 Series mainframes. It is a system programming language based on ALGOL 68 but with data types and operators aligned to those offered by the 2900 Series. It was the implementation language of the operating system VME." [http://en.wikipedia.org/wiki/S3_(programming_language)]