TheLGP-30, standing forLibrascope General Purpose and thenLibrascope General Precision, is an early off-the-shelf computer. It was manufactured by theLibrascope company ofGlendale, California (a division ofGeneral Precision Inc.), and sold and serviced by the Royal Precision Electronic Computer Company, a joint venture with theRoyal McBee division of theRoyal Typewriter Company. The LGP-30 was first manufactured in 1956,[1][2][3] at a retail price of $47,000, equivalent to $560,000 in 2025.[4]
The LGP-30 was commonly referred to as a desk computer. Its height, width, and depth, excluding the typewriter shelf, was 33 by 44 by 26 inches (84 by 112 by 66 cm). It weighed about 800 pounds (360 kg),[5] and was mounted on sturdycasters which facilitated moving the unit.
The primary design consultant for the Librascope computer wasStan Frankel, aManhattan Project veteran and one of the first programmers ofENIAC, assisted byJames Cass, at the time a graduate student atCaltech.[6] They designed a usable computer with a minimal amount of hardware.[7] The single addressinstruction set had only 16 commands. Magneticdrum memory held themain memory, and thecentral processing unit (CPU)processor registers, timing information, and the master bit clock, each on a dedicated track. The number ofvacuum tubes (113)[6] was minimized by using solid-statediode logic, abit-serial architecture[8] and multiple use of each of the 15 flip-flops.[citation needed]
It was abinary, 31-bit wordcomputer with a 4096-worddrum memory. Standard inputs were theFlexowriter keyboard andpaper tape (ten six-bit characters/second). The standard output was the Flexowriterprinter (typewriter, working at 10 characters/second). An optional higher-speed paper tape reader and punch was available as a separate peripheral.[citation needed]
The computer contained 113 electronictubes and 1450diodes. The tubes were mounted on 34 etched circuit pluggable cards which also contain associated components. The 34 cards were of only 12 different types. Card-extenders were available to permit dynamic testing of all machine functions. 680 of the 1450 diodes were mounted on one pluggablelogic board.[citation needed]
The LGP-30 required 1500watts operating under full load. The power inlet cord could plug into any standard 115volt 60-cycle single-phase line. The computer incorporatedvoltage regulation suitable for powerline variation of 95 to 130 volts. In addition to power regulation, the computer also contained circuitry for a warm-up stage, which minimized thermal shock to the tubes to ensure longer life. The computer contained a cooling fan which directed filteredair through ducts to the tubes and diodes, to extend component life and ensure proper operation. No expensiveair conditioning was necessary if the LGP-30 was operated at reasonable temperatures.[citation needed]
Al Barr, professor of Computer Science at Caltech, noted in 2023 the power saving features of the design. "Much of the computer hardware before the LGP-30 used far too many vacuum tubes. Vacuum tubes used a great deal of electrical power, produced a lot of heat, and were fairly unreliable since they frequently burned out like incandescent light bulbs. The LGP-30 used a goodly amount of solid-state diode logic to reduce the number of vacuum tubes, increasing its reliability and decreasing its power use. The hardware design was one of the stepping stones that opened the door to the modern computer revolution."[6]
Each drum word had 32 bit locations, but only 31 were used, permitting a "restoration of magnetic flux in the head" at the 32nd bit time. Since each instruction had only one address, a method was needed to optimize allocation ofoperands. Otherwise, each instruction would wait a complete drum (or disk) revolution each time a data reference was made. The LGP-30 provided foroperand-location optimization byinterleaving thelogical addresses on the drum, so that two adjacent addresses (e.g., 00 and 01) were separated by nine physical locations. These spaces allowed for operands to be located next to the instructions that used them. The drum had 64 tracks, each with 64 words (sectors). The time between two adjacent physical words was about 0.260millisecond (ms), and the time between two adjacent addresses was 9 x 0.260 or 2.340 ms. The worst-case access time was 16.66 ms.[citation needed]
Half of the instruction (15 bits) was unused. The unused half could have been used for extra instructions, indexing,indirect addressing, or a second (+1) address to locate the next instruction, each of which would have increased program performance. None of these features was implemented in the LGP-30, but some were realized in its 1960 successor, the RPC-4000.[citation needed]
A unique feature of the LGP-30 was its built-in multiplication, despite being an inexpensive computer. Since this was a drum computer, bits were processed serially as they were read from the drum. As it did each of the additions associated with the multiplication, it effectively shifted the operand right, acting as ifthe binary point were on the left side of the word, as opposed to the right side as on most other computers. The divide operation worked similarly.[citation needed]
To further reduce costs, the traditionalfront panel lights showing internal registers were absent. Instead, Librascope mounted a smalloscilloscope on the front panel that displayed the output from the three register read heads, one above the other, allowing the operator to see and read the bits. Horizontal and vertical size controls let the operator adjust the display to match a plastic overlay engraved with the bit numbers. To read bits the operator counted the up- and down-transitions of the oscilloscope trace.[citation needed]
Unlike other computers of its day, internal data was represented inhexadecimal instead ofoctal, but being a very inexpensive machine it used the physical typewriter keys that correspond to positions 10 to 15 in the type basket for the six non-decimal characters (as opposed to the now normal A – F) to represent those values, resulting in 0 – 9 f g j k q w, which was remembered using themnemonic "Fiber-GlassJavelins Kill Quite Well".[citation needed]
The LGP-30 has 16 instructions. Each instruction occupies a 31-bit word though about half the bits are unused and set to zero. An instruction consists of an "order" such as the letter b for "bring from memory" and an address part such as the number 2000 to designate a memory location. All instructions have a similar appearance in an LGP-30 word. The order bits occupy positions 12 through 15 of the word and the address bits occupy positions 18 through 29 of the word. The address bits are further divided by track and sector. Although all instructions have an address, some do not use the address. It is customary to enter an address of 0000 in these instructions.[10]
| 00 | 11 | 12 | 15 | 16 | 17 | 18 | 23 | 24 | 29 | 30 | ||||||||||||||||||||
| 000000000000 | Order | 00 | Track | Sector | 0 | |||||||||||||||||||||||||
| Example | Order | Operation |
|---|---|---|
| b 2000 | 0001 | Bring from Memory: Replace the contents of the accumulator with the contents of memory location 2000. The contents of memory location 2000 is unaffected. |
| h 2000 | 1100 | Hold and Store: Replace the contents of memory location 2000 with the contents of the accumulator. The contents of the accumulator is unaffected. |
| c 2000 | 1101 | Clear and Store: Replace the contents of memory location 2000 with the contents of the accumulator and replace the contents of the accumulator with zero. |
| y 2000 | 0010 | Store Address: Replace the contents of the address portion of the word in memory location 2000 with the contents of the address portion of the word in the accumulator. The contents of the accumulator is unaffected. The LGP-30 has no index register. Y can be used to self-modify code to index an array. |
| u 2000 | 1010 | Unconditional transfer: Replace the number in the (program) counter register with the contents of the address portion of the unconditional transfer instruction. |
| r 2000 | 0011 | Return address: Add one to the contents of the (program) counter register and replace the address portion of memory location 2000 with the contents of the counter register. This instruction is used to patch anunconditional transfer instruction at the end of a subroutine to direct it to return to the caller. R is followed immediately with a branch instruction to the beginning of the subroutine. R can also be used to patch aTest instruction to create a conditional return. |
| t 2000 | 1011 | Test: (Conditional transfer) If a one is in the sign bit of the word in the accumulator, the test instruction has the effect of an unconditional transfer. If a zero is in the sign bit of the word in the accumulator, the next following instruction in normal sequence is executed. |
| z 0000 | 0000 | Stop: Stop computation. If computation is to stop, the address portion of the stop instruction is usually of no significance. However, the stop order has a special characteristic. If there is a one in the third bit from the right hand end of the track portion of a stop instruction, computation does not stop if break point switch 4 on the console of the computer is depressed. Four break point switches are supported by the z instruction. |
| p 2000 | 1000 | Print: Execute the typewriter keyboard function indicated by the 6 track bits. The print order has no effect on the contents of any memory location, the accumulator, or the counter register. For example, p 2000 has 010100 in the track bits which is the code for a back space on the typewriter. The execution of p 2000 results in the typewriter back spacing. |
| i 0000 | 0100 | Input: The address portion of the instruction constructed from this order is always 0000. It is always preceded by the instruction p 0000. After a p 0000 instruction starts the tape reader, an i 0000 instruction transfers into the last 4 bit positions of the accumulator the first 4 bits of the typewriter code for the first character read on the tape. When the second character is read, the bits representing the first character are shifted left into the next to last four bit positions of the accumulator and the first four bits of the typewriter code of the second character on tape are placed in the last four bit positions of the accumulator. This process continues up to eight times to fill the entire accumulator until a stop code (100000) appears on the tape. The stop code stops the tape reader and sends a start signal to the computer so that the instruction following i 0000 in memory is executed. Often this next instruction is a h or c instruction so that the characters read into the accumulator can be stored in some memory location. |
| a 2000 | 1110 | Add: Add the contents of memory location 2000 to the contents of the accumulator and place the result in the accumulator. The contents of memory location 2000 is unaffected. |
| s 2000 | 1111 | Subtract: Subtract the contents of memory location 2000 from the contents of the accumulator and place the result in the accumulator. The contents of memory location 2000 is unaffected. |
| m 2000 | 0111 | Multiply upper: Multiply the number in the accumulator by the number in memory location 2000 and place the most significant thirty bits of the product in the accumulator. The contents of memory location 2000 is unaffected. |
| n 2000 | 0110 | Multiply lower: Multiply the number in the accumulator by the number in memory location 2000 and place the least significant thirty-one magnitude bits of the product in the sign bit and thirty magnitude bits of the accumulator. The contents of memory location 2000 is unaffected. |
| d 2000 | 0101 | Divide: Divide the number in the accumulator by the number in memory location 2000 and place the quotient rounded to thirty bits in the accumulator. The contents of memory location 2000 is unaffected. |
| e 2000 | 1001 | Extract: Place zeroes in the word in the accumulator wherever there are zeroes in location 2000 but otherwise leave the word in the accumulator unchanged. The contents of location 2000 is unaffected. This is the equivalent of anAND instruction on most computers. |
The LGP-30 had a high-level language called ACT-III. Every token had to be delimited by an apostrophe, making it hard to read and even harder to prepare tapes:[11]
s1'dim'a'500'm'500'q'500''index'j'j+1'j-1''daprt'e'n't'e'r' 'd'a't'a''cr''rdxit's35''s2'iread'm'1''iread'q'1''iread'd''iread'n''1';'j''0'flo'd';'d.''s3'sqrt'd.';'sqrd.''1'unflo'sqrd.'i/'10';'sqrd''2010'print'sqrd.''2000'iprt'sqrd''cr''cr''...
Dartmouth College developed two implementations ofALGOL 60 for the LGP-30.Dartmouth ALGOL 30 is a three-pass system (compiler, loader, and interpreter) that provides almost all features of ALGOL except those requiring run-time storage allocation. SCALP, a Self Contained Algol Processor, is a one-pass system for a small subset of ALGOL: no blocks other than the entire program, no procedure declarations, conditional statements but no conditional expressions, no constructs other thanwhile in afor statement, no nestedswitch declarations (nested calls are permitted), and no Boolean variables or operators. As in ACT-III, every token had to be separated by an apostrophe.[9]
DICTATOR is a convoluted acronym forDODCOInterpretiveCode forThreeAddress withTechnicalOptimumRange. DICTATOR, introduced in 1959, is an interpreter designed to hide the LGP-30 machine details from the programmer. The programming language resembles three-operand assembly code with two source operands and one destination operand. All numbers are in floating point with an eight digit mantissa and two digit exponent.Natural logs and exponents are supported along withsin, cos, andarctan. Up to four nested loops are supported. Table look-up and block memory move operations are implemented. A bit more than half the total LGP-30 memory is used by the interpreter; it takes about 30 minutes to load the paper tape via the Flexowriter. Floating point add, subtract, multiply, and divide take less than 455 milliseconds each. Cosine is calculated in 740 milliseconds.[12]
The procedure for starting, or "booting" the LGP-30 was complicated. First, the bootstrap paper tape was snapped into the console typewriter, aFriden Flexowriter. The operator pressed a lever on the Flexowriter to read an address field and pressed a button on the front panel to transfer the address into a computer register. Then the lever on the Flexowriter was pressed to read the data field and three more buttons were pressed on the front panel to store it at the specified address. This process was repeated, maybe six to eight times, and a rhythm was developed:
burrrp, clunk, burrrp, clunk, clunk, clunk, burrrp, clunk, burrrp, clunk, clunk, clunk,burrrp, clunk, burrrp, clunk, clunk, clunk, burrrp, clunk, burrrp, clunk, clunk, clunk, burrrp, clunk, burrrp, clunk, clunk, clunk, burrrp, clunk, burrrp, clunk, clunk, clunk.
The operator then removed the bootstrap tape, snapped in the tape containing the regular loader, carefully arranging it so it would not jam, and pressed a few more buttons to start up the bootstrap program. Once the regular loader was in, the computer was ready to read in a program tape. The regular loader read a more compact format tape than the bootstrap loader. Each block began with a starting address so the tape could be rewound and retried if an error occurred. If any mistakes were made in the process, or if the program crashed and damaged the loader program, the process had to be restarted from the beginning.[13]
In 1960, Librascope announced another, more-powerful successor machine, the General Precision RPC 4000.[14] Similar to the LGP-30, but transistorized, it featured 8,008 32-bit words of memory drum storage. It had 500 transistors and 4,500 diodes, sold for $87,500 (equivalent to $952,300 in 2025), and weighed 500 pounds (230 kg).[15][16][17]
In 1963,[18] Librascope produced a transistorized update to the LGP-30 named the LGP-21.[19][20] The new computer had about 460 transistors and about 375 diodes. It cost only US$16,250 (equivalent to $170,900 in 2025), one-third the price of its predecessor. However, it was also about one-third as fast as the earlier computer.[citation needed]
The central computer weighed about 90 pounds (41 kg),[21] the basic system (including printer and stands) about 155 pounds (70 kg).[22]
Edward Lorenz used the LGP-30 in his attempt to model changing weather patterns. His discovery that massive differences in forecast could derive from tiny differences in initial data led to him coining the termsstrange attractor andbutterfly effect, core concepts inchaos theory.[23] The RPC-4000 (successor to the LGP-30) is also remembered as the computer on whichMel Kaye performed a legendary programming task inmachine code, retold byEd Nather in the hacker epicThe Story of Mel.[24]
Software simulations of the LGP-30 and LGP-21 are supported bySIMH, a free and open source, multi-platform multi-system emulator.[citation needed]
{{cite web}}: CS1 maint: others (link)In November, 1955, (...) two important events occurred. The LGP-30 computer, containing seven MH-10R heads, failed to function correctly at the International Automation Exhibition in Chicago on November 15, 1955. In fact, an LGP-30 computer did not work satisfactorily until March, 1956, and the computer was not offered for sale to the general public until the fall of 1956.
{{cite book}}: CS1 maint: multiple names: authors list (link)
This article incorporates text from this source, which is in thepublic domain.The size of two desks, it weighs 900 lbs
