IBM 1620 SPS

IBM 1620 SPS, the Symbolic Programming System, is the assembly language of the IBM 1620 Data Processing System. IBM announced the 1620 in October 1959 as an inexpensive scientific computer. Unlike most computers before or since, it worked in decimal digits, and its data fields were not fixed-size words but runs of digits of any length, marked off by flag bits. SPS let programmers write the machine’s 12-digit numeric instructions as mnemonics such as TF, AM and BNF, with symbolic labels in place of five-digit core addresses. It also gave them macro-instructions that linked a program to IBM’s floating-point and function subroutines.

The 1620 was installed in large numbers at universities and engineering firms. Wikipedia says “hundreds of thousands of students had their first computer experience” on one. SPS and FORTRAN were the two programming systems those users learned, and in IBM’s own 1620 course SPS came straight after FORTRAN.

History & Origins

A decimal machine that needed an assembler

The 1620 grew out of a low-cost computer project with the code name CADET. Its first model had no conventional adder: addition and multiplication were done by looking up tables kept in core memory. That design gave rise to the well-known joke that CADET stood for “Can’t Add, Doesn’t Even Try”. A 1620 Model I had 20,000 decimal digits of core, expandable to 40,000 or 60,000 with an IBM 1623 storage unit, and a 20-microsecond memory cycle.

Every 1620 instruction is 12 digits long: a 2-digit operation code followed by two 5-digit addresses, called P and Q. Writing this by hand meant tracking every address in a program, and moving any routine meant renumbering it. IBM’s preface to the SPS manual describes the motivation plainly: “The difficulties of coding in machine language - a tedious and time-consuming task - have been recognized and one of the efforts at simplification is the system known as Symbolic Programming.”

The first SPS processors

SPS was specified alongside the machine. The earliest documents found are both from 1960. One is the 1620 Symbolic Programming System Preliminary Specifications (J26-4201-1), which IBM’s 1963 bibliography describes as covering “1620 Symbolic Language Programming techniques as well as general principles and concepts of Symbolic Programming”, for library programs 1620-SP-008 (paper tape) and 1620-SP-009 (cards). The other is a manual for an SPS One-Pass Processor (J26-4204-0). A further bulletin, 1620 SPS for Card I/O and Additional Core Storage (J26-5556), added mnemonics for the IBM 1622 card read-punch and the 1623 storage unit.

SPS caught on quickly. IBM’s 1961 Program Writing and Testing bulletin says that writing any but short programs in machine language “is cumbersome and confusing, even to an experienced programmer. Thus, SPS has been used extensively in the writing of 1620 programs.” The same bulletin also recommends something unusual. On a paper tape machine, where a program might be changed ten times before it worked, it suggests translating SPS by hand. It says a beginner “soon finds that with practice he can translate the SPS language almost as fast as he can write the numbers down”.

The 1620/1710 SPS

By 1962 IBM had brought the assembler together in the IBM 1620/1710 Symbolic Programming System reference manual (C26-5600-1, © 1962; the bitsavers copy incorporates a Technical Newsletter and has pages revised 1 April 1963). It describes three processors that accepted the same source language:

• the 1620/1710 Two-Pass Processor for paper tape (1620-SP-021);
• the 1620/1710 Two-Pass Processor for cards (1620-SP-020);
• a processor for assembling 1620/1710 programs on an IBM 709 or 7090 (1710-SP-001). It needed at least 32,000 storage positions, two channels and ten tapes, and ran under what the manual calls the IB SOS Monitor.

The “1710” in the title is the IBM 1710 Control System, an industrial process control computer built around a 1620. SPS covered both machines, and the manual adds a section of 1710-only operations.

SPS II-D, SPS III and the Monitors

Two lines of development followed:

• SPS II-D was the disk version of the assembler. It ran under IBM’s 1620 Monitor I System, a combined operating and programming system with a Supervisor Program, a Disk Utility Program, SPS II-D and FORTRAN, using IBM 1311 disk drives. IBM’s August 1963 bibliography already lists 1620 SPS II-D for Monitor II (C26-5768), which added mnemonics for the Model 2’s index registers and binary capabilities.
• SPS III was a revised card and paper tape assembler. The 1620 SPS III Programming System Reference Manual (C26-5793-0, © 1963, 1964) covers both SPS III and 1620-1443 SPS III. The latter used the IBM 1443 line printer during assembly and added ten printer mnemonics. SPS III supported the new Model 2 instructions and index registers, and needed a 1620 with 20,000 positions of core and Indirect Addressing. Indirect Addressing was standard on the Model 2 and a special feature on the Model 1.

Design Philosophy

The SPS manual calls the translation “one for one — the processor produces one machine language instruction for each machine instruction, except macro-instructions, written in symbolic form”. Like most assemblers of its time, SPS did not hide the machine. It took away the clerical work instead. In IBM’s words, “SPS automatically assigns and keeps a record of storage locations, and checks for coding errors.”

Three ideas shaped the language:

• Symbols instead of addresses. Labels made a program “independent of actual machine locations”, so routines could be written separately, relocated and combined. Statements could be added or deleted without reassigning storage.
• The coding sheet as the source format. Each statement corresponded to one line on IBM coding sheet X26-5627, which carried both the SPS form and, on the reverse, an “absolute” machine-language form.
• Library calls as macros. Floating-point arithmetic and functions were subroutines, not hardware on a basic Model I. SPS let a programmer request them with a single macro-instruction, and the processor generated the linkage.

Key Features

Statement format

A statement could be no longer than 75 characters. On paper tape, statements were written in “free” form, packed end to end and terminated by an end-of-line character. On cards the end of the card ended the statement. Blanks in operands were ignored, except in alphameric constants.

An imperative statement has up to four items, separated by commas: the P operand, the Q operand, a flag indicator operand and remarks. The flag indicator lists which of the instruction’s digit positions should carry a flag bit. For immediate instructions such as AM (Add Immediate), SPS automatically flagged position Q7 so that the immediate data formed a properly bounded field, with the exception of TDM. If remarks were present, all three commas had to be written even when the operands were omitted.

Operands and address arithmetic

Operands could be actual addresses, symbolic labels, or *, which stands for the address of the current instruction. Operands could also be adjusted with +, - and * (multiplication), so *+24 means the instruction two places ahead and TOTAL+11 points inside a field. The manual describes address adjustment as a method that “relieves the programmer of considerable effort and reduces the number of symbols required”.

The HEAD statement gave all following labels a heading character. A symbol could then be written as 5$SUM to mean SUM under heading 5, so that program blocks written separately, by different programmers or at different times, could be assembled together without name clashes.

Declarative and control operations

Because 1620 data fields have no fixed size, the declaratives carry the field length as their first operand. A DC label refers to the rightmost (units) digit of the constant, where 1620 arithmetic starts, and SPS places a flag over the leftmost digit to mark where the field ends. A DAC alphameric constant uses two digits of storage per character. Its address is the leftmost position plus one, which must be odd, and SPS assigned an odd address automatically. An @ inside a constant became a record mark. TCD and TRA let a program too large for core be loaded and run in pieces.

Imperative operations

The imperative mnemonics map directly onto 1620 operation codes. The codes for immediate instructions begin with the digit 1:

SPS also provided unique mnemonics that filled in the device digits of the Q address for you. RNTY, RNPT and RNCD read numerically from the typewriter, paper tape or card reader. WATY writes alphamerically on the typewriter. RCTY returns the typewriter carriage. Extended branch mnemonics named the indicator being tested.

Macro-instructions and the subroutine library

The SPS library held seventeen IBM subroutines, “like floating divide, square root, and arctangent” in the manual’s words. A macro-instruction in the source program told the processor to generate the linkage instructions to the subroutine and back, and to load the subroutine with the object program. The floating-point format was a mantissa followed by a two-digit exponent. Variable-length mantissas could run from 2 to 45 digits, and fixed-length mantissas had 8 digits. Users could add up to twelve subroutines of their own to the package.

A short example

This program types a greeting on the 1620 console typewriter and halts. The listing shows columns 6 onward (label, operation, operands and remarks), without the page and line number:

1
2
3
4
5
6
7

*TYPE A GREETING ON THE CONSOLE TYPEWRITER, THEN HALT
START RCTY,,,RETURN THE CARRIAGE
      WATY MSG,,,TYPE THE MESSAGE UP TO THE RECORD MARK
      H   ,,,HALT
      B   START,,,PRESSING START TYPES IT AGAIN
MSG   DAC 13,HELLO, WORLD@
      DEND START

A few SPS habits appear here. Imperative statements with remarks need three commas, even when the P and Q operands are left out. The DAC length (13) counts every character, including the comma, the blank and the @. The @ becomes a record mark, which ends the alphameric write. With a starting address on DEND, the loaded program halts and begins at START when the operator presses the console Start key. This example follows the rules in IBM’s C26-5600-1 manual. It has not been assembled or run on a processor or simulator.

Evolution

After IBM withdrew the 1620 in 1970, SPS had no successor. The 1620’s nominal successor, the IBM 1130, was a 16-bit binary machine with its own unrelated assembler, so SPS programs could not be carried over.

Current Relevance

1620 SPS is a historical language, but it can still be run. SIMH, the multi-machine historical simulator originally written by Bob Supnik, includes an IBM 1620 simulator based on Geoff Kuenning’s earlier 1620 simulator. Its documentation covers the Model 1 and Model 2 CPUs, the console typewriter, paper tape, the 1622 card reader/punch, the 1443 printer and the 1311 disk. Bitsavers holds the SPS, SPS III and Monitor manuals, along with an archive of 1620 card images whose index lists SPS processor decks, Monitor I systems and many SPS source decks.

A real 1620 runs too. By early 1999 Dave Babcock, a software engineer who had written a 1620 emulator for the PalmPilot, had proposed leading a volunteer team to restore the nonworking 1620 owned by what is now the Computer History Museum. The museum’s 1620 Model 1, Level F was restored to full operation. Members of the team later built the IBM 1620 Jr., a replica for the museum’s education department. By 2019 it had been shown at VCF West two years running and had won Best in Show there.

Why It Matters

SPS was how many programmers first met machine-level programming, on a machine unlike any later one. It works on decimal digits, its fields are delimited by flags rather than word boundaries, and on the Model I even addition is a table lookup. Its features include symbolic labels, address arithmetic, block headings for combining separately written code, and macro calls into a subroutine library. They show how much an early 1960s assembler could do on a computer with 20,000 digits of memory and a typewriter for a console.

The 1620 itself did not escape criticism. Edsger Dijkstra pointed out several flaws in its design in EWD37, “A review of the IBM 1620 data processing system”. But programmers used it in great numbers, and as IBM’s 1961 bulletin acknowledged, SPS was used extensively to write their programs. Fay’s 1962 rewrite of the processor and the user-written assemblers in IBM’s 1971 program catalog show that some users went on to improve the assembler itself.