Columbia University Computing History

The IBM 026 Key Punch

 

The IBM 026 Printing Card Punch (left), introduced in July 1949. A nonprinting 024 model (above, CLICK HERE for another view) was also available. These were superseded starting about 1964 by the 029 punch which was required for the IBM 360 because it used the EBCDIC character set rather than earlier BCD variants of the 7000-series (026s remained in use in non-IBM shops -- e.g. CDC -- well into the 1970s). The card diagram below shows the 026 character set, including the mythical "lozenge" character (12-4-8):


CLICK to magnify; Compare with 029 card

Note that the punched-card code is duodecimal (base 12), and is therefore different from the computer's internal code, which was usually decimal or binary. The character set -- i.e. the repertoire of characters, regardless of how they are coded -- in this case is Binary Coded Decimal Interchange Code, or BCDIC, a 48-character code. BCDIC and its card code descend directly from the original design of Herman Hollerith. As you can see, the symbols are designed primarily for accounting and statistics, and are not sufficient for programming languages such as Fortran. BCDIC includes the 26 uppercase Roman letters, the 10 digits 0-9, and 11 special characters: Ampersand (&), Period (.), Lozenge (), Minus sign (-), Dollar sign ($), Asterisk (*), Slash (/), Comma (,), Percent sign (%), Number sign (#), and Commercial At Sign (@). Later versions of BCDIC (and 026 key punch models, interpreters, etc) allowed for programming by replacing some of the special characters by Plus Sign, Parentheses, and so on.

Blank cards are fed into the punching station from the input hopper (right) one by one. The current card faces the operator on the right, just above the keyboard; the previous card is in the center. When a card is completely punched, the previous one moves to the left position and then flips up into the output stacker (left), the current card becomes the previous card, and a new card is fed from the input hopper into the current position. The input and output hoppers hold 500 cards each.

The operator presses keys to punch holes in the cards. Each "data key" on the main keypad -- letter (uppercase only), digit, space bar, punctuation -- moves the cards one column to the left. Data characters were printed across the top of the card on the 026 (if the ribbon was not dry) in their column positions.


CLICK to magnify.

Control switches included NUM, SKIP, and DUP. Since there were no digit keys, the NUM key shifted the right-hand letter keys to be digits. SKIP was like Tab, and DUP would duplicate whatever was in the current position of the previous card for as long as the key was held down. There was also a way to "overstrike" in a single column, using the Multipunch (MULT PCH) key. Loren Wilton (of Burroughs/Unisys, who worked with early IBM gear while in college) recalls (31 Dec 2003):

The Backspace key was only useful in the rare case that you spaced past a column that you needed to punch; you could backspace and restrike the column. Of course if the column was mispunched, you swore under your breath, hit the release key to feed the current card, duped up to the error using the next blank card, then continued punching from that point. When you released this card (or it auto-released after column 80) you quickly grabbed the mis-punched card out of the flipper as it was being stacked and threw it in the trashcan, which was invariably on the left side of the keypunch for this purpose.

When starting with an empty keypunch, you loaded a handful of cards in the feed hopper and hit "feed" twice to load the first card of the deck into the punch position.

Not shown on your keyboard layout were the four (I think) switches on the top of the keyboard. One of these was the "auto-feed" switch, which was usually on. With the auto-feed switch on, as you finished each card, either using the "Rel" key (#34) or after punching column 80, the current card would move to the read station and a new blank card would feed into the punch station. With auto-feed off a new card would not feed into the punch station until you hit the feed key after the release key.

I seem to recall that there was also a "program on/off" key on the top of the keyboard, which would enable or disable the program drum if it was installed and the reading fingers were down (which was done with a small lever at the bottom of the drum itself). I don't recall what the other switches did anymore, I don't think I ever found a use for them. Suppose I could try to find my 026 manual, but it doesn't seem worth the effort after all these years.

It should perhaps be noted that there was also a small slot where you could manually feed a single card into the punch station from the front of the machine, rather than using the feed hopper. This was useful to correct a single card, or to duplicate a card that would no longer feed in the 1402 (reader/punch for the IBM 1401). This was typically the first card of the loader deck or job deck, which became "fuzzy" on the top edge after repeated use, and would not be grabbed correctly by the feed claws on the 1402.

You could use it by turning Feed off, hitting Rel twice to clear the cards from the punch and read stations, dropping the two blank cards in the stacker on the top of the machine, inserting the card to be duplicated in the slot, hitting Reg (#37) to register it, hitting Rel to release it from the punch station to the read station, Feed to feed a blank card from the feed hopper, and then duplicating the card, finally hitting Rel twice to feed out both cards to the stacker. Sounds complicated, but when you were doing it you did it automatically without even thinking about it. All this was also applicable to the 029 of course.

  The machine could be programmed to some extent with a program card, an ordinary punch card wrapped around the program drum housed in the compartment at the top center. The drum turned in synchrony with the card-column position and was read by little toothed wheels. Instructions included DUP, SKIP, and so on, and were entered in the desired column positions using special codes. Thus portions of the preceding card could be duplicated automatically; or when the card reached a certain column, it could skip automatically to a specified "tab stop"; and so on. An expert key punch operator in data-entry applications, with the aid of a well-designed program card, could punch 200 cards per hour. There was a huge market for key punch operators in the 1950s and 60s.

On the keyboard unit, above the keys, were three Functional Control Switches (thanks to Toivo from Ottawa, who was an IBM Senior Customer Engineer 1966-73, for reminding me): Print On/Off, Program/On/Off, and Autofeed ("If the Autofeed was kept up with one finger, one could empty the whole feed hopper of IBM punchcards").

Another device, the 056 Verifier looked and worked like the 026 card punch, but instead of punching holes in the card, it verified that the holes that were already in the card matched the operator's keystrokes. Any column that did not match received a notch at the top of the card. If the card was OK, a notch was cut on the right edge. Columbia didn't have any verifiers, but they were used in installations such as banks and the military, where transcription errors could have more serious consequences than points off your homework. To minimize systematic errors, a card deck would be punched by one operator and verified by a second. Another error-control technique was to punch sequence numbers in columns 72-80. This could be done automatically by various EAM equipment, or by host-driven punches, and allowed dropped decks to be sorted (in a sorter).

Still another variation was the IBM 526 Printing Summary Punch. This was virtually identical in appearance and function to the 026, put it could be connected to the IBM 402, 403, or 419 accounting machine as an output device. In other words, cards could be punched by hand, from the keyboard, like on an 026, or by another machine. Unlike the 026 (pictured at top), this one has a control panel to allow detailed specification of how input from the accounting machine should be punched. For more about summary punching, CLICK HERE.

Key punch noise was quite horrendous, especially when many punches were operated in a confined space simultaneously, as they were in Columbia's key punch areas, where usually the program drums were broken and the ribbons dry. The 026 was followed by the 029 in the mid 1960s; Columbia went through both generations, as well as earlier ones.


Also see:

References:

  1. IBM 24 Card Punch / IBM 26 Printing Card Punch: Reference Manual, International Business Machines, Endicott NY, Form A24-0520-1 (1949).
  2. IBM 56 Card Verifier: Reference Manual, International Business Machines, Endicott NY, Form A24-1018-1 (Copyright 1950, 1951, 1954, 1957, 1958, 1962).
  3. Mackenzie, Charles E., Coded Character Sets, History and Development, Addison-Wesley (1980).
  4. Punching Data on Cards, film, University of Queensland Chemistry Department (1969). Demonstrates operation of IBM 029 and (briefly) 026 card punches.

Last Update: Wed Nov 20 09:02:36 2013


Frank da Cruz / fdc@columbia.edu / Columbia University Computing History