LINC

LINC is the programming language of the LINC (Laboratory INstrument Computer), a 12-bit machine that Wesley A. Clark and Charles Molnar designed at MIT’s Lincoln Laboratory so that biomedical researchers could run a computer in their own labs. The language had two layers. One was the LINC order code, a set of octal instructions built around analog input, a display scope and a small block-addressed tape. The other was the series of LINC Assembly Programs (LAP) that Mary Allen Wilkes wrote, which turned typed mnemonics into those codes. Programming the LINC meant working with both.

Some historians count the LINC as the first minicomputer, and many see it as a forerunner of the personal computer. Its language matters for the same reason: it was meant for scientists who were not computer specialists, working at a keyboard and screen on a machine nobody else was using.

History and Origins

Lincoln Laboratory, 1961-1962

Clark had already led the design of the TX-0 and TX-2 at Lincoln Laboratory. According to DEC engineer C. Gordon Bell, the LINC project began in 1961 and the first machine was delivered in March 1962. Mary Allen Wilkes, a Wellesley philosophy graduate who had been programming IBM 704 and 709 machines for Lincoln’s speech-recognition project, joined Clark’s Digital Computer Group in June 1961, just as the LINC design began. Before the hardware existed she simulated the LINC on the TX-2. She also designed the prototype’s console.

She also wrote the assembler. Her manual for LAP3 (“LINC Assembly Program”) is signed and dated 10 December 1962. It describes a complete on-line system: the user typed program lines (“manuscript”) at the LINC keyboard, watched them appear on the oscilloscope screens, and stored and converted them on LINC tape.

The Evaluation Program, 1963-1965

In January 1963 the group moved from Lincoln Laboratory to MIT’s Cambridge campus. That summer, under a National Institutes of Health program run with NASA, researchers from about a dozen laboratories came to MIT, assembled their own LINCs and learned to program them. Wilkes taught in the program. When it ended, the scientists took the machines home.

In 1964 the core of the team moved to Washington University in St. Louis and set up the Computer Systems Laboratory there. Several key LINC documents date from 1965:

• LAP4 and GUIDE (Technical Report No. 1, 19 March 1965) from the university’s Biomedical Computer Laboratory (M. D. McDonald, S. R. Davisson and J. R. Cox Jr.). Its preface calls LAP4 “a descendant of LAP3” with revised and added meta commands, and calls GUIDE a new system for filing and running programs.
• The Final LINC Evaluation Program Meeting, held at Washington University on 18-19 March 1965, where participating laboratories reported on their results.
• Programming the LINC by Wilkes and Clark, first published in June 1965 as Section 2 of LINC Volume 16: Programming and Use I. It was reissued in 1967 and revised as a second edition in January 1969, and it became the standard textbook for the order code.

The catalogue’s year of 1965 most likely comes from that cluster of publications. The language itself is older: the order code ran on LINC hardware from 1962, and the LAP3 manual is dated December 1962.

LAP6 and the 2048-word LINC

Wilkes spent 1964 traveling around the world. She rejoined the group late that year but worked from her parents’ home in Baltimore until late 1965, on a LINC the laboratory installed there. Asked whether that made her the first person to use a computer in a private home, she said, “Well, I guess I might have been.”

Early LINC software was written for 1024 words of memory. Once LINCs had 2048 words available, Wilkes could write a much more capable system, and some of that work reportedly took place on the Baltimore machine. The result was LAP6. Its Handbook and Manuscript Listings are both dated 1 May 1967. The Washington University index of LINC documents describes it as “an on-line program for the 2048-word LINC” that could display any part of a manuscript at any time and edit it “directly by simply adding or deleting lines”. Meta commands filed programs on tape and converted them to binary, and users could add meta commands of their own. LAP6’s scrolling editor used a text-editing algorithm proposed by Wilkes’s colleagues Mishell Stucki and Severo Ornstein.

Design Philosophy

The LINC was a laboratory instrument first and a computer second, and its language shows it:

• Instruments are part of the instruction set. Reading an analog channel (SAM, SAMPLE), plotting a point on the scope (DIS, DISPLAY), reading the keyboard (KBD) and driving the six relays (ATR) are each a single instruction, not a call into a library.
• Interactive, not batch. LAP was used at the machine: you typed, you saw the line on the screen, you fixed it, you converted it, you ran it. The researcher sat at the LINC, not at a card punch.
• Small enough to understand completely. Programming the LINC teaches the whole machine from number systems upward, starting with the console switches and the DO lever that executes a single instruction set in the switches.

Key Features

Words, numbers and octal

Every register and memory cell holds a 12-bit word. The arithmetic is ones’ complement, so there is both a “plus zero” (0000) and a “minus zero” (7777). Programmers wrote everything in octal. LAP3 accepted only octal constants and turned any number containing an 8 or 9 into zero.

Instruction classes

Programming the LINC introduces the order code class by class:

Subroutines through location 0

The LINC had no stack. A JMP X from location p automatically put the instruction JMP p+1 into memory location 0. A subroutine returned by jumping to 0, which made single-level subroutine calls almost free. A subroutine that called another one had to save location 0 first.

A simple program

This is Example 1 from Programming the LINC. It divides the number in location 30 by eight and stores the result in location 31. Addresses and codes are octal:

1
2
3
4
5
6
7
8

Address   Instruction   Code    Effect
  20      CLR           0011    Clear the accumulator
  21      ADD 30        2030    Add C(30) to the accumulator
  22      SCR 3         0343    Scale right 3 places (divide by 8)
  23      STC 31        4031    Store in 31 and clear the accumulator
  24      HLT           0000    Halt
  30      N                     Number to be divided
  31      N/8                   Result

At first the code numbers were entered with the console’s FILL button and switches, and the program was run with START 20. With LAP the same program was typed as manuscript. LAP3 allowed tags of a digit and a capital letter (such as 2A or 3K) as symbolic addresses, a p for the present location, relative addresses such as p+5, and “equalities” that gave a tag a value.

Manuscripts and meta commands

The LAP systems kept two kinds of input apart. Manuscript lines were the program. Meta commands, ended with a dedicated META key, edited and processed it. LAP3 had nine, including REMOVE, INSERT, DISPLAY, SAVE MANUSCRIPT, CONVERT and COPY. LAP4 changed five of them and added three. In LAP6, meta commands filed source and binary programs on LINC tape. The LINC tape file system used eight-character names, and one name could hold both a source file and a binary file.

Evolution

The order code also outlived the original hardware. Spear Inc. built micro-LINC variants with integrated circuits. DEC’s LINC-8 (produced 1966-1969) paired a PDP-8 with a LINC processor. The PDP-12 (1969) had one processor that ran either instruction set. LINC Document No. 27, Users’ Guide to LINC Variants (June 1968), covers the differences programmers had to watch for when moving code between the classic LINC, the micro-LINCs and the LINC-8. On the PDP-12 the LAP6 tradition continued as LAP6-DIAL.

Current Relevance

LINC programming is now a historical subject. No LINC language is in active use, and no official emulator or container image is published, so this page lists no Docker image. The primary documents survive, though. Programming the LINC, the LAP3 manual, the LAP4/GUIDE report, the complete LAP6 source listings and the 1965 evaluation proceedings are scanned on Bitsavers, which makes the LINC one of the best-documented small machines of the 1960s.

Why It Matters

• Programming moved into the laboratory. The LINC let a physiologist or psychologist write, edit and run their own data-collection program next to the experiment, without handing a card deck to a computation center.
• An early interactive programming environment. LAP3 (1962) and LAP6 (1967) combined keyboard input, on-screen editing, tape filing and assembly in one system on a single-user machine. That is the workflow later personal computers made routine.
• A notable programmer. Wilkes wrote the system software and co-wrote the manual for the LINC family, and she spent much of 1965 programming a LINC in her parents’ home in Baltimore.
• A long-lived order code. Through the LINC-8 and PDP-12, programs written in the order code that first ran in 1962 were still running on new DEC hardware into the 1970s.