Punched Cards for Computer Programs

• CDC 3600
• IBM 701
• IBM 704
• IBM 7040
• IBM 709x
• IPL V
• GE 600
• HP 9820
• HYPO/ASSEM
• Siemens 2002
• Siemens System 300

• 888157 FORTRAN
• J71164 FORTRAN
• CERN FORTRAN/data
• German Aerospace Center
• Regionales Rechenzentrum Hannover
• Hummel Algol FORTRAN
• IBM Educational FORTRAN
• Ohio State University FORTRAN

• IBM 360 RPG
• IBM RPG II

• Hewlett Packard Educational BASIC
• Michigan State University Computer Laboratory
• Ohio State University SCANTRAN

CDC 3600

This card is formatted for the column-binary format used for object code used by the SCOPE operating system on the CDC 3600 computer. The notation (7-66) in the left margin may indicate that the design is from 1966. The CDC 3600 was introduced in 1963 and phased out in the early 1970s. The machine had a 48-bit word, so in CDC's column-binary format, 4 card columns can hold one word.

The printing on the card documents significant details of the object code format. The W field, in rows 11 through 3, contains either a word-count for values from 1 to 21 (octal), or a record type. Cryptic names for the record types are given in small print between rows 12 and 11 (labeled – and + in the right margin). The text between rows 1 and 2 documents the CDC 3600 display code, using card column numbers to give the octal value. This is similar to the way the CDC 6600 character set was documented on the Michigan State University card, but note the different character encoding. Finally, columns 3 and 4 of the card are reserved for a 24-bit checksum. The 21 octal (17 decimal) limit on the word count suggets that columns 73 to 80 of the card are reserved for a sequence number.

An unusual feature of this card is that the digits printed in the punch positions on the card do not give the row numbers 0 to 9, but rather they give the bit weights 1, 2 and 4 of each octal digit in the column binary format.

The punching on this card has little to do with the data format it documents. The /* in columns 1 and 2 marks the start of a PL/1 or C comment, while the 00000060 in columns 73 to 80 is probably a sequence number. The printing at the top of this card was probably from some kind of high-speed interpreter, since IBM's ubiquitous keypunches generally used a dot matrix print mechanism.

The card was printed by IBM.

IBM 701

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.

The card was printed by IBM.

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.

The card was printed by IBM.

IBM 704

The format of this card suggests that it was designed to support programming on the IBM 704 at some point before IBM's symbolic assembly program (SAP) was fully developed. The card contains space for both symbolic and numerical code. Space is reserved for the address and decrement field of each instruction in both symbolic and numeric form, and if the locaiton is a numeric address, presumably the identification field is the corresponding textual label.

The card was printed by IBM.

IBM 7040

The layout of this card is specific to the assembly language of the IBM 704 and its transistorized descendant, the 7040. These computers were the foundation of IBM's successfull family of 36-bit scientific mainframes that included the 709, 7044, 7090 and 7094.

SAP (the Symbolic Assembly Program) was one of the first really well designed assembly languages, and many later assembly langages copied major parts of their syntax and implementation from SAP.

The card was printed by IBM.

IBM 709x

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 7090 and 7094. The assembly language of this family of computers grew from SAP, the Symbolic Assembly Program for the IBM 704, but comparison of this card with the earlier SAP card shows that the language has evolved somewhat from its origins.

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.

The card was printed by Midwest Tab Card.

On a purely card-based system, the object code output of an assembler or compiler could be punched as an object deck. The object code format of the IBM 7094 computer is documented on this card. These machines had 36-bit words, and data was stored in column-binary format, with 3 12-bit columns on the card holding the contents of each word. The loader interpreted the first 2 words (6 columns) on the card to determine how to interpret the remaining 22 words. Columns 73 to 80 of the card are reserved for sequence numbers.

The card was printed by Globe.

IPL V

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.

There is no indication of who printed this card.

GE 600

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 punched on cards.

This card was printed by Jersey Tab Card.

When an assembler processed a program in GE 600 assembly language, the output was in GE 600 object code. As punched on cards, this was a column-binary code, where each 36-bit word was punched in 3 columns of 12 bits, most significant third first, most significant bit at the top. Memory addresses on the GE 600 were 18 bits each.

The printing in the relocatable field of the card (columns 7-15) informs us that the relocatability of each word was determined by 5 bits, suggesting that the assembler and linker allowed 32 distinct relocation bases. From this and the printing in the first word, (columns 1-3) we can guess that that word held the 18-bit load address for this card in the low bits of that word, 5 bits of relocation information for that word, and in the high bits, perhaps the number of words in this block of data.

The checksum (columns 4-6) is there to detect misreading of the data on this card. It could have been as simple as the binary sum of all the words on the card. The relocatable field (columns 7-15) appears to have held the relocation base for each of the data words in the card, with 7 5-bit relocation bases in each of the three words. Finally, there are up to 19 words of load data in the remainder of the card. The shading in each word of load data divides the word into three fields, an 18-bit address in the high bits, a 9-bit opcode in the middle bits, and 9 bits of what GE called the tag in the low bits (really an addressing mode).

This object format allows the cards in an object deck to be loaded in any order, Columns 73-80 of the card are not used. These could be used for a sequence number punched in conventional card code, but this is really not needed because the object format we can infer from the design of the card appears to allow a deck of object cards to be read in any order and still produce the correct result.

This card was printed by the Globe Ticket Company.

HP 9820

The HP 9820 was a programmable desk calculator made by Hewlett Packard and introduced in 1972. This was purely a programmable calculator, with a calculator keyboard. HP offerd numerous peripherals for this calculator, including the 9860A Optical Card Reader.

This card is a column-binary card with space along the top for a user to write their calculator program in symbolic form, as a series of calculator key presses. After writing the code in that form, the programmer would hand translate the keycodes to 7-bit binary and fill in the bubbles on the lower 7 rows of the card.

The card was printed by IBM. In addition to IBM's plate number, the card has HP's part number 9320-2885.

HYPO/ASSEM

This optical mark-sense card for HYPO/ASSEM was apparently developed to support classes in elementary computer architecture taught in a setting where kypunches were expensive and programs were small.

Several hypothetical computer architectures have been named hypo, and this card supports programming one of them. The card can be used either for data, given as a 9-digit signed decimal value, or to assemble an instruction. The fixed-format of the assembly language allows only 2 letter labels, and there appear to be only 17 opcodes. Operands (and comments) are limited to 11 characters.

This card has been coded (or bubbled) SUB 55 with no label.

The card was printed by IBM.

This card was given by K. McQuiggen. Siemens & Halske

Siemens 2002

Siemens & Halske introduced the Siemens 2002 data processing system (datenverarbeitungsanlage) in 1957, and was delivering machines to customers in 1959. Production continued until 1966. This was the first mass produced transistorized computer. It was a decimal machine with 12 decimal digits per word. This "standard 6-word card" is designed to hold 6 words of data plus the 5-decimal-digit address where those words are to be stored in memory.

Documentation for the machine says 12 digits plus sign. Assuming that the data on the card was purely numerical, the layout of this card has no provision for a sign. Given that the usual encoding for numerals was a single punch in rows 0 to 9, the sign could have been encoded with a second punch, for example, a minus sign (a punch in row 11).

Note that the data punched on this card appears to be in the Algol programming language and has no relationship with the fields printed on the card.

The card was printed by Gizeh.

Siemens System 300

Siemens & Halske introduced the Siemens 3003 computer in 1963, 3 years before the company was reorganized as Siemens The Siemens System 300 was a small family of industrial process-control computers spun off from the Siemens 3000 family. All of these machines had a 24-bit word; instructions had an 8-bit opcode and a 24-bit address. The assembly language was called PROSA, which stood for Programming with Symbolic Addresses. The format of this assembly-language card is entirely unremarkable, except for the field labels in German. Despite the German labels on the card, the language name and instruction mnemonics seem to have been English-based.

This card was printed by Hummel.

888157 FORTRAN

These cards are 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 21^st 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.

The second example illustrates the fact that the colored stripe on the card was an optional feature, and although it was usually applied to the top edge of the card, it was sometimes applied elsewhere.

These cards were printed by IBM.

IBM had printing plants around the world that produced the 888157 card for local customers. The example here is from New Zealand. IBM 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, an alternative plate number.

The examples from CDC and Globe are typical.

J71164 FORTRAN

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.

The card was printed by IBM.

Curiously, this version of the J71164 card closely matches the IBM artwork, but it does not use that number.

The card was printed by Globe.

CERN FORTRAN/data

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).

The card was printed by Ferry.

German Aerospace Center

Some time between 1969 and 1989, the Deutch Forschungs-und Versuchsanftalr für Luft-und Raumfahrt (literally, the German Research and Test Institute for Aviation and Space Flight) Rechenzentrum Oberpfaffenhofen (Oberpfaffenhofen computer center), ha this card printed for FORTRAN code.

The design of this card is loosely based on the IBM 888157 but with all explanatory text removed.

The card was printed by Hummel.

Regionales Rechenzentrum Hannover

The Regionales Rechenzentrum Hannover (Hannover Regional Computer Center) had these cards printed, nominally for programs. The bold column-divider lines setting off column 6 and after column 72 specifically support FORTRAN code.

The card was printed by Hummel.

Hummel Algol FORTRAN

Algol was an entirely free-format programming language (it is the ancestor of C and Java from which the formatting conventions of those languages evolved). FORTRAN, on the other hand, had strict rules about the use of card columns 1 to 6 and 73 to 80. The field divisions on this card reflect that and are basically the same as those on the IBM 888157 but without any explanatory text.

This card was printed by Hummel.

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 2051 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.

These cards were complicated to print, requiring a total of three printing plates. Plates 40904 and 40908 were used for the color and black ink on the front, and plate 40906 was used for the back. IBM also printed these cards using blue ink, as demonstrated by this scan sent by someone who used these cards in high school in the early 1970s to program on an IBM 1130.

This card was printed by IBM.

Ohio State University FORTRAN

The differences between this card from the Ohio State University computer center and the IBM 888157 FORTRAN card are subtle, the addition of 3 extra rows of column numbers and small changes in text placement and wording.

The card was printed by BSC.

IBM 360 RPG

IBM's RPG (Report Program Generator) is an unusual language. It was designed to allow a fast transition from plugboard-programmed tabulating machines to computers, allowing workers who had deveoped careers programming those machines to migrate to programming computers. RPG was developed in the late 1950s, by the time it was ported to the IBM 360 in the 1960s, it had matured somewhat, but it was still a fixed-format language with distinct (and different) data formats for each of its statement types. The examples above illustrate a few of these.

These cards were printed by BSC.

IBM RPG II

When IBM announced the System/3 in 1969, they intended that RPG be the primary programming language for the system and they introduced a new 96 (actually 128) column punched card format. RPG II was supported in this new punched-card format, using only 80 columns of the card.

This card was printed by IBM Switzerland.

This card was given by Yves Bolognini.

Hewlett Packard Educational BASIC

As with the IBM Educational FORTRAN card, these BASIC cards are 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 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 public school systems could afford.

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 sometimes spoke of "bubbling in" thir code. I first heard this usage in 2002 from Dr. Glen B. Cook.

These cards were printed by IBM and the Globe Ticket Company. The fonts differ, and the plate numbers are specific to the printer, but both are also marked with HP's part number 9320-2051.

Michigan State University Computer Laboratory 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. The material in column 1 and 2 of the card has evolved somewhat from the column-binary format of the CDC 3600.

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. Curiously, the octal character given here differ from those on the CDC 3600 card. 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.

This card was printed by Hackett

Ohio State University SCANTRAN

It is difficult to find any information about the SCANTRAN programming language used at the Ohio State University's Numerical Computation Laboratory aside from what can be inferred from this card. Column 1 must have had a special purpose, perhaps distinguishing statement types. The label field is much longer than allowed by FORTRAN, but as on FORTRAN cards, columns 73 and up are reserved for such things as sequence numbers.

The card was printed by BSC.