Keypunch


IBM 029 keypunch.

A keypunch is a device for manually entering data into punched cards by precisely punching holes at locations designated by the keys struck by the operator. Early keypunches were manual devices. Later keypunches were mechanized, often resembled a small desk, with a keyboard similar to a typewriter, and with hoppers for blank cards and stackers for punched cards. Some keypunch models could print at the top of columns, the character punched in each of those columns. The small pieces punched out by a keypunch fell into a chad box, or (at IBM) chip box, or bit bucket.

In many data processing facilities the punched cards were verified by keying the exact same data a second time and then checking to see if the second keying and the punched data were the same. There was a great demand for keypunch operators, usually women[1], who worked full-time on keypunch and verifier machines, often in large keypunch departments with dozens or hundreds of other operators.

IBM keypunches such as the 024, 026 and 029 provided for the mounting of a program card that controlled various functions, such as tabbing and automatic duplication of fields from the previous card. The later 129 used electronic circuit cards to store simple programs written by the keypunch operator.

Keypunch operators at work at the U.S. Social Security Administration in the 1940s.
Hand-operated keypunch manufactured by British ICT (1960s)

Keypunches were popular through the 1970s but were rapidly made obsolete by the availability of graphical terminals[2]

Contents

Hollerith and IBM Keypunches, 1890 through 1930s

Herman Hollerith's first device for punching cards from the 1890s was ...any ordinary ticket punch, cutting a round hole 3/16 of an inch in diameter.[3]. Use of such a punch was facilitated by placing the holes to be used near the edges of the card. Hollerith soon developed a more accurate, simpler to use, Keyboard Punch, using a pantograph to link a punch mechanism to a guide pointer that an operator would place over the appropriate mark in a 12 by 20 matrix to line up a manual punch over correct hole in one of 20 columns. In 1901 Hollerith patented[4] a mechanism where an operator pressed one of 12 keys to punch a hole, with the card automatically advancing to the next column. This first generation Type 001 keypunch[5] used 45 columns and round holes. In 1923 CTR (renamed IBM in 1924) introduced the first electric keypunch, the Type 011 Electric Keypunch[6], a similar looking device where each key closed an electrical contact that activated a solenoid which punched the hole. Later IBM keypunches included the Type 016 Motor-Driven Electric Duplicating Keypunch (1929)[7], the Type 31 Alphabetical Duplicating Punch (1933) ,and the Type 32 Alphabetical Printing Punch (1933). See Early Card Punch Machines at Columbia University Computing History[8].

Post-WW II IBM Keypunches and verifiers for 80-column cards

IBM 024, 026

IBM 026 keypunch. Note pink program card mounted on the program drum (top center).

The IBM 024 Card Punch and IBM 026 Printing Card Punch (photo) were announced in 1949. They were almost identical, with the exception of the printing mechanism.

The heart of the 024 and 026 keypunches was a set of twelve precision punches, one per card row, each with an actuator of relatively high power. Punch cards were stepped across the punch one column at a time, and the appropriate punches were activated to create the holes, resulting in a distinctive "chunk, chunk" sound as columns were punched.

Metal plate character generator ROM from IBM 026 keypunch

The 026 could print the punched character above each column. There were two popular versions with slightly different character sets. The scientific version printed parentheses, equal sign and plus sign in place of four less frequently used characters in the commercial character set: percent, lozenge, pound, and ampersand. The character was printed using a 5x7 dot matrix array of wires; the device from which it derived the shape of the character was a metal plate, called the "code plate," with space for 1680 pins (35 pins times 48 printable characters). If the dot was not to be printed in a given character, the pin was machined off). By correctly positioning the plate and pressing it against one end of the array of printing wires, only the correct wires were pressed against the ribbon and then the punched card. (This printer mechanism was generally considered by IBM Customer Engineers to be difficult to repair. One of the most common problems was wires breaking in the tightly curved narrow tube between the code plate and the ribbon - extracting the fragments and replacing the bundle of 35 wires was very tedious!) The printing mechanism was prone to be damaged if a user attempted to duplicate "binary" cards with non-standard punch patterns. These could cause the code-plate positioning mechanism to try to shift the plate beyond its intended range of motion, sometimes causing damage. Turning off printing did not actually prevent the damage, as many people assumed, because the code-plate mechanism remained engaged with the punch unit and shifted the code plate. Turning off printing only suppressed pressing the printing pins into the ribbon and card.

Logic consisted of diodes, 25L6 vacuum tubes and relays. The tube circuits used 150VDC, but this voltage was only used to operate the punch-clutch magnet. Most other circuits used 48VDC.

Raymond Loewy, industrial designer of "streamlined" motifs who also designed railway passenger cars of the 1930s and 1940s, did the award winning external design of the 026/024 series for IBM. Their heavy steel construction and rounded corners (photos) indeed echo the industrial Art Deco style.

IBM 056 Card Verifier

Verifier companion to the IBM 024 Card Punch and IBM 026 Printing Card Punch. Physically, the IBM 056 verifier was visually similar to the 026 keypunch except for the presence of a red error lens located in the machine cover lower center. The verifier operator entered the exact same data as the keypunch operator and the verifier machine then checked to see if the punched data were the same. Successfully verified cards had a small notch punched on the right hand edge.

The IBM 056 verifier utilized most of the same mechanical and electrical components as the 024/026 keypunch machines with the exception of the punch unit and print head. The punch unit had sensing pins in place of the punches which were driven through the holes where present, and prevented from full travel where there was no hole present as each card column was stepped by. The holes sensed or not sensed would trip a contact bail when the configuration was other than that entered by the verifier operator. This stopped the forward motion of the card, and presented a red error light on the lower center of the machine cover. The notching mechanism was physically located in the area occupied by the print mechanism on a 026 printing keypunch. It had a solenoid which drove the notching mechanism, and another that selected the top notch punch or end of card punch.

When an operator keying data to be verified encountered an error the operator was given a second and third try to re-enter the data that was supposed to be in the field. If the third try was incorrect an error notch was put on the top of the card over the column with the error and the "OK" punch at the end of the card was not enabled. It should be noted that the data in the card could actually be correct upon occasion as the verifier operator was capable of making errors as well as the keypunch operator. However with three tries, the operator was less likely to repeatedly make the same error. Some verifier operators were able to guess the error on the card created by the previous keypunch operator, defeating the purpose of the verify procedure, and thus some machines were altered to allow only one entry and error notched on the second try.

Cards with error notches were re-punched (using an 024 or 026) usually by "duplicating" to the column in error, then entering the correct data. The "duplicating function was accomplished by feeding the card through the punch station without punching it. At the next station sensing pins read the holes present in the original card and transferred the data to the punching station and into a blank card. Columns with errors were corrected instead of being duplicated. The corrected card was then verified to check the data again and be "OK notched"

IBM 824 and 826 Typewriter Card Punches

The IBM 824 Typewriter Card Punch was an IBM 024 where the 024 keyboard was replaced by an IBM electric typewriter, permitting selected text to be typed and punched.[9] The IBM 826 used an IBM 026 Keypunch.

IBM 029

IBM 029 keypunch

Introduced with System/360 in 1964, the 029 had new character codes for parentheses, equal and plus as well as other new symbols used in the EBCDIC code. The IBM 029 was mechanically similar to the IBM 026 and printed the punched character on the top of the card using the same kind of mechanism as the 026, although it used a larger code plate with 2240 printing-pin sites due to the larger set of characters in EBCDIC.

The 029's logic consisted of wire contact relays on later models and reed relays and diodes on SMS cards for early ones. The more "advanced" reed relays used at first proved to be less reliable than expected, causing IBM to revert to the older-style wire-contact relay-based design. All ran on 48 volts direct current, and did not require vacuum tubes, as were used in the 024/026. A common additional feature made available (at additional cost) was the leading zeros feature (termed "Left-Zero"). This was delivered by an additional set of four SMS cards. The field was programmed for leading zeros using the program card. If it was (say) a six digit field, the operator only had to key in the actual value (for example 73). The feature would then fill the field by punching the leading four zeros, followed by the 73, in effect right justifying the field, thus: 000073.

IBM 059 Card Verifier

The IBM 059 was the Verifier companion to the IBM 029 Card Punch. In design, it differed radically from the earlier 056 verifier, in that it used optical sensing of card holes instead of mechanical sensing pins. This made the 059 much quieter than the 056 (which was often actually louder than the 024 keypunch!). The optical sensors used a single light source, which was distributed to various sites withing the machine via fiber-optic lightpipes. Despite the technology, the basic mode of operation remained essentially the same as with the 056.

Ironically, not all verifier operators appreciated the noise reduction. When used in a room also containing 029 keypunch machines, the verifier operators sometimes missed the auditory feedback provided by the loud "thunk" noise emitted by the older 059. Some were known to compensate by hitting the keys harder, sometimes actually wearing out keyboard parts.

IBM 129 Card Data Recorder

IBM 129 keypunch
IBM 129 keyboard. Card is punched with the letters of the alphabet and the digits 1 through 0.

Introduced with the System/370 in 1971, the IBM 129 was capable of both punching and verifying. A switch on the keyboard unit provided the ability to toggle between the two modes.

The transistorized IBM 129 Card Data Recorder's primary advantage over the 029 was that it featured an electronic 80-column buffer to hold the card image. When using earlier keypunches, a keystroke error required the card to be ejected by pressing the Release and Register keys, the error corrected by pressing the Duplicate key until the wrong column was reached, typing the correct data for the rest of that card, then pressing the Release key and manually removing the bad card from the output card stacker before it was placed in the deck (this required some practice, but quickly became an automatic action that you no longer had to think about). With the 129 a keystroke error could be erased by pressing the Backspace key and re-keyed. The entire 80-column card was punched automatically, as fast as the mechanism could go, when the Release key was pressed.

Logic was in SLT modules.

A secondary advantage of the 129 was that the speed of the keying operation was not limited by punching each column at the time of the keystroke.

The 129 could store six programs in its memory, selectable by a rotary switch; no program card was required.

Program card

IBM 024, 026, and 029 keypunches and their companion verifiers, the 056 and 059, could be programmed to a limited extent using a Program Card[10]. The keypunch or verifier could be programmed to automatically advance to the beginning of each field, default to certain character types within the field, duplicate a field from the previous card, and so on. Program cards were an improvement over the Skip Bar used in some earlier keypunches.[11]

The program was encoded on a punched card and could be prepared on any keypunch (a keypunch would operate even if no program card was in place). The program card was mounted on the program drum, a small metal drum that was as high as a card and whose circumference was equal to the length of the card. A pink program card is visible in the above IBM 026 image behind the window in the upper-center section of the machine. The central cover would be tilted toward the operator, a locking lever released, and the program drum then removed/replaced. The holes in the program card were sensed by an array of starwheels that would cause levers to rise and fall as the holes in the program card passed beneath the starwheels, activating electrical contacts. A switch permitted selection of one of two programs, if the optional Second Program feature was installed, with program 1 in the top six rows [12,11,0,1,2,3] and program 2 in the bottom six rows [4,5,6,7,8,9].

The program card was punched with characters that controlled its function as follows:

Function Program Usage
#1 Char. #2 Char.
Field Definition 12 & 4 4 Punch in every column of a field, except the first (left)
Start Automatic Skip 11 - 5 5 Punch in first (left) column of field(s) to skip
Start Automatic Duplication 0 0 6 6 Punch in first (left) column of field(s) to duplicate
Alphabetic Shift 1 1 7 7 Punch in a column to shift keyboard to Alphabetic mode
Left Zero Print 2 2 8 8 Punch in a column to force printing of leading zeros and signs
Print Suppression 3 3 9 9 Punch in a column to suppress printing


Many programming languages, such as FORTRAN, the RPG programming language or the IBM Assembler, coded operations in specific card columns, such as 1, 10, 16, 36, and 72. The program card for such a setup might be coded as:

1.......10........20........30........40........50........60........70........80
1AAAAAAAA1AAAAA1AAAAAAAAAAAAAAAAAAA1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA &&&&&&&&

In this example, if the keypunch operator typed a few characters at the beginning of the card and then pressed the skip key, the keypunch would tab to column 10. Note: "Field Definition" (12) and "Alphabetic Shift" (1) prints as an A. If Program #2 codes were punched, invalid characters could be generated that the printer did not know how to print, some of which could even damage the printer! Thus it was usually a good idea to turn off printing when duplicating a program card on the 026 or 029.

Program cards could automate certain tasks, such as "gang punching", the insertion of a constant field into each card of a deck of cards. For amusement, program cards could even be set up to play music by gang-punching "noisy" characters (characters represented by many holes, usually special characters) and "quiet" numbers and letters in rhythmic patterns.

IBM Keypunch for 96 column cards

An IBM System/3 96-column punch card.

IBM, in the early 1970s, introduced the System/3 family of low-end business computers which featured a new, smaller sized, punch card format with 96 columns.[12] IBM 5496 Data Recorder, a keypunch machine with print and verify functions, and IBM 5486 Card Sorter were made for these 96-column cards.

Powers, Remington Rand (UNIVAC) Keypunches

Beginning in about 1906 an employee of the Census Bureau, James Powers, developed the Powers Keypunch specific to the census application, with 240 keys.[13][14] In 1911 Powers formed Powers Accounting Machine Company, later merged with others to form Remington Rand. Remington Rand's UNIVAC division made keypunches for their 90-column cards and similar machines for the IBM 80-column card. Their 90-column keypunches used a mechanical system developed by Remington Rand to avoid IBM patent issues (long before the acquisition of Eckert-Mauchly Computer Corporation), that stored the entire card image and punched all holes on the entire card simultaneously.

Remington Rand keypunches included: UNIVAC Card Code Punch Type 306-5, 90 Column Alphabetical (Types 306-2, 306-3), 90 Column Numerical (Types 204-2, 204-3), Portable Electric Punch Type 202, Spot Punch Type 301, and the Automatic Verifying Machine Type 313.[15]

The Type 306-2 provided for verification; the cards were passed through the keypunch a second time and keyed again. The verify-punching of the same cards in the same sequence ... results in the elongation of perforations for correct information. Round perforations indicate incorrect information. Complete and rapid detection of errors is performed mechanically by the Automatic Verifying Machine[16]

References

  1. ^ IBM Archive: Keypunch operators, 1934, Stockholm
  2. ^ Aspray (ed.), W. (1990). Computing before Computers. Iowa State University Press. p. 151. ISBN 0-8138-0047-1. 
  3. ^ Truesdell, Leon E. (1965). The Development of Punch Card Tabulation in the Bureau of the Census 1890-1940. US GPO. p. 44. 
  4. ^ U.S. Patent 682,197
  5. ^ Fierheller, George A. (2006). Do Not Fold, Spindle or Mutilate: The 'Hole' Story of Punched Cards. Stewart Publishing. p. 25. ISBN 1-894183-86-X. http://www.gfierheller.ca/Do_Not_Fold_Web.pdf.  An accessible book of recollections (sometimes with errors), with photographs and descriptions of many unit record machines
  6. ^ IBM Archive: 1923
  7. ^ Fierheller. op. cit.. p. 25. 
  8. ^ Columbia University Computing History: Early Card Punch Machines
  9. ^ Fierheller. op. cit.. p. 55. 
  10. ^ Fierheller. op. cit.. p. 27. 
  11. ^ Fierheller. op. cit.. p. 26. 
  12. ^ IBM Field Engineering Announcement: IBM System/3
  13. ^ Truesdell. op. cit.. p. 119–126. 
  14. ^ Aspray (ed.). op. cit.. p. 124–125. 
  15. ^ Mecham (ed.), Alan D. (1961). Data Processing Equipment Encyclopedia Vol.1 Electromechanical Devices. Gillie Associates. 
  16. ^ Mecham (ed.). op. cit.. p. 197, 357. 

Citations

See also

External links







stock | retire | vm
Why are we here?
All text is available under the terms of the GNU Free Documentation License
This page is cache of Wikipedia. History