Information about IBM 1130

IBM 1130 Console, restoration in progress.

The IBM 1130 Computing System was introduced in 1965. It was IBM's least-expensive computer to date, and was aimed at price-sensitive, computing-intensive technical markets like education and engineering. The IBM 1800 was a process control variant of the 1130 with two extra instructions (CMP and DCM) and extra I/O capabilities.

Description

The 1130 became quite popular, and the 1130 and its non-IBM clones gave many people their first feel of "personal computing." Though its price-performance ratio was good and it notably included inexpensive disk storage, it otherwise broke no new ground technically. The 1130 holds a place in computing history primarily because of the fondness its former users hold for it.

The IBM 1130 used System/360 electronics packaging called Solid Logic Technology (SLT) and had a 16-bit binary architecture, not very different from later minicomputers like the PDP-11 or Data General Nova. The address space was 15 bits, limiting the 1130 to 32K 16-bit words of core memory. Both direct and indirect addressing capabilities were implemented. Amazing loops were possible.

Much programming was done in Fortran. The 1130 Fortran compiler could run on a machine with only 4K words of core. That's 8 kilobytes, the minimum file allocation on many PC's. To maximize speed and conserve space, the operating system and compilers were written entirely in assembly language, and employed techniques seen less frequently today including tight integration of code and data as well as self-modifying code.

Other programming languages available on the 1130 included: APL^[1], BASIC, COBOL, FORTH, PL/I and RPG. Eastern Michigan University developed a Fortran IV compiler for the 1130.

The basic 1130 came with an IBM 2310 disk drive. These read pizza-box-sized 2315 single platter cartridges that held 512 K words or 1 M byte (less than a 3.5" floppy). Disk memory was used to store the operating system, object code, and data, but not source code. The last was kept on punch cards. The disk operating system was called DMS or DM2 (for Disk Monitor System, Release 2).

Other available peripherals included the IBM 1132 and IBM 1403 lineprinters, the IBM 1442 card reader/punch, the IBM 2311 Disk Drive, the IBM 2250 Graphic Display Unit and the IBM 1627 drum plotter. The plotter was very useful for engineering work. The console typewriter used an IBM Selectric mechanism, which meant one could change the type by replacing a hollow, golf-ball sized type element. There was a special type element available for APL, a powerful array-oriented programming language using a special symbolic notation.

The IBM 1130 MTCA, for Multiple Terminal Control Adapter, was announced late in the 1130's product life; it allowed up to four 2741 terminals to be connected to an IBM 1130, for use with APL.

A standard 1130 had a 3.6 microsecond memory cycle time, with a more expensive model equipped with 2.2 Âµs memory cycle time. (You could use the latter with a 1403 printer connected through a 1133 multiplexer.) To further tap the low end of the market, IBM introduced the 1130 Model 4, with a 5.6 Âµs cycle time - at a lower price of course. The Model 4's 1132 printer was derated as well, but the slower CPU still could not keep up with it. (The 1132 used the CPU to determine when to fire the print wheels as they rotated, a very compute intensive function.) Careful readers of the 1130 hardware manual discovered that when the printer interrupt level (4) was on, the 1130 Model 4 ran at the faster 3.6 us cycle time. Some users of the Model 4 would write a phony printer driver that turned on level 4 and left it on. They would call this driver when running a compute-intensive job and write their output to disk, the printer being unusable, of course. When done, they'd run a normal program to print their output.

IBM 1130 Models

IBM implemented five models of the 1131 Central Processing Unit which was the primary processing component of the IBM 1130 Computing Systems.

	Storage Speed
Storage Size	3.6-microsec. storage cycle no internal disk	3.6-microsec. storage cycle plus disks	3.6-microsec. storage cycle (70% performance) single disk	2.2-microsec. storage cycle plus disks	2.2-microsec. storage cycle (no internal disk)
4096 words	Model 1A	Model 2A	Model 4A	---	---
8192 words	Model 1B	Model 2B	Model 4B	Model 3B	Model 5B
16,384 words	Model 1C	Model 2C	---	Model 3C	Model 5C
32,768 words	Model 1D	Model 2D	---	Model 3D	Model 5D

The IBM 1800 was a variant of the IBM 1130 with additional features for process control applications. Just as the IBM 1130 was a successor to the IBM 1620, the IBM 1800 was a successor to the IBM 1710

Chronology

Feb. 11, 1965 - IBM introduces the 1130 (Models A1, A2, B1 and B2). Also announced is the IBM 1132 printer, the lowest cost online computer printer ever announced by IBM at that time.
Fourth Quarter 1965 - First customer shipments begin from the San Jose plant.
August 9, 1966 - IBM rolls out the 1130 synchronous communications adapter, which permits the small 1130 system to be connected by regular leased telephone lines to, and function as a communications terminal for, any model of the IBM System/360.
April 17, 1967 - A four-way expansion of the 1130 is announced (Models B3, C2, C3, D2 and D3), involving:
five times the disk storage and four times the magnetic core memory size;
an additional processing speed almost 40 percent faster than previously available;
More and faster peripheral equipment, including an optical mark reader;
an improved commercial programing package.
January 1968 - First shipments begin of the 1130 Models B3, C2, C3, D2 and D3.
July 1968 - The Boca Raton plant begins shipping the 1130.
July 22, 1971 - 1130 Models 4A and 4B are introduced at new levels of economy.
September 1971 - First customer shipments begin of the 1130 Model 4.
May 31, 1972 - Models 1C, 1D, 5B, 5C and 5D are announced.

Trivia

Punch card containing a self-loading 1130 program that would copy the deck of cards placed after it in the input hopper.

Brian Utley was the 1130's Project Manager during its development and introduction. Brian said at the third 11/30 party that before IBM Marketing named the 1130 it was known as the Small Engineering Computer System or SECS.^[2] The initial architecture was 18 bits but was changed to 16 bits due to the influence of the System/360 development. The full dialogue of his 2005 presentation is available at IBM1130.Org.

Notable software designer Grady Booch got his first exposure to programming on an IBM 1130:^[3]

... I pounded the doors at the local IBM sales office until a salesman took pity on me. After we chatted for a while, he handed me a Fortran [manual]. I'm sure he gave it to me thinking, "I'll never hear from this kid again." I returned the following week saying, "This is really cool. I've read the whole thing and have written a small program. Where can I find a computer?" The fellow, to my delight, found me programming time on an IBM 1130 on weekends and late-evening hours. That was my first programming experience, and I must thank that anonymous IBM salesman for launching my career. Thank you, IBM.

LISP guru Guy Steele wrote a LISP interpreter for the IBM 1130 when he was in high school (Boston Latin School, which had an IBM 1130 for student use)^[4]^[5]
Chuck Moore wanted to call his new language "Fourth" but the IBM 1130 operating system was limited to five character names, so it wound up being called FORTH.^[6]
Dan Bricklin creator of the VisiCalc program got his start in programming when he learned and used the IBM 1130 as part of the National Science Foundation Computer/Math Summer Project for high school students, given at the University of Pennsylvania in 1966.^[7]
An IBM 1130 with 8 kilowords of core was used for the world's first full-time Search for Extraterrestrial Intelligence research at The Ohio State University Radio Observatory.^[8]
Charles Goldfarb, the father of SGML, describes a job installing a typesetting system based on an IBM 1130 that "eventually changed my career", driving him towards generic markup:^[9]

The system was an IBM 1130 computer, a machine the size of a desk with 8KB (sic!) of main memory, a 512KB disk drive, a Teletype CX paper tape reader and BRPE paper tape punch, and a Photon 713 photomechanical typesetter. The assignment was my first experience with managing a machine-readable document database: I learned to roll the punched paper tape carefully so that it could be stored neatly in cylindrical waste paper baskets.
In the meantime, though I didn't know about it, the roots of generalized markup were being planted. Historically, electronic manuscripts contained control codes or macros that caused the document to be formatted in a particular way ("specific coding"). In contrast, generic coding, which began in the late 1960s, uses descriptive tags (for example, "heading", rather than "format-17").

There was an urban legend at the time of introduction that since it was a small scientific machine, the model number of the IBM 1130 was obtained from multiplying the model number of the IBM 360 by π.
There was an early version of the operating system which had the unique feature that the file headers when written by either FORTRAN and and early RPG compiler were not compatible. Before using the other language, the file had to be copied.

Instruction set overview

>
Main Registers:
IAR = Instruction Address Register
ACC = Accumulator
EXT = Extension Register
XRx = Index Registers x = 1,2,3
1130 Instruction Set Mnemonics:
LD   = Load ACC                   STO  = Store ACC
LDD  = Load Double (ACC & EXT)    STD  = Store Double (ACC & EXT)
LDX  = Load Index                 STX  = Store Index
LDS  = Load Status                STS  = Store Status
A    = Add ACC                    AD   = Add Double
S    = Subtract ACC               SD   = Subtract Double
M    = Multiply                   D    = Divide
AND  = Boolean And                OR   = Boolean Or
XOR  = Boolean Exclusive Or
SLA  = Shift Left ACC             SLT  = Shift Left ACC & EXT
SLCA = Shift Left and Count ACC   SLC  = Shift Left and Count ACC & EXT
SRA  = Shift Right ACC            SRT  = Shift Right ACC & EXT
RTE  = Rotate Right ACC & EXT     XCH  = Exchange ACC and EXT
MDM  = Modify Memory
B    = Branch
BSC  = Branch or Skip on Condition (Modifier dependent)
       i.e. BP BNP BN BNN BZ BNZ BC BO BOD
BSI  = Branch and Store IAR
MDX  = Modify Index and Skip
WAIT = Halt                       NOP  = No Operation
XIO  = Execute I/O
1800 Additional Instruction Mnemonics:
CMP  = Compare ACC                DCM  = Double Compare ACC & EXT
Short instruction format (one 16 bit word):
                       1
Bits    0...45678......5
        OP---FTTDisp----
OP    is Operation
F     is format 0 = Short
TT    is Tag
Disp  is Displacement
Long instruction format (two 16 bit words):
                       1               1
Bits    0...456789.....50..............5
        OP---FTTIMod----Address---------
OP    is Operation
F     is format 1 = Long
TT    is Tag
I     is Indirect bit
Mod   is Modifier
Effective Address Calulation (EA):
          F = 0            | F = 1, I = 0     | F = 1, I = 1
          Direct Addressing| Direct Addressing| Indirect Addressing
-------------------------------------------------------------------
TT = 00 | EA = Displ + IAR | EA = Add         | EA = C/Add
TT = 01 | EA = Displ + XR1 | EA = Add + XR1   | EA = C/Add + XR1
TT = 10 | EA = Displ + XR2 | EA = Add + XR2   | EA = C/Add + XR2
TT = 11 | EA = Displ + XR3 | EA = Add + XR2   | EA = C/Add + XR3
-------------------------------------------------------------------
    Disp = Contents of displacement field
     Add = Contents of address field of instruction
       C = Contents of location specified by Add or Add + XR

Programming Examples

The examples can be executed on the IBM 1130 emulator available at IBM 1130.org.

Sample Assembler program deck

The following listing shows a card deck that compiles and runs an Assembler program that lists a deck of cards to the line printer.
The following code Copyright (c) 2006 Kym Farnik. Code published under MIT license. See: [1]

>
 // JOB 
 // ASM
 *LIST
                     * LCARD.ASM - LIST A DECK OF CARDS TO LINE PRINTER
                     *
                     * COPYRIGHT (C) 2006 KYM FARNIK. 
                     * CODE PUBLISHED UNDER MIT LICENSE. 
                     *
                     * PROGRAM
                     *    NEW PAGE ON PRINTER
                     * A  READ A CARD
                     *    CONVERT FORMAT
                     *    PRINT A LINE ON PRINTER
                     *    GOTO A
                     *
                     START LIBF    PRNT1    GOTO NEW PAGE ON 1132
                           DC      /3100    PRINTER CHANNEL 1-NEW PAGE
                     *
                     NEXTC LIBF    CARD0    READ FROM 1442 CARD READER
                           DC      /1000    CONTROL TO READ
                           DC      CBUFF    STORE 80 COLUMNS
                     CINP  LIBF    CARD0
                           DC      0
                           B       CINP     LOOP UNTIL CARD IS READ
                     *
                           LIBF    ZIPCO    CONVERT CARD TO PRINTER
                           DC      /1100    UNPACKED IN, PACKED OUT
                           DC      CBUFF+1  INPUT BUFFER
                           DC      PBUFF+1  OUTPUT BUFFER
                           DC      80       CHARACTER COUNT
                           CALL    HLEBC    HOLLERITH TO EBCDIC
                     *
                           LIBF    PRNT1    PRINT 80 CHARACTERS
                           DC      /2000    CONTROL CODE TO PRINT
                           DC      PBUFF    PRINT BUFFER
                           DC      PERR     PRINT ERROR
                     POUT  LIBF    PRNT1    CHECK FOR PRINT COMPLETE
                           DC      0
                           B       POUT     LOOP UNTIL COMPLETE
                     *
                           B       NEXTC    READ NEXT CARD
                     *
                     * DATA
                     *
                     CBUFF DC      80       80 COLUMNS PER CARD
                           BSS     80
                     *
                     PBUFF DC      40       40 WORDS 80 CHARACTERS
                           BSS     40
                     *
                     PERR  DC      0
                           B    I  PERR     THIS RETURNS TO THE
                     *                       PRINTER ERROR HANDLER
                     *                       WHICH WILL TERMINATE THE PROGRAM
                     *
                           END     START    PROGRAM ENTRY POINT
 // XEQ
 TEST DATA 1
 HELLO WORLD
 TEST DATA 2

Sample Fortran IV program deck

The following listing shows a card deck that compiles and runs a Fortran program and Fortran subroutine for the IBM 1130 when running DM2.
The following code Copyright (c) 2005 Kym Farnik. Code published under MIT license. See: [2]

>
 // JOB 
 // FOR
 *LIST SOURCE PROGRAM
 *ONE WORD INTEGERS
 C-------------------------------------------------------   
 C COMPUTE THE CRITICAL VALUES FOR A QUADRATIC EQN
 C 0=A*X**2+B*X+C
 C RETURNS DISCRIMINANT, ROOTS, VERTEX, FOCAL LENGTH, FOCAL POINT
 C X1 AND X2 ARE THE ROOTS
 C-------------------------------------------------------   
       SUBROUTINE QUADR(A,B,C,DISCR,X1,X2,VX,VY,FL,FPY)
       REAL A,B,C,DISCR,X1,X2,VX,VY,FL,FPY
 C DISCRIMINANT, VERTEX, FOCAL LENGTH, FOCAL POINT Y
       DISCR = B**2.0 - 4.0*A*C
       VX = -B / (2.0*A)
       VY = A*VX**2.0 + B*VX + C
       FL = 1.0 / (A * 4.0)
       FPY = VY + FL
       FL = ABS(FL)
 C COMPUTE THE ROOTS BASED ON THE DISCRIMINANT
       IF(DISCR) 110,120,130
 C -VE DISCRIMINANT, TWO COMPLEX ROOTS, REAL=X1, IMG=+/-X2
 110   X1 = -B / (2.0*A)
       X2 = SQRT(-DISCR) / (2.0*A)
       RETURN
       
 C ZERO DISCRIMINANT, ONE REAL ROOT
 120   X1 = -B / (2.0*A)
       X2 = X1
       RETURN 
 C +VE DISCRIMINANT, TWO REAL ROOTS
 130   X1 = (-B + SQRT(DISCR)) / (2.0*A)
       X2 = (-B - SQRT(DISCR)) / (2.0*A)
       RETURN
 C
 C NEXT STORE SUBROUTINE ON DISK USING DUP
       END
 // DUP
 *DELETE             QUADR
 *STORE      WS  UA  QUADR
 // JOB
 // FOR
 *LIST SOURCE PROGRAM   
 *IOCS(CARD,1132 PRINTER)   
 *ONE WORD INTEGERS   
 C-------------------------------------------------------   
 C PROCESS DATA CARDS WITH A,B,C
 C UNTIL A=0
 C-------------------------------------------------------   
       DATA ICARD,IPRT /2,3/
       REAL A,B,C
       REAL DISCR,XR1,XR2,VX,VY,FL,FPY
       WRITE(IPRT,901)
 901   FORMAT(' ------------------------------------------------------')
 C READ A B C, IF A=0 THEN EXIT
 100   READ(ICARD,801)A,B,C
 801   FORMAT(3F8.3)
 C     EXIT WHEN A IS ZERO
       IF (A) 110,9000,110
 C PRINT A B C 
 110   WRITE(IPRT,902)A,B,C
 902   FORMAT(' QUADRATIC A=',F8.3,' B=',F8.3,' C=',F8.3)
 C COMPUTE AND PRINT THE CRITICAL VALUES
       CALL QUADR(A,B,C,DISCR,XR1,XR2,VX,VY,FL,FPY)
       WRITE(IPRT,903) DISCR
 903   FORMAT(' DISCRIMINANT=',F9.4)
       WRITE(IPRT,904) VX,VY
 904   FORMAT(' VERTEX X=',F9.4,'  Y=',F9.4)
       WRITE(IPRT,905) FL
 905   FORMAT(' FOCAL LENGTH=',F9.4)
       WRITE(IPRT,906) VX,FPY
 906   FORMAT(' FOCAL POINT X=',F9.4,'  Y='F9.4)
       IF (DISCR) 120,130,140
 C -VE DISCRIMINANT, TWO COMPLEX ROOTS
 120   WRITE(IPRT,913) XR1, XR2
 913   FORMAT(' COMPLEX ROOTS =(',F9.4,'  +/-',F9.4,'I)')
       GO TO 200
       
 C ZERO DISCRIMINANT, ONE REAL ROOT
 130   WRITE(IPRT,912) XR1
 912   FORMAT(' ROOT  X =',F9.4)
       GO TO 200
 C +VE DISCRIMINANT, TWO REAL ROOTS
 140   WRITE(IPRT,911) XR1, XR2
 911   FORMAT(' ROOTS X1=',F9.4,'   X2=',F9.4)
 C --- GO TO 200
 C END OF QUAD
 200   WRITE(IPRT,901)
       GO TO 100
 C END OF PROGRAM
 C DATA FOLLOWS XEQ CARD
 9000  CALL EXIT   
       END   
 // XEQ
 +001.000+000.000+000.000
 +001.000+002.000+003.000
 +002.000+002.000+000.000
 +002.000+000.000-004.000
 +000.500+000.000-004.000
 +000.250+002.000-002.000
 -004.000+000.000-004.000
 +002.730-007.200-003.750
 +000.000+000.000+000.000

Sample APL \ 1130 session

The following image shows a simple APL \ 1130 session. This session was performed via the 1130 simulator available from IBM 1130.org

apl \ 1130
apl \ 1130 sample session

The above session shows a signon, addition of the integers 1 to 100, generation of an addition table for the integers 1..5 and a sign off.

References

1. ^ Larry Breed (August 2006). "How We Got To APL\1130". Vector (British APL Association) 22 (3). ISSN 0955-1433.
2. ^ Utley, Brian (2006-10-30). Origin of the IBM 1130 Name. Retrieved on 2007-01-16.
3. ^ Booch, Grady (2003-04-03). Quote from interview Grady Booch polishes his crystal ball. IBM

accessdate=2007-01-16.
4. ^ Steele, Guy L., Jr. (2005-11-24). Thoughts on Language Design -- New challenges require new solutions. Dr. Dobb's Journal. Retrieved on 2006-01-16.
5. ^ Steele, Guy L., Jr.. Confessions of a Happy Hacker. Retrieved on 2006-01-16.
6. ^ Rather, Elizabeth; Colburn, Donald and Moore, Charles (March 1993). The Evolution of Forth. Retrieved on 2007-01-16.
7. ^ Bricklin, Dan (2002-08-23). Memories while visiting the Bay Area and the Computer History Museum. Retrieved on 2007-01-16.
8. ^ Dixon, Bob (2005-08-13). SETI in the 1970s. The Big Ear. Retrieved on 2007-01-16.
9. ^ Goldfarb, Charles (1996). The Roots of SGML -- A Personal Recollection. Retrieved on 2007-01-16.

Ibm 1130