Punched Cards for Computer Programs

Part of the Punched Card Collection
by Douglas W. Jones
THE UNIVERSITY OF IOWA Department of Computer Science

Click on any image for a high-resolution version. All images were scanned at 600 dpi and edited to remove streaks caused by bad (or dust occluded) pixels in the scanner. Note that, prior to 1978, all material printed in the US without a copyright notice was automatically in the public domain; this also applies to most material printed before 1989 without a notice. Beware, however, that institutional logos are typically protected by trademark law and cannot be used in a manner that conflicts with the trademark owner's rights.

IBM 701

 [IBM 701 program card]

This card was probably for the IBM 701 computer; this was the very first general purpose digital computer sold by IBM. It used vacuum tube technology, including Williams tubes for main memory (sometimes described as vacuum tube DRAM). There is a remote possibility that it was for the IBM Card Programmable Calculator, a programmmable calculating machine made from off-the-shelf punched-card equipment assembled into a rudimentary computer. However, this card does not match the CPC instruction card shown on page 234 of Bryan Randell's book, The Origins of Digita Computers.

This card has fields for both the symbolic and executable forms of the instruction, suggesting that it might have been used with some kind of assembler that could punch the object code directly onto the cards from which it read the source code.

 [IBM 701 row binary card]

This card is a row-binary card for the IBM 701 computer. This machine had a 36 bit word, with two 18-bit instructions packed per word. The card reader for the 701 read cards one row at a time, delivering the results as two words of data holding 72 bits of data, with a plugboard on the card reader that deetermined which 72 out of the 80 colums on the card were being read.

The above hardware constraints led naturally to the row-binary data format, with two words, 72 bits of data per row of the card. A bootstrap loader that read row binary cards into memory was one of the simplest ways to load code into the machine, so row-binary cards were in common use for holding memory images of programs. This card is clearly designed for use with a plugboard that ignores columns 1 to 8. Users could use those columns for sequence numbers, so that running the cards through a card sorter would put them in the right order if the deck of cards was accidentally shuffled.

IBM 709x

 [IBM 709x assembly language card]

The layout of this card is specific to the assembly language of the IBM 709x series of machines, a family that grew from the vacuum tube IBM 704 and 709 to include the transistorized 7040, 7044, 7090 and 7094. These 36-bit computers dominated the scientific computing market between 1954 and 1964 and remained important through the 1960s.

The table in the sequence number field (columns 73-80) is intended as an aid to users intent on decoding the punched patterns, although it is one of the less useful self-interpreting card formats in this collection.


 [Carnegie Tech IPL V punched card]

This card, from Carnegie Tech, is formatted for IPL V, the fifth of a series of Information Processing Languages developed at RAND Corporation and at Carnegie Tech. All of these were essentially assembly languages, a fact that is quite evident from the layout of this card, but the language controlled a virtual machine that operated on linked list structures. These languages were important in the early development of the field of artificial intelligence, but were completely supplanted by LISP.

GE 600 Self Interpreting Card

 [Bell Labs punched card]

This card, probably designed in October 1965 (judging by the notation "10-65" printed on the left edge), was printed for use with the GE 600 series computers at Bell Labs. These included a GE 635 at the Whippany lab and two GE 645 systems at Murray Hill, one in the computer center, and one used for the Multics project, a joint venture between Bell Labs, MIT and GE. All but the latter ran GECOS (the General Electric Computer Operating System).

This card is formatted for the GE 600 assembly language, and it has the nice feature that columns 50 to 72 are printed with complete documentation of the GE 600 6-bit BCD character set, as it was punched on cards.

888157 FORTRAN

 [IBM 888157 FORTRAN card]

This card is printed with all of the fields that matter to the FORTRAN programming language; this card is the standard IBM 888157 FORTRAN card. IBM introduced the FORTRAN language on the IBM 804 in 1957, and the FORTRAN Programmer's Reference Manual from late 1956 includes examples presented on a coding form that closely resembles the layout of this card. By the mid 1960s, FORTRAN compilers had been developed for computers ranging from the 60-bit CDC 6600 to the 12-bit DEC PDP-8, and Fortran (no longer all upper case) remains in use in the 21st century.

In many organizations, programmers were expected to write their programs on coding forms that were then sent to keypunch clerks, usually women, who punched the code from the forms onto cards. IBM had a coding form specifically designed for use with the 888157 card. See this high-resolution PDF.

 [IBM 888157 FORTRAN card from New Zealand]  [CDC 888157 FORTRAN card]
 [Globe 888157 FORTRAN card]

IBM had printing plants around the world that produced the 888157 card for local customers. The example here is from New Zealand. Other card vendors also created copies of the 888157 that are distinguished only by very small typographical differences and the vendor's name and, sometimes, alternative plate number. The examples from CDC and Globe are typical.


 [IBM J71164 FORTRAN card]
 [Globe 42225 FORTRAN card]

While the 888157 FORTRAN card satisfied the needs of most FORTRAN programmers, it had one shortcoming. If the card was run through an interpreter to print the contents of the card on its face, there was no indication of the column numbers of the printed text. Keypunches always printed on the very top edge precisely aligned with the punched columns, but high speed punches did not print, so if you wanted to be able to read the cards, you had to run the cards through an interpreter. IBM's interpreters used a wider print spacing, so they came up with the J71164 card that indicated the fields and card column numbers where the interpreter would print.

Curiously, Globe's version of this card closely matches the IBM artwork, but it does not use the same number.


 [CERN punched card]

This card is printed with all of the fields that matter to the FORTRAN programming language, plus rulings every ten columns suggesting a generic tabular data layout. Column 1 of this particular example is prepunched with an end-of-file mark for the CDC 6600 computer system (a 6-7-8-9 multipunch). A high resolution scan is available.

IBM Educational FORTRAN


Keypunches were expensive, so some schools sought inexpensive ways to teach FORTRAN using IBM's optical mark-sense technology, allowing cards to be marked with a number-2 soft-lead pencil. The IBM 40904/40908 card shown here uses an eccentric character coding totally unlike that used by keypunches, along with a very limited set of statement numbers and single marks for the keywords that begin many FORTRAN statements. A high resolution of scan is available, along with a a scan of the flip side of the card. (Thanks to an Internet correspondent for the scans of this card, a card used in the early 1970s by high-school students to program an IBM 1130.)

Hewlett Packard Educational BASIC


As with the above card, this BASIC card is also intended to be marked with a number-2 soft-lead pencil, and then read on an optical mark reader (possibly made for HP by Chatsworth). In the early 1970's, Hewlett Packard was a leader in providing computers to public school systems interested in teaching computer programming. While Hewlett Packard emphasized use of timesharing systems, the provisions they made for batch operation using optical mark readers lowered the price per student to something that many public school systems could afford. A high resolution of scan is available,

The black index marks along the bottom indicate the columns of the card to the reader, and the statement type was coded using a special 1 out of 22 code. The standard optical mark reader format for use on punched card stock allowed only 40 columns, but this HP format sacrifices one column in the statement field and two more in the comment field.

With conventional punched-cards, programmers spoke of punching their programs onto cards using a keypunch. Users of mark-sense cards have come up with interesting terminology to describe the analogous act of programming on such cards. One of the more interesting descriptive phrases is "we bubbled in our programs on cards", referring to filling the oval bubbles that are commonly used as marking targets on mark-sense forms. I first heard this usage in 2002 from Dr. Glen B. Cook.

Michigan State University Computer Laboratory card

 [ Michigan State University punched card ]

This card is intended for column binary data, if one judges by the printing in columns 1, 2, 79 and 80. Column binary cards store 12 bits of binary data in each column. The material in the center of the card suggests that the card might have been for a CDC 6500 computer. That machine had a 60 bit word, so each word of data for that machine would occupy 5 columns.

Most of the space on this card is used as a pocket reference card for programmers, giving the octal codes for the 64 characters of the CDC 6500 display code, the octal codes for ASCII characters and other material programmers might find useful. It is highly likely that most of the cards printed in this style were used by students in programming courses for the source code of their programming assignments. A high resolution image is available.