Zebra Stripe Card

How Data is generally stored on an 80 column punch card

Before we can explore the IBM 1130 Binary Card (aka Zebra Stripe Card), we must first understand the Standard Punch Card.

Standard Punch Cards have 80 vertical columns and 12 horizontal rows for rectangular punches. This means that each column on the card has 12 punch-hole positions.

Card Rows of a Generic Card

Why 12 rows? Ten rows would suffice for numeric data.. in fact, the original punch card had ten rows of round holes, and way fewer (27?) columns.

In addition to rows '0-9', there are two zone punches that are used to in combination with 0-9 to represent letters and some special characters. The zone punches are in the two rows above the 0-row, called the 11-row & 12-row. The Hollerith coding for alphanumeric punches is shown on this card (also from my collection).

Alphanumeric characters punched on a Blue-Stripe Manilla 5081 card

Note in the above card photo, the 11 and 12 rows have no ink printed showing them. These rows exist — you can see the punches!

The printing across the top was done by the keypunch machine, using a primitive dot matrix print head. See references at the end.

Hollerith Codes were named for Herman Hollerith, who was responsible for the 1890 census. See references at the end.

Card Columns of a Generic Card

All 80 columns can be used for data. However, many times the order of a deck of cards is critical, such as a deck of cards holding a thousand statements of a computer program — so columns 73 through 80 were often reserved for Card Identification and Sequence Numbering, leaving columns 1-72 for data or the body of a computer program.

Alternatively, a data deck might use columns 1-8 for a student or employee number, and use 9-80 for data. These same applications often needed more than one card or kind of card per person. So, for example, column 80 might contain a card type which indicated what format applied to the card!

In general, the card is simply a 'medium' that can be used for input. A card passed through a card reader, and the card image, 80 12-bit results, were sent to the computer for processing. A paper hole or lack of a hole was all that mattered.

What is special about the Zebra Stripe Card?

This card format was designed to hold binary data. What does that mean?! Literally bit for bit, punched or not can represent 960 bits. But only the first 72 columns held data, yielding 864 bits.

IBM 1130 Binary Card uses columns 1-72, and all 12 rows.

(72 x 12) bits are mapped into (54 x 16) bits in an orderly fashion.

Punches are grouped into 4-column 12-row Stripes.
Each Stripe has 4x12 = 48 bits.
The 48 bits can be arranged into 3 16-bit (binary) numbers.
Each card has 18 Stripes, holding 18x3 = 54 16-bit (binary) numbers.

The diagram below, in 'How Data is Read from the Card', shows this mapping.

It's a Format!

The printed pattern visually shows the format specification, i.e., how data will be grouped on the paper, so that programs can retrieve and process it accordingly.

So the main thing here is the specification, not the printed pattern.

You could say there was no (good) reason for having anything printed on these cards. Maybe guys pored over the cards looking for who knows what?

On the practical side, since the ticket stock was printed accurately, the operator could sometimes tell when the puncher might need adjustment, simply by fanning through the punched deck of cards.

If you weren't concerned with these things, you could use blank or 'scrap' cards left over from some other job.

How Data is Read from the Card

Card reader (hardware) moved the card in sync with a timing wheel past a read station consisting 12 photo-electric sensors. This generated 80 12-bit samples, which were stored directly into the computer's memory. The 'buffer' could then be processed by a routine that shuffled the bit samples into 16-bit words.

Zebra Stripe Card (cropped to columns 25-60)

The above image shows most of the full height of the card, cropped to a square. The image below shows the columns rearranged.

A 4-column 12-row card Stripe can be rearranged into three 16-bit Words.

This may seem daunting, but in assembly language it becomes a lovely dance of shifting registers and logical operations.

Exercise

Can you write an Algorithm for converting the 'card image' into an array of integers? Imagine a little machine with the column data in memory (MEM) at 72 locations, and a 16-bit accumulator (ACC) with a 16-bit extension (EXT), and these operations.

Load ACC from MEM
Shift ACC L or R n bits
Rotate ACC and EXT
Logical AND ACC & MEM
Logical OR AVCC | MEM
Store ACC into MEM
Loop

You'd probably need to loop 18 times, so assume there is an index register that you can load and decrement to zero.

Can we find this routine listed in Assembly language on IBM MicroFiche? It appears that I had an assembly language routine for this — RDOBJ, but I only the have the assembled object deck! LOL

What were these cards used for?

The cards were used to store compiled objects for later use (to avoid having to recompile a large program). They were also used to distribute and update system software. Back in the day (late 60's, 1970's) we'd occasionally get a batch of cards from IBM containing updates to the IBM Disk Monitor System. This varied from say 100 cards to 1000 or more. I don't have any record of those updates.

I think Paper Tape was also used to distribute updates. Not everyone had an 8 channel paper tape reader, so I'd say cards were the main medium for updates.

Curious Observation about Information

This section is just a thought for our amusement here in 2022.

Fifty-four 16-bit Words would be equivalent to 108 8-bit Bytes. This is interesting because that's more character data than if we used all 80 columns for single letters! Here is a comparison of 72 and 108

72 characters:

  abcdefghijklmnopqr
  abcdefghijklmnopqr
  abcdefghijklmnopqr
  abcdefghijklmnopqr

108 characters:

  abcdefghijklmnopqrstuvwxyzz
  abcdefghijklmnopqrstuvwxyzz
  abcdefghijklmnopqrstuvwxyzz
  abcdefghijklmnopqrstuvwxy

How is this possible? Modern ASCII uses 7 bits to define 127 unique character codes or 8 bits to define 255. This means we only need ⅔ of a column for one character, and that works out to 108 characters per card. Note that this is a comparison between old and new character codes, and so this was not a consideration back in time. See the section headed 'What were these cards used for?' for the real story..

QR Code example

We used a QR code to represent the URL for this page!

We suggest learning about QR codes -- How is the information encoded? How does a QR pattern get recognized?

IBM 1130 Binary Card