Personal tools
You are here: Home Projects BCPL
Document Actions

BCPL

by Paul McJones last modified 2024-02-12 13:57

 

Paul McJones, editor - paul@mcjones.org - http://www.mcjones.org/dustydecks/
Software Preservation Group
Computer History Museum

 

Introduction

The goal of this project is to preserve and present primary and secondary source materials (including specifications, source code, manuals, and papers discussing design and implementation) from BCPL, a portable system programming language designed by Martin Richards. Comments, suggestions, and donations of additional materials are welcome.

 

Contents

 

IBM 7094, Compatible Timesharing System (Project MAC, MIT)

This was the first implementation of BCPL. It ran on the IBM 7094 under MIT's Compatible Time-Sharing System.

"This compiler was originally developed to implement the language CPL (Combined Programming Language) on a number of different machines. The central feature of the system is the bootstrapping language BCPL.

BCPL is derived from CPL by removing those features of the full language which make compilation difficult: namely, the type and mode matching and the variety of definition structures and their associated scope conventions. The large number of conditional commands and expression operators do not present a problem and are all included. The BCPL compiler was itself written in BCPL and serves as an example of the recommended style of programming for the other compilers of the system.

Great care has been taken to ensure that the BCPL compiler is as machine independent as possible. To demonstrate this, it is being implemented on the following five machines: the IBM 7094, 360/65, KDF9, Atlas 2, and GE 645." [Richards 1967a]

"Strachey visited Jack Wozencraft at MIT when he was designing a new course to introduce first year students to computer programming. The outcome was that both Peter Landin and I moved to MIT and helped to design a form of sugared λ-calculus, based on the language ISWIM (If you See What I Mean) described by Landin in “The next 700 programming languages” [Landin 1966]. Landin produced a prototype implementation in LISP using his SECD machine as described in “The mechanical evaluation of expressions” [Landin 1964]. When I arrived at MIT in December 1966, I quickly constructed a BCPL compiler that ran on the timesharing system CTSS and set about using it to implement a variant of Landin’s system called PAL [Evans 1968] that was then used in the new course. This language was a form of sugared λ-calculus but its syntax was somewhat related to CPL. Based on the SECD machine it was dynamically typed with every value carrying its data type at run time. Like LISP, it required a garbage collector. ..." [Richards 2016]

Documentation

  • Martin Richards. The BCPL Reference Manual. Memorandum-M-352, Project MAC, Massachusetts Institute of Technology, 21 July 1967.
    1. Peter G. Neumann's copy via Dennis Ritchie's BCPL history page. The example program in section 8 is missing.
    2. Karl Kleine's copy (originally from http://www.eah-jena.de/~kleine/history/). It includes the example program in section 8, and one reference. PDF

Papers

  • Martin Richards. The BCPL Compiler System. In Project MAC Progress Report IV, July 1966-July 1967, Programming Linguistics section, pages 134-135. Online at apps.dtic.mil
  • P. J. Landin. The mechanical evaluation of expressions. Computer Journal, 6(4):308–320, 1964. Oxford Academic
  • P. J. Landin. The next 700 programming languages. Comm. ACM, 9(3):157–166, 1966. ACM Digital Library
  • A. Evans, Jr. PAL - A language designed for teaching programming linguistics. In Proceedings of 1968 23 ACM Conference, pp 395-403 August 1968. Thompson Book Company, Washington, DC, 1968. ACM Digital Library

Source code

Applications

See: PAL.

 

Various systems (Cambridge)

"BCPL: ... In use on Cambridge Titan October 1968 and subsequently on IBM 370 series. (Also used for Tripos operating system on PDP11, CA LSI4 etc.) Retired from local IBM mainframe in 1994, but still in use elsewhere." [David Wheeler, Events in the early history of the Computer Laboratory]

Documentation

  • M. Richards. The BCPL Reference Manual. Technical Memorandum 69/1, Computer Laboratory, University of Cambridge, 1969. Online at Gesellschaft für Informatik
  • M. Richards. INTCODE - An Interpretive Machine Code for BCPL. Computer Laboratory, University of Cambridge. December 1972 (revised August 1975). PDF

    From bcpl/icint.doc in archive at https://aminet.net/package/dev/lang/BCPL4Amiga.

  • M. Richards. Bootstrapping the BCPL Compiler using INTCODE. Computer Laboratory, University of Cambridge, August 1973. PDF

    From bcpl/booting.doc in archive at https://aminet.net/package/dev/lang/BCPL4Amiga.

  • M. Richards. The BCPL Programming Manual. Computer Laboratory, University of Cambridge.

    "The overall layout and organisation of this manual is based on a manual written by J.H. Morris of the University of California, Berkeley, which itself was based on a well-written memorandum by R.H. Canaday and D.M. Richie of Bell Telephone Laboratories. ... The machine code library was implemented for the 370 by J.K.M. Moody and many of the language extensions for the 370 were implemented with the assistance of H.C.M. Meekings. Many of the extensions were first designed and implemented by J.L. Dawson."

  • M. D. Middleton. A Proposed Definition of the Language BCPL. 1 October 1979. PDF

    "This document sets out a proposal for the definition of a standard BCPL and was prepared by M.D. Middleton in collaboration with
       R. Firth (HPAC Ltd.)
       M. Richards (University Cambridge)
       I. Willers (CERN Geneva)
    who are members of the BCPL Standards Committee elected at the BCPL User Meeting on 7th March 1979 in Cambridge."

    From oldbcpl/obcpl-0.9.8/doc/standard.txt in Archive at https://www.cl.cam.ac.uk/~mr10/Archive.html.

  • Martin Richards and Colin Whitby-Strevens. BCPL - the language and its compiler, 1979. Online at archive.org
  • Martin Richards. The BCPL Cintcode System Users’ Guide. Computer Laboratory, University of Cambridge, 11 December 2003, 132 pages. PDF at cl.cam.ac.uk via archive.org
  • Martin Richards. The BCPL Cintsys and Cintpos User Guide. Computer Laboratory, University of Cambridge, November 2023, 296 pagees. PDF at cl.cam.ac.uk

Papers

  • M. Richards. The Portability of the BCPL Compiler. Software-Practice and Experience, 1 (2), pp. 135-146, 1971. Wiley Online Library
  • Martin Richards. How BCPL Evolved from CPL. The Computer Journal, Volume 56, Issue 5, May 2013, pages 664–670. PDF at cl.cam.ac.uk / Oxford Academic
  • Martin Richards. Christopher Strachey and the Development of CPL. Given at the Strachey 100 Celebration in Oxford, 19 November 2016. PDF at cl.cam.ac.uk

Source code

Applications

 

GE 635, GECOS III, and GE 645 and Honeywell 6180, Multics (Bell Telephone Laboratories)

"Dennis Ritchie and Rudd Canaday of BTL ported CTSS BCPL to Multics. Ken Thompson wrote a version of QED in BCPL, and Doug McIlroy and Bob Morris wrote Multics runoff [McIlroy 1969] in BCPL based on Jerry Saltzer's MAD version of RUNOFF for CTSS.

Robert F. Mabee maintained Multics BCPL after the divorce from Bell Labs. The BCPL runoff command was used by Honeywell documentation to produce Multics manuals for years, until they switched to compose. Bob Daley wrote the Multics qedx command in PL/I to replace the BCPL qed command.
[Tom Van Vleck, Multics Software Features: BCPL]

- - -

"Dennis Ritchie and I implemented a BCPL compiler. I wrote the compiler and Dennis wrote the supporting routines for input and output and the mathematical library (routines for doing mathematics). I wrote the user’s manual. (I wish I still had a copy.) [But see Morris 1969] ..." [Rudd Canaday, How C Came to Be]

- - -

"Thompson: ... After UNIX was up, or, simultaneous with UNIX coming out, BCPL was just emerging and that was a clear winner with both of us. Both of us were really taken by the language and did a lot of work with it.

Mahoney: How did you come up with it, it’s an English language wasn’t it?

Thompson: Ah yes, but the guy who did, Martin Richards, actually developed it at MIT. It was available in a very informal way, on CTSS and we pulled it off of CTSS and got a version running on GECOS here and did system programming there. It was too big a language to run on the UNIX machines that were 4K machines. That’s when B was developed. ..." [Ken Thompson interviewed by Michael Mahoney, 1989]

Documentation

  • M. Richards. The BCPL Reference Manual. Multics Repository Document M0099, 15 May 1968. Cited in [Canaday, BZ.6.00].
  • R. H. Canaday. A BCPL Compiler for Multics - Overview. Multics System Programmers' Manual, Section BZ.6.00, 18 June 1968, 3+cover page. PDF at multicians.org
  • R. H. Canaday. Language description. Multics System Programmers' Manual, Section BZ.6.01, [1968].
  • R. H. Canaday. BCPL-Multics library routines. Multics System Programmers' Manual, Section BZ.6.02, 18 June 1968, 4 pages. PDF at multicians.org
  • R, H. Canaday. Additions and amendments to the BCPL run-time library, BZ.6.02. Multics System Programmers' Manual, Section BZ.6.02a, 20 September 1968, 3 pages. PDF at multicians.org
  • R. H. Canaday. Accessing the Multics BCPL compiler through MRGEDT. Multics System Programmers' Manual, Section BZ.6.03, 12 July 1968, 1 page. PDF at multicians.org
  • R. H. Canaday. BCPL-Multics compiler - code generation. Multics System Programmers' Manual, Section BZ.6.04, 12 July 1968, 17 pages. PDF at multicians.org
  • R. H. Canaday. Executing BCPL code under Multics. Multics System Programmers' Manual, Section BZ.6.05, [1968].
  • D. M. Ritchie. The BCPL command. Multics System Programmers' Manual, Section BX.7.06, 25 September 1968, 4 pages. PDF at multicians.org
  • Martin Richards; revised by Arthur Evans, Jr. and Robert F. Mabee. The BCPL reference manual. MAC-TR-141, 26 November 1974. PDF

    "BCPL (Basic CPL) is a general purpose programming language which is particularly suitable for large nonnumerical problems in which machine independence is important. It was originally designed as a tool for compiler writing and has, so far, been used in at least three compilers. BCPL is currently implemented and running on the Honeywell 635 under GECOS III, on the Honeywell 645 and 6180 under Multics, on the IBM 360 under OS and CP/CMS, on the TX-2 at Lincoln Laboratory, on the CDC 6400, on the Univac 1108, and on the DEC PDP-9. There are also BCPL compilers on the KDF 9 at Oxford and on Atlas 2 at Cambridge. Other implementations are under construction."

  • See also https://multicians.org/unix.html.

Source code

  • See entries of the form bcpl_*.bcpl for the BCPL system, and entries of the form runoff_*.bcpl for the runoff application written in BCPL, in this directory: https://multicians.org/source-index.html

Applications

 

TX-2 (Lincoln Laboratory)

  • M. Richards and E. ("Henry") I. Ancona. The BCPL Reference Manual. Lincoln Laboratory, Massachusetts Institute of Technology, 6 May 1969 (revised). PDF at bitavers.org

    "BCPL is currently implemented and running on CTSS at Project MAC, the GE 635 under GE COS and on a KDF 9 at Oxford. Other implementations are under construction for MULTICS, the ICT 1900 series, Atlas, the System 360, and the TX-2."

 

CDC 6400 (U.C. Berkeley)

"In the interest of making documentation of BCPL available quickly, large portions of this manual were taken from a very well-written memorandum by R. H. Canady [sic] and D. M. Ritchie of Bell Telephone Laboratories. Naturally any errors or omissions in this manual are my responsibility.

The initial design and implementation of BCPL were done by Martin Richards of Cambridge University, England.

The implementation for the 6400 was done with the assistance of Richard Aronoff." [Morris 1969]

Documentation

Papers

  • James H. Morris. Thoughts of a Reformed Computer Scientist: On the Nature of Real and Artificial Intelligence. Self-published, 2021. Amazon

    Describes bringing BCPL to Berkeley and how it was received.

  • James H. Morris. BCPL. Nerd Zone. Online at jimmorris.org

    Explains how Morris bootstrapped the BCPL compiler on a CDC 6400 via OCODE (which Morris refers to as UNCOL).

Source code

Applications

  • [Bill Bridge.] BASIC. Interpreter for the BASIC programming language. 21 January 1972. Online at caltss.computerhistory.org
  • [Howard E. Sturgis.] CLNPRF. Utility to manage accounting structures. Undated, circa 1971. Online at caltss.computerhistory.org
  • [Howard E. Sturgis.] Multiprocess test framework. Undated, circa summer 1971. Coordination framework for running a command in multiple processes and retrieving the reports. Written in BCPL, but probably not finished. Undated, circa 1971. PDF at caltss.computerhistory.org

 

TOPS-10 PDP-10 (University of Essex)

"Richards' original compiler produced object code (OCODE) for an idealised stack machine and was itself available in OCODE. Hence to transport the compiler to another machine, it was only necessary to write a code generator to translate OCODE to the required machine code. By this method Richards took BCPL to Cambridge (England), from which version the original Essex ICL 1900 BCPL was developed via a code generator written by Bernard Sufrin in 1969. It was transported onto the PDP-10 in 1970 via a code generator written in BCPL by Brian O'Mahoney and David Eyres, with help from Bernard Sufrin.

By 1973 BCPL had developed into the major software language in use by the Department of Computer Science for both research (e.g. in AI) and teaching (e.g. Compiler writing), and so with the intention of improving the compiler, both in performance and by adding new language features, a new compiler was developed by Pete Gardner for release in 1974. The performance, as measured by the kilo-core second load on the system, has been improved by a factor 3 or 4; the new features included are documented in this manual. The main contributory factor was the removal of the intermediate OCOOE stage which required in effect two compilations, one from BCPL to OCODE and one from OCODE to machine code." [Gardner 1978]

Documentation

  • P. Gardner. The BCPL Reference Manual. Computing Service, Department of Computer Science, University of Essex, 2nd edition, revised January 1978. PDF at rabbit.eng.miami.edu
  • R. D. Eager. Improving the Portability of the BCPL Compiler. Master's thesis, University of Essex, January 1975. PDF at bobeager.uk

Source code

 

KDF-9 (Oxford) and CTL Modular One (Programming Research Group)

"BCPL: started Jan 1967 by Martin Richards at MIT and in use MIT and Oxford Programming Research Group in May 1967. ..." [David Wheeler, Events in the early history of the Computer Laboratory]

- - -

"Throughout my time at MIT and later, on return to Cambridge, I maintained close ties with Strachey. He was enthusiastic about the design and portability of BCPL to the extent that he implemented it on the KDF-9 computer at Oxford, and later he installed it on the CTL Modular One at the Programming Research Group at 45 Banbury Road. He also used BCPL to implement an operating system called OS6 for that machine which, as the story goes, ran successfully, for the first time, on a Sunday evening very few days after the machine arrived. The BCPL source code is published in OS6Pub [Strachey and Stoy 1972a] with the “Commentary on the text of OS6Pub” [Strachey and Stoy 1972a]. BCPL running under OS6 was the only language available to students at the Programming Research Group for some years.

OS6 included many innovative ideas, one being his implementation of I/O streams. He repre- sented a stream by a small vector, called a stream control block (SCB), that held all the values needed for its implementation, such as a pointer to its buffer and integers giving its size and current position. But importantly, the SCB also held three functions. One (Next) to read the next value from the stream, one (Out) to write a value to the stream and one (Close) to close the stream. Next was defined as follows:

LET Next(s) = (s!NEXT)(s)

where s points to an SCB and NEXT is a manifest constant identifying the position of the read function. This mechanism could be used to represent streams of characters, words or indeed any kind of value. You could even create a stream that generated prime numbers. It is clear that this structure is similar to an instance of a class in a language such as Java. Some streams required larger SCBs but could still use the same definition of Next. This is clearly a precursor to the concept of inheritance found in modern object oriented languages." [Richards 2016]

- - -

"I first met BCPL running on Strachey's Modular One at Oxford. Although the language was essentially the same as Richard's, the syntax was far superior, mainly because Strachey had insisted on having teletypes and a line printer that actually supported a reasonable character set.

Specifically, the hardware character set included upper and lower case letters, three of the four arrows (right for conditional, down for indexing), multiply, logical "and" and "or", a matching pair of quotes(!), and four sets of brackets {, [, ( and "Section brackets" that were used to delimit code blocks; the open section bracket was a double S section symbol (§) and the close section bracket was the same thing with a vertical bar running through it.

The full Modular One Internal character code also included a few characters that were not on the printers, but which could be produced (more or less) by overprinting: divide (÷), $, #, and lambda.

All this was done with 7 bits. The 8th bit was used to indicate underlining. Just as in many of the contemporary books, we used underlining to indicate keywords. The underscore key on the Olivetti teletypes was a "dead" key, like an accent, and you typed the keyword let, say, by striking _l_e_t.

The Oxford version of BCPL also included "Manifest Functions", which were used to simulate abstract data types, and ... objects. For example, Next[aStream] was a manifest function, i.e., one that could be compiled inline; its body was aStream STREAM_NEXT [aStream], i.e., apply the function that is stored in the STREAM_NEXT (a small integer) element of the aStream vector to aStream itself. What this did, of course, depended on the kind of stream that you had ... sound familiar?

I still have a few listings from those days ...

Incidentally, manifest constants were by convention all caps, and words therein were broken by an underlined space (STREAM_NEXT). All other identifiers used studley caps. " [Andrew Black, squeek-dev list, June 2000]

Applications

  • Joseph Stoy and Christopher Strachey. An Operating System for a Small Computer. PRG-08, Programming Research Group, Oxford University Computer Laboratory. May, 1972. PDF at cs.ox.ac.uk

    Published as:

    • OS6—An Experimental Operating System for a Small Computer. Part 1: General Principles and Structure. The Computer Journal, Volume 15, Issue 2, May 1972, Pages 117–124. Oxford University Press
    • OS6—An Experimental Operating System for a Small Computer. Part 2: Input/Output and Filing System. The Computer Journal, Volume 15, Issue 3, August 1972, Pages 195–203. Oxford University Press
  • Christopher Strachey and Joseph Stoy. The text of OS6Pub. PRG-09, Programming Research Group, Oxford University Computer Laboratory, July 1972. PDF at cs.ox.ac.uk
  • Christopher Strachey and Joseph Stoy. The text of OS6Pub (Commentary). PRG-09 (c), Programming Research Group, Oxford University Computer Laboratory, July 1972. PDF at cs.ox.ac.uk

 

TENEX PDP-10 (BBN)

"BCPL was originally designed and implemented by Martin Richards at MIT Project MAC. Many people have since contributed to the development of the language, compiler, utilities, and debugging system, as represented in the TENEX BCPL system. The language and compiler were extended to include structures, symbol tables, and various new language constructs by the group at MIT Lincoln Laboratory on the TX-2 computer, led by Art Evans. Carl Ellison (University of Utah Computer Science Department) built a TENEX BCPL bootstrap and brought an early version of the Lincoln compiler to Utah-TENEX through the ARPANET. He also built the first TENEX BCPL I/O library. Paul Rovner brought the Utah system to BBN-TENEX through the ARPANET, then used it to bootstrap an improved version of Lincoln's compiler. Victor Miller (BBN) helped to upgrade Ellison's code generators. The present TENEX BCPL system includes several packages of routines and functions, and several utility programs that were brought from Lincoln and modified for use on TENEX by Paul Rovner. Other utilities were contributed by Jerry Wolf, Ray Tomlinson, and Richard Schwartz at BBN. The TENEX BCPL debugger was designed and implemented by Jim Miller and Paul Rovner, with help by John Sybalsky. And Gail Hedtler of the TENEX group at BBN spent many hours puzzling through pencil scratched versions of this manual as she converted it to RUNOFF format and keyed it in." [Richards et al. 1974]

Documentation

  • Martin Richards with Herny Ancona, Paul Rovner, Jerry Burchfiel, and Jerry Wolf. BCPL Reference Manual. September 1974. PDF at bitsavers.org

Source code

 

IBM System/370, CP/CMS (IBM Research)

"... [Martin Richards] was on a sabbatical at IBM Research in the early '70s, and I succeeded him in being the 'keeper of the keys' for his port of BCPL to VM/CMS. He had left everything in perfect order for me to take over. I continued to use this BCPL until I left IBM in 1993 (20 years, pretty good record for durability).

I built a theorem prover (for Effigy [symbolic execution] headed by Jim King) in a personally modified BCPL. ..." [Jerry Archibald, squeak-dev list, June 2000]

Applications

 

Data General Nova and Xerox Alto (Xerox Palo Alto Research Center)

"BCPL had a long history with ARPA and PARC. Jim Curry, at Lincoln Labs in the 60's, then at Utah, then at PARC, was one of the earliest bootstrappers of BCPL. The workhorse at PARC for the first 2 years was the Data General NOVA, which however lacked an efficient semihighlevel language to program with (the Algol on it was too slow and too hermetically sealed). So Jim bootstrapped one of the versions of BCPL to the NOVA.

The bootstrapping was interesting. BCPL had a bytecoded representation of itself (descended like all such from the legendary Burrough's B5000). One first wrote an interpreter for these byte codes, in this case in NOVA assembler. This got BCPL running, but slowly. One then started using BCPL to make a back end native code generator for the new machine. Once this started running the bootstrap was done and BCPL was pretty efficient. One of the architectures that was emulated by the Alto when it started running in 1973 was the NOVA (but with a 16 bit address space instead of the NOVA's 15-bit space). And BCPL was used for some of the Alto programming.

Quite a bit of the non-Smalltalk and non-Lisp software was done in BCPL, including one of the several operating systems, and BRAVO, which was the embryo of what is now called MS Word." [Alan Kay, squeak-dev list, June 2000],

Documentation

Nova

  • James E. Curry. BPCL Manual. Xerox Palo Alto Research Center, 15 February 1973. PDF at bitsavers.org
  • Ben Laws. BCPL I/O and Runtime Routines. Xerox Palo Alto Research Center, 31 May 1973. PDF at bitsavers.org
  • Gene McDaniel. BCPL Machine Language Interface. Xerox Palo Alto Research Center, 18 June 1973. PDF at bitsavers.org
  • James E. Curry. Compiling BCPL Programs. Xerox Palo Alto Research Center, 16 August 1973. PDF at bitsavers.org
  • James E. Curry. Loading BCPL programs. Xerox Palo Alto Research Center, 20 August 1973. PDF at bitsavers.org

Alto

  • Butler Lampson. Alto/Bcpl stcrage allocation and function calls. Xerox Palo Alto Research Center, 19 June 1973. PDF at bitsavers.org
  • Gene McDaniel. Bringing NOVA BCPL Programs to ALTO. Xerox Palo Alto Research Center, 3 July 1973. PDF at bitsavers.org
  • Bill Duvall. BCPL Symbol Table Format (Gleaned from Allen Brown's Debugger Notes). Xerox Palo Alto Research Center, 7 March 1974. PDF at bitsavers.org
  • Jim Curry and Peter Deutsch. BCPL .BR file format. Xerox Palo Alto Research Center, 29 April 1974. PDF at bitsavers.org
  • [Dan Swinehart]. Recent BCPL System Modifications. Xerox Palo Alto Research Center, 19 December 1974. PDF at bitsavers.org
  • [Dan Swinehart]. Recent BCPL System Modifications. Xerox Palo Alto Research Center, 14 January 1975. PDF at bitsavers.org
  • [James H. Morris, Jr.?]. Swat, a BCPL-oriented debugger. Xerox Palo Alto Research Center, 2 February 1977. PDF at bitsavers.org
  • [Bob Sproull?]. BCPL Runtime Package. Xerox Palo Alto Research Center, 17 October 1977. PDF at bitsavers.org
  • James E. Curry. BCPL Reference Manual. Xerox Palo Alto Research Center, 9 September 1975. PDF at bitsavers.org
  • [James E. Curry?]. [BCPL Compiler Internals]. Xerox Palo Alto Research Center, undated (circa 1975?). PDF at bitsavers.org
  • James E. Curry and PARC staff. BCPL Reference Manual. Xerox Palo Alto Research Center, 14 September 1979. PDF at bitsavers.org

Source code

  • James E. Curry and PARC staff. BCPL compiler source code. BCPL and Alto microcode. From [Indigo] BCPLSOURCES.DM!1, 5 December 1980. xeroxalto.computerhistory.org
  • James E. Curry and PARC staff. BCPL runtime source code. Alto assembly language and microcode. From [Indigo]BCPLRUNTIMESOURCE.DM!, 30 August 1979. xeroxalto.computerhistory.org

Applications

  • Xerox Alto operating system, library routines, utility programs, and applications (including Bravo and Draw).
  • Xerox Smalltalk.

    "You might be interested to know that the very first occurrence of a Smalltalk-to-C (-like language) was a translator from Smalltalk to BCPL that Ted Kaehler, Glenn Krasner and I did way back when we were at Xerox.

    We had designed this (pretty cool) virtual memory named LOOM (see the Green Book) that used 16-bit internal pointers, but 32-bit external pointers. This meant that if we could get it to work, we could just bolt it onto the existing (then fastest in the world) Dorado Smalltalk. Ted wrote the whole thing in Smalltalk, and arranged to run two images back-to-back, one with the LOOM VM code in it, the other with then normal Smalltalk image. When there was a fault in the normal image, it entered a primitive that emerged on the other side to handle the fault.

    When this all finally worked (it did!), we wanted to speed it up, and make it smaller by rewriting it in BCPL (BCPL was supported on all the Xerox hardware at the time). Ted had written a lot of it in the style of SLANG -- ie, Smalltalk as machine code -- so instead of starting over, we just changed the prettyPrinter to emit valid BCPL code for about 80% of what was there. We did that in a day, and then Ted and Glenn finished the translation by hand." [Dan Ingalls, squeak-dev list, June 2000]

 

Other implementations and applications (TO BE COMPLETED)

Implementations

Applications

  • David Turner. SASL functional programming language. 1973.

    "The implementation of SASL in LISP wasn’t really robust enough to use for teaching. So over the Easter vacation in 1973 I wrote a compiler from SASL to SECD machine code and an interpreter for the latter, all in BCPL. The code of the first version was just over 300 lines — SASL was not a large language. It ran under the RAX timesharing system on the department’s IBM 360/44, so the students were able to run SASL programs interactively on monitors, which they liked." [Turner 2013]

  • David Turner. Some History of Functional Programming Languages. In Lecture Notes in Computer Science. Edited by H.-W. Loidl and R. Peña. Springer, 2013, pp. 1-20. PDF at kent.ac.uk / Springer

 

Acknowledgments

Thanks to: Martin Richards and many others...

« February 2024 »
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29
 

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: