|Bits||6-bits plus word mark and parity|
|Branching||Branch instruction with modifier character|
|3 index, in memory, optional|
The IBM 1401 is a variable-wordlength decimal computer that was announced by IBM on October 5, 1959. The first member of the highly successful IBM 1400 series, it was aimed at replacing unit record equipment for processing data stored on punched cards and at providing peripheral services for larger computers. The 1401 is considered to be the Ford Model-T of the computer industry, because it was mass-produced and because of its sales volume. Over 12,000 units were produced and many were leased or resold after they were replaced with newer technology. The 1401 was withdrawn on February 8, 1971.
Monthly rental for 1401 configurations started at US$2,500 (worth about $23,239 today).
"IBM was pleasantly surprised (perhaps shocked) to receive 5,200 orders in just the first five weeks – more than predicted for the entire life of the machine!" By late 1961, the 2000 installed in the USA were about one quarter of all electronic stored-program computers by all manufacturers. The number of installed 1401s peaked above 10,000 in the mid-1960s. "In all, by the mid-1960s nearly half of all computer systems in the world were 1401-type systems." The system was marketed until February 1971.
Commonly used by small businesses as their primary data processing machines, the 1401 was also frequently used as an off-line peripheral controller for mainframe computers. In such installations, with an IBM 7090 for example, the mainframe computers used only magnetic tape for input-output. It was the 1401 that transferred input data from slow peripherals (such as the IBM 1402 Card Read-Punch) to tape, and transferred output data from tape to the card punch, the IBM 1403 Printer, or other peripherals. This allowed the mainframe's throughput to not be limited by the speed of a card reader or printer. (For more information, see Spooling.)
Elements within IBM, notably John Haanstra, an executive in charge of 1401 deployment, supported its continuation in larger models for evolving needs (e.g., the IBM 1410) but the 1964 decision at the top to focus resources on the System/360 ended these efforts rather suddenly.
IBM was facing a competitive threat from the Honeywell 200 and the 360's incompatibility with the 1401 design. IBM pioneered the use of microcode emulation, in the form of ROM, so that some System/360 models could run 1401 programs.
Each alphanumeric character in the 1401 was encoded by six bits, called B,A,8,4,2,1. The B,A bits were called zone bits and the 8,4,2,1 bits were called numeric bits, terms taken from the IBM 80 column punched card.
- For digits 1 through 9, the bits B,A were zero, the digit BCD encoded in bits 8,4,2,1. Digit 0 was encoded 8,2.
- For alphabetic characters the setting of bits was derived from the zone and digit punches of the IBM 80 column punched card character code: B,A from 12, B from 11, and A from 0; the setting of bits 8,4,2,1 from BCD encoding of the 1 through 9 punches. Thus the letter A, 12,1 in the punched card character code, was encoded B,A,1.
- Encodings of punched card characters with two or more digit punches can be found in the Character and op codes table.
IBM called the 1401's character code BCD, even though that term describes only the decimal digit encoding. The 1401's alphanumeric collating sequence was compatible with the punched card collating sequence.
Associated with each memory location were two other bits, called C for odd parity check and M for word mark. M was present in memory but not on punched cards, and had to be set using special machine instructions; when printing memory it was typically displayed by underlining the character. C was calculated automatically and was also not present on punched cards.
Each memory location then, had the following bits:
C B A 8 4 2 1 M
The 1401 was available in six memory configurations: 1,400, 2,000, 4,000, 8,000, 12,000, or 16,000 characters.[a] Each character was addressable, addresses ranging from 0 through 15999. A very small number of 1401s were expanded to 32,000 characters by special request.
Some operations used specific memory locations (those locations were not reserved and could be used for other purposes). Read a card stored the 80 columns of data from a card into memory locations 001–080. Index registers 1, 2 and 3 were in memory locations 087–089, 092-094 and 097-099 respectively. Punch a card punched the contents of memory locations 101-180 into a card. Write a line printed the contents of memory locations 201–332.
The 1401's instruction format was
Opcode with [A-or-I-or-unit-address [B-address]] [modifier] word mark
Opcodes were one character. Memory addresses ("I" a branch target, "A" and "B" data) and unit address were three characters. The opcode modifier was one character. Instruction length was then 1, 2, 4, 5, 7, or 8 characters. Most instructions had to be followed by a word mark (a requirement commonly met by the word mark with the opcode of the next instruction).
See Character and op codes for a list of operations.
A three-character memory address in an instruction was an encoding of a five-digit memory address. The three low-order digits of the five-digit address, 000 to 999, were specified by the numeric bits of the three characters. The zone bits of the high-order character specified an increment as follows: A 1000, B 2000, B and A together 3000, giving an addressability of 4,000 memory locations. The zone bits of the low-order character specified increments of 4000, 8000, or 12000, to address 16,000 memory locations (with an IBM 1406 Storage Unit).[b] For example, the three-character address "I99" was a reference to memory location 3000 + 999, or 3999.
The zone bits of the middle character of a three-character memory address could specify one of three index registers, one of many optional features.
Operands referenced by the A-address and B-address were: a single memory location, a variable-length field, or a variable-length record. Variable-length fields were addressed at their low-order (highest-addressed) position, their length defined by a word mark set at their high-order (lowest-addressed) position. When an operation such as addition was performed, the processor began at the low-order position of the two fields and worked its way to the high-order, just as a person would when adding with pencil and paper.
The only limit on the length of such fields was the available memory. Instructions applicable to variable-length fields included: Add, Subtract, Multiply, Divide, Compare, Move Characters to A or B Word Mark, Move Characters and Edit. One or more adjacent variable-length fields could make up a variable-length record. A variable-length record was addressed at its high-order position, its length defined by a group-mark character with a word mark or a record-mark character in its low-order position. The instruction Move Characters Record or Group Mark could be used to assemble a block of records. A variable-length record, or block of records, to be written to magnetic tape was addressed at its high-order position, its length defined by a group-mark character with a word mark immediately following its low-order position.
A sequence of operations on adjacent fields could be "chained", using the addresses left in the address registers by the previous operation. For example, addition of adjacent data fields might be coded as
A 690,840. With chaining, this could be coded as
A - omitting data address from the second and third instructions.
The IBM 1401G was sold in six models: (G1 and G11: 1,400 storage positions; G2 and G12 for 2,000; G3 and G13 for 4,000).  One difference between the 1401 and 1401G was how the reader-punch was controlled.
Booting and sample program
When the LOAD button on the 1402 Card Read-Punch is pressed, a card is read into memory locations 001–080, a word mark is set in location 001, the word marks in locations 002-080 (if any) are cleared, and execution starts with the instruction at location 001. That is always the dyadic Set Word Mark (it was the only instruction not requiring a following word mark) to set word marks for the two following instructions. A single Set Word Mark instruction can set two word marks but requires one word mark as an instruction itself, so a sequence of these instructions would be needed, which would incrementally set word marks in the program's code or data (one instruction for each mark needed) and set word marks for subsequent Set Word Mark instructions. Execution of instructions in the card continues, setting word marks, loading the program into memory, and then branching to the program's start address. To read subsequent cards, an explicit Read command (opcode
1) must be executed as the last instruction on every card to get the new card's contents into locations 001–080. Note that the word marks are not erased when the Read command is executed, but are kept as-is for the next card read in. This is convenient, because much of what the first few cards do is set word marks in the proper locations; having the first half dozen or so word marks set means the programmer would not need to set those word marks again.
One-card programs could be written for various tasks. Commonly available were a one-card program to print the deck of cards following it, and another to duplicate a deck to the card punch. See Tom Van Vleck's web site. Here is a one-card program which will print "HELLO, WORLD!". Pressing LOAD (above) reads one card, and begins execution at 001 (the first
,). The program will automatically set its own wordmarks, assuming that the first
, has a wordmark already.
Following conventional IBM notation, the underscores[clarification needed] show where word marks would be set in memory once the program had run; on punched cards they would not be indicated visually or present in the punched data.
The program is:
- Set Word Mark (opcode
,operands 036 008). This must always be the first instruction, and one of its operands must always be 008 or else the next instruction would not have a word mark to indicate that it is an executable instruction.
- Additional Set Word Marks. The underscores show where the word marks are after completing all
,opcodes. Only word marks from 036 and further are needed for the "guts" of the program; word marks up through 029 are only needed for Set Word Mark instructions. Since the core of the program needs six word marks, five Set Word Mark instructions are needed in total. The reason one fewer is needed is because the final Set Word Mark does not need to waste an operand on other Set Word Marks
- Clear Storage - the rest of the print area 299-200 (opcode
- Clear Storage - part of the print area 332-300 (opcode
HELLO, WORLD!to the print area (opcode
L, operands 065 and 213. Move stops due to the word mark in location 062 (which, doing double-duty, also defines the end of the Halt and branch instruction))
- Write a Line on the printer (opcode
2; "HELLO, WORLD!" will be printed in the 11 leftmost printer positions)
- Halt (opcode
Most of the logic circuitry of the 1401 is a type of diode–transistor logic (DTL), that IBM referred to as CTDL (Complemented Transistor Diode Logic). Other IBM circuit types were referred to as: Alloy (some logic, but mostly various non-logic functions, named for the germanium-alloy transistors used), CTRL (Complemented Transistor Resistor Logic, a type of resistor–transistor logic (RTL)). Later upgrades (e.g., the TAU-9 tape interface) used a faster type of DTL using "drift" transistors (a type of transistor invented by Herbert Kroemer in 1953) for their speed, that IBM referred to as SDTDL (Saturated Drift Transistor Diode Logic). Typical logic levels of these circuits were (S & U Level) high: 0 V to -0.5V, low: -6 V to -12 V; (T Level) high: 6 V to 1 V, low: -5.5 V to -6 V.
These circuits are constructed of discrete components (resistors, capacitors, transistors) mounted on single-sided paper-epoxy printed circuit boards either 2.5 by 4.5 inches (64 by 114 mm) with a 16-pin gold-plated edge connector (single wide) or 5.375 by 4.5 inches (136.5 by 114.3 mm) with two 16-pin gold-plated edge connectors (double wide), that IBM referred to as SMS cards (Standard Modular System). The amount of logic on one card is similar to that in one 7400 series SSI or simpler MSI package (e.g., three to five logic gates or a couple of flip-flops on a single-wide card up to about twenty logic gates or four flip-flops on a double-wide card).
The SMS cards were inserted in sockets on hinged swing-out racks, that IBM referred to as gates.
The modules used were fairly delicate, compared to previous unit-record equipment, so IBM shipped them enclosed in a newly invented packing material, bubble wrap. This was one of the first widespread uses of this packing; it greatly impressed recipients, and brought great publicity to the material.
Like most machines of the day, the 1401 uses magnetic-core memory. The cores are about 1 mm in diameter and use a four-wire arrangement (x, y, sense, and inhibit). The memory is arranged in planes of 4000 cores each, each core storing one bit. A stack of eight such planes store the six data bits, word mark bit, and parity bit for 4000 memory locations. Together with eight additional planes with fewer cores on them for additional storage functions, this made up a 4000-character memory module. One such module is housed within the 1401's primary enclosure. Systems were commonly available with two, three, or four such modules. The additional modules are contained in an add-on box, the 1406 Core Memory Unit, which is about two feet square and three feet high.
Operands in memory are accessed serially, one memory location at a time, and the 1401 can read or write one memory location within its basic cycle time of 11.5 microseconds.
All instruction timings are cited in multiples of this cycle time.
IBM 1403 printer
The IBM 1403 printer was introduced in October 1959 with the 1401 Data Processing System. The printer was a completely new development.
IBM software for the 1401 included:
- 1401 Symbolic Programming System assembler.
- Autocoder on Tape, a more advanced assembler, required at least 4000-character memory and four tape drives.
- Autocoder on Disk, similar to, but not compatible with, Autocoder on Tape, required at least one 1311 disk drive.
- COBOL required at least 4000-character memory and four tape drives.
- FARGO (Fourteen-o-one Automatic Report Generation Operation), a predecessor of RPG, required at least 4000-character memory.
- FORTRAN II required at least 8000-character memory; the 1401 Fortran compiler is described in Haines, L.H. (1965), below. The Fortran compiler, to generate code for small memories, used a pioneering form of interpreted "p-code" although its programmers had no name for what it was that they did.
- FORTRAN IV required at least 12000-character memory and either four tape drives or at least one IBM 1311 disk drive.
- RPG (Report Program Generator); Basic RPG required at least 4000-character memory.
For the IBM Catalog of 1401 software, see IBM 1400 series.
Character and op codes
The 1401's operation codes are single characters. In many cases, particularly for the more common instructions, the character chosen is mnemonic for the operation: A for add, B for branch, S for subtract, etc.
In October 2006, Icelandic avant-garde musician Jóhann Jóhannsson released the album IBM 1401, A User's Manual through music publisher 4AD. The concept is based upon work done in 1964 by his father, Jóhann Gunnarsson, chief maintenance engineer of one of the country's first computers, and Elías Daviðsson, one of the first programmers in the country. The album was originally written for a string quartet, organ and electronics and to accompany a dance piece by long-standing collaborator friend, Erna Ómarsdóttir. For the album recording, Jóhann has rewritten it for a sixty-piece string orchestra, adding a new final movement and incorporating electronics and vintage reel-to-reel recordings of a singing 1401 found in his father's attic.
More well-known were various demo programs to play music on transistor radios placed on the CPU and computer "art", mostly kitschy pictures printed using Xs and 0s on chain printers. IBM 1401 was the first computer introduced in Nepal for the census purpose in 1971. It took about one year to take the census of the country. At that time the population of Nepal was about 10,000,000. Other programs would generate music by having the printer print particular groups/sequences of characters using the impact of the printer hammers to generate tones.
Truck-based portable version
- The 1401 was a decimal computer, so e.g. "8000" characters is not 8,192 characters.
- More simply stated: the four zone bits encoded the decimal values 0 to 15 as the binary numbers 0000 to 1111. The encoded value was used as the thousands part of a 1401 address. Thus making the 1401 a curious machine with memory addresses stored as a combination of 3 decimal digits and 4 binary digits. IBM did not use the word "binary" in describing the 1401's addressing (see the 1401 Reference Manual).
- The RPQ "Reader/Punch Card Code 8-2 and A-Bit Compatibility" (898148) causes the 1401 to read/punch the A bit as 8-2 for compatibility with the IBM 1410.
- Boshe, Charles J.; Johnson, Lyle R.; Palmer, John H.; Pugh, Emerson W. (1986). IBM's Early Computers. MIT Press. p. 473.
... configured for stand-alone use as well as peripheral service for larger computers ... A small configuration, without tapes and with the minimum memory capacity, was available for just under $2500 per month, a much lower rental for much higher performance than three 407 accounting machines plus a 604 calculator.
- Information Technology Industry TimeLine Retrieved October 26, 2017.
- "1401 Data Processing System". IBM Archives. October 5, 1959. Retrieved June 2, 2010.
- Columbia University, Computing History Project
- Spicer, Dag. "Back to Life: The story behind CHM's IBM 1401 Restoration" (PDF). Computer History Museum. Archived from the original (PDF) on November 5, 2010. Retrieved May 27, 2011.
- "FAQ's for Products and Services". IBM Archives. Retrieved June 2, 2010.
- among other things, Honeywell used the name Easycoder, resembling IBM's Autocoder.
- there was also a semi-automated converter of 1401 object code, named Liberator: "Using Liberator".
- Emerson W. Pugh (1995). Building IBM: Shaping an Industry and Its Technology. MIT. p. 273. ISBN 0-262-16147-8.
- "1401 Restoration Project".
- "1401 "Rebuilding the IBM," by Philip E. Ross, IEEE Spectrum, November 2009".
- IBM and BCD
- Fedorkow, Guy (2015). IBM 1401AModernTheory of Operation (PDF). p. 143.
- IBM (April 1962). IBM 1401 Data Processing System: Reference Manual (PDF). p. 20. A24-1403-5. Archived from the original (PDF) on August 9, 2010.
- IBM 1401G, booklet 520-1061-0
- "System Operation Reference Manual. IBM 1401. IBM 1460" (PDF).
- "Tom Van Vleck: 1401s I have known".
- Rob Storey. "Core memory frame from a 1401". Retrieved July 15, 2012.
- "The IBM 1401". IBM 1401 Restoration Project. Computer History Museum. Retrieved July 15, 2012.
The 1401’s clock frequency is 86,957 cycles per second, or about 87 kiloHertz! This corresponds to an 11.5 micro-second system clock cycle time. ... The 1401 CPU does everything in a character-serial manner. In order to add say two N-digit numbers, the CPU takes several cycles to fetch the instruction itself and then one cycle for every character of the instruction’s two operands or arguments, or 2N cycles total.
- "IBM 1401 Principles of Programming, Section 7" (PDF). IBM Personal Study Program. IBM Corporation. 1961. p. 19. Retrieved July 15, 2012.
The timing of the IBM 1401 is described in terms of the time required for one complete core storage cycle, which is 11.5 microseconds ... The time required for any internal processing instruction is always a multiple of this interval of time.
- "Custom Features for IBM 1401, 1440, and 1460 Data Processing Systems" (PDF). Archived from the original (PDF) on August 29, 2012. Retrieved September 23, 2015.
- "IBM 1401, A User's Manual-Live in Italy". Retrieved January 29, 2015.
- "Jóhann Jóhannsson: IBM 1401, A User's Manual". work's web site. Archived from the original on February 11, 2015. Retrieved January 29, 2015.
- Gansing, Kristoffer (2007). "Working Paper version - Humans Thinking Like Machines - Incidental Media Art in the Swedish Welfare State" (PDF). University of Malmö, School of Arts & Communication. Retrieved November 29, 2017. A full version to be published in Place Studies in Art, Media, Science and Technology, VDG Weimar 2009
- IBM 1401: The Mainframe --Cultural impacts
- IBM 1401: The Mainframe-- Overview
- Columbia University Computing History--The IBM 1401
- IBM 1401 System - 50th Anniversary in the Computer History Museum YouTube November 19, 2009
- IBM 1401 French Presentation with English Subtitles YouTube April 20, 2014
- IBM 1401 for the Roper Corporation YouTube May 14, 2015
- The IBM 1401 compiles and runs FORTRAN II YouTube February 2, 2018
- Bashe, Charles J.; Johnson, Lyle R; Palmer, John H.; Pugh, Emerson W. (1986). IBM's Early Computers. MIT. pp. 717. ISBN 0-262-02225-7. Chapter 12 Broadening the Base pages 465–494, a history of IBM's 1401 and 1403 development
- IBM 1401 System Summary (PDF). IBM. April 1966. A24-1401-1. Brief descriptions of the machine features, components, configurations, and special features
- IBM 1401 Data Processing System: Reference Manual (PDF). IBM. April 1962. A24-1403-5. Archived from the original (PDF) on August 9, 2010.
- 1401 documents on bitsavers.org
- A Century of Smart: The IBM 1401 (1959). IBM Social Media. November 16, 2009. Archived from the original on March 9, 2011. Retrieved November 17, 2009. Video captures thoughts and reflections of some of the original 1401 team members from a reunion held in Endicott, NY in 2009. Includes footage from 1401 marketing films.
- 1401 videos and sounds
- 1401s I have Known, Tom Van Vleck
- L. H. Haines (1965). "Serial compilation and the 1401 FORTRAN compiler". IBM Systems Journal. 4 (1): 73–80. doi:10.1147/sj.41.0073. This article was reprinted, edited, in both editions of Lee, John A. N. (1967). Anatomy of a Compiler (1st and 1974 2nd ed.). Van Nostrand Reinhold.
- Music inspired by the 1401: Johann Johannsson's "IBM 1401: A User's Manual" - CD / LP
- a double width SMS card used in the 1401 used germanium alloy transistors
- Shirriff, Ken (February 2021). "Booting the IBM 1401: How a 1959 punch-card computer loads a program".
- Shirriff, Ken (March 2021). "Germanium transistors: logic circuits in the IBM 1401 computer".