LIL, The Little Implementation Language

LIL, The Little Implementation Language, has been a lost and overlooked chapter in the history of Unix and the C language.

Back in the days when systems programmers still disdained "high level languages" there were stories in the compiler community, passed mouth to ear about LIL, a high level assembler, whose creator, had a friendly competition with the creators of C, as to which language could generate more efficient code. Each time LIL edged out C, the C compiler would be improved, and erase LIL's margin of advantage.

A unique element to the LIL saga, is that LIL's creator documented the story, available here (thanks to a copy provided by the author);

A Little Implementation Language

Also available for the first time, thanks to the author, and courtesy of Bell Labs/Lucent Technologies the following internal Bell Labs memos;

Bell Labs Technical Memo: TM-74-1352-8
LIL Reference Manual
Bell Labs Technical Memo: TM-74-1352-6
Programming in LIL: A Tutorial An introduction to LIL for PDP-11 Assembler programmers.

Thanks

Many thanks to P.J. Plauger, for his insightful documentation, and also for digging up, and photocopying the documents, and his permission to reproduce them here. Thanks also to John Mashey for providing institutional memory and information useful in the unearthing of the memos, and to Dennis Ritchie for providing permission to release the internal memos.

See Also

Plauger:1976:LIL [301] P. J. Plauger. A Little Implementation Language. ACM SIGPLAN Notices, 11 (4):135-137, April 1, 1976. CODEN SINODQ. ISSN 0362-1340

Usenet postings;


Related topics

Other mid-level implementation languages;

BCPL

Basic version of the Combined Programming Language (CPL). First implemeted by Martin Richards at MIT in the 1960's. Used on the Xerox Alto and Amiga?

B

A simplified version of BCPL, implemented on the PDP-7 by Ken Thompson. The immediate predicessor to C, B was word oriented.

BLISS

A descendant of BCPL, BLISS (the Basic Language for the Implementation of System Software) was originally implemented at CM-U by Bill Wulf as BLISS-10, an implementation language for the PDP-10. A second compiler, BLISS-11 was implemented in BLISS-10, which cross-compiled code for the PDP-11. This optimizing compiler is described in the rare, but excellent book "The Design of an Optimizing Compiler", by Wulf, Johnsson, Weinstock, Hobbs, and Geschke.

BLISS-11 was developed by DEC into "Common BLISS", a family which included BLISS-16, a cross compiler for the PDP-11, BLISS-32 for the VAX, and BLISS-36 for the PDP-10. There is reputed to have been a PDP-11 native Commmon BLISS compiler, called uBliss (micro-BLISS).

BLISS-36C ran on the PDP-10, and translated a subset of BLISS-36 to BLISS-10 (the subset that one could express by targeting BLISS-10). A few features were added to BLISS-10 to allow BLISS-36C to support more of BLISS-36. There was also a BLISS-16C that translated BLISS-16 to BLISS-11. These compilers were used to get Common BLISS code up and running (presumably including the BLISS-16, BLISS-32 and BLISS-36 compilers themselves) This is reputed to be covered in the article:

Ronald F. Brender: Generation of BLISSes. TSE 6(6): 553-563 (1980)

Articles, available from Hunter Goatley's FILESERV at Process Software;

PostScript session notes for Matthew Madison's "Introduction to BLISS" (describes "Common BLISS")

"BLISS: A Language for Systems Programming", CACM 14(12):780-790, Dec 1971 (describes BLISS-10)

Sources, thanks to Tim Shoppa, from the PDP-10 Software Archive at trailing-edge.com;

BLISS-32 (for the VAX) and BLISS-32EN and BLISS-64EN (for Alpha AXP) are available on the OpenVMS Freeware CD-ROM.

BLISS-36 V4.2 (236) 16-Oct-1989 binaries (for TOPS-10) are available at Trailing Edge.

manuals:

Early C

Dennis Ritchie's home page has a number of great documents (and code) from the early days of C, and documentation on C's ancestors, BCPL and B (look for the section titled "C and its immediate ancestors"). Attempting to compile the Primeval C compilers under a modern C compiler will be instructive as to what C was like at the time of LIL. See also DMR's paper: The Development of the C Language.

C--

A current research project at Harvard, C-- is a C-like language meant to be used as interface between high-level compilers and retargetable, optimizing code generators. It is described as a "[a] portable assembly language that could be generated by a front end and implemented by any of the available code generators."

COMFY

COMFY is A Comfortable Set of Control Primitives for Machine Language Programming; a low level compiler, designed and implemented by Henry Baker, see:

Henry G. Baker: COMFY - A Comfortable Set of Control Primitives for Machine Language Programming. SIGPLAN Notices 32(6): 23-27 (1997)
and
Henry G. Baker: The COMFY 6502 Compiler. SIGPLAN Notices 32(11): 25-30 (1997)

DECAL

A structured assembler for the PDP-1 c. 1964? Some DECAL programs. Was considered "hard to debug".

EPL

"Early PL/I", used on Multics before full PL/I was available.

See the EPL entry in the Multics Glossary

Burroughs ESPOL

Executive Systems Programming Oriented Language -- the native (and only) implementation language on Burroughs B6700. The Burroughs architecture was (is -- it lives on, in Unisys "A Series" systems) stack oriented, and was meant to directly support High Level Languages.

Most code was written in Burroughs Extended Algol, with ESPOL reserved only for hardware oriented operations?

MOL940

"Systems programmer compiler language for the SDS 940." Developed for the NASA Langley Human Intellect Augmentation project?

Hay & Rulifson. MOL940: Preliminary specifications for an ALGOL-like machine-oriented language for the SDS 940. Interim Technical Report 2. Prepared for NASA, Langley Research Center. Contract NAS1-5904. [March 1968]

PL/360

"PL/360, A Programming Language for the 360 Computers", N. Wirth, JACM 15(1):37-74 (Jan 1968)

Usenet postings;

From FOLDOC:

Structured assembly language for the IBM 360 and IBM 370, with a few high-level constructs. Syntactically it resembles ALGOL 60. Its grammar is defined entirely by operator precedence.

Files:

PL-11

From FOLDOC:

A high-level machine-oriented language for the PDP-11 developed by R.D. Russell of CERN in Nov 1971. It is similar to PL360 and is written in Fortran IV and cross-compiled on other machines.

Mention of the PL-11 and PL-VAX languages from PL-11 and PL-VAX languages from a CERN News Letter.

PL/S

From FOLDOC:

An IBM machine-oriented language derived from PL/I in the late 1960s for the IBM 360 and IBM 370. PL/S permitted inline assembly language and control over register usage.

SYMPL

A subset of Jovial. SYMPL (SYsteMs Programming Language) an Algol-like systems implementation language created by Control Data for its 6000 and 7000 Series computers.

From FOLDOC:

CDC's derivative of Jovial. SYMPL is a non-re-entrant block structured language with extensive bit manipulation facilities, which is linkable with Fortran. Major parts of CDC systems during the 1970s were written in SYMPL.

Used to implement TCP on the Cyber 175.

TERSE

A commercial "Algebraic Assmbly Language" for the x86 available from www.terse.com.

misc


Phil Budne