Path: utzoo!utgpu!news-server.csri.toronto.edu!mailrus!ncar!ico!ism780c!news
From: news@ism780c.isc.com (News system)
Newsgroups: comp.misc
Subject: Re: Punched Cards
Message-ID: <43535@ism780c.isc.com>
Date: 6 Jun 90 20:38:19 GMT
References: <12546@netcom.UUCP> <220@taumet.COM> <12573@netcom.UUCP> <898@nlsun1.oracle.nl> <1990May29.132631.2253@pdn.paradyne.com> <1990May30.065025.25861@diku.dk> <1990Jun1.211352.4749@unhtel.uucp> <5157@stpstn.UUCP> <124@bohra.cpg.oz> <1208@mplvax.EDU>
Reply-To: marv@ism780.UUCP (Marvin Rubenstein)
Organization: Interactive Systems Corp., Santa Monica CA
Lines: 57

In article <1208@mplvax.EDU> cdl@mplvax.ucsd.edu.UUCP (Carl Lowenstein) writes:
>For some large computer (probably 7030 Stretch) IBM made a 72-bit core
>memory.  At the same time they made a card reader that could read
>72-bit binary data a row at a time across the card to load this
>memory.

An historical correction.  Long before IBM made computers, they made a line
of machines collectivly called "unit record equipment".  The 80 column
Holerith card was the unit record.  With the exception of the key operated
card punch and verifier, all the card readers and punches operated row-wize.
i.e., one complete row of 80 columns was processed in parallel.  When the 704
computer came out, the *pre-existing* unit record equipment was modified for
use as I/O devices.  Since cards were read (or punched) a row at a time it
the computer was built to read 72 card columns at a time into two 36 bit
words.[1]  The data from the card were presented to computer in the order:

     column  1-36 of row 9
     column 37-72 of row 9
     column  1-36 of row 8
     etc

The card reader could, of course, read all 80 columns.  However only 72
columns were presented to the computer.  As I pointed out in a previous
posting, the specific columns to be input was controled by a patch panel in
the card reader.  The use of columns 1-72 was a convention and was not
hardware inforced.  I know if one shop that used columns 3-38 and 43-78.
The reason was that the manager thought that by having four blank columns in
the middle of the card that the cards would be stiffer and would cause fewer
jams.  It turned out to be not true in practice.

A machine made by the Bureau of Standards Called SWAC (South West
Automatic Calculator)[2] was installed at UCLA around 1949.  This machine
was also a 36-bit machine (4-bit opcode, 256 words total!).  It used a
collator as the input device because it was the fastest reader available.
Unfortunately, the collator could not read the 12 row so the Holerith codes
for A through Z could not be read.  So the letters U,V,W,Z,Y,Z were used for
the hex-digits above 9.  I wrote my first program for that machine.

To the best of my recollection, the first computer made by IBM that could
read 80 columns was the 650.  This was a decimal machine.  Alphanumeric
processing (the ability to read and punch alphabetics as well as decimal
digits) was an extra cost option that provided a 48 character set with at
most 40 columns of alphabetics.  The remaining columns were restricted to
digits.

[1] The syncronizing of the card reader with memory transfers had to be
managed by the CPU (I/O channels came out with the 709).  In order that the
programmer be able to write correct code, timings were given in the reference
manual.  The time between 9-left and 9-right was 300 micro-seconds.   The
time between 9-right and 8-left was 8-milliseconds.  The first transfer to
memory had to be issued within 30-milliseconds after issuing the read-card
instruction.

[2] In those days, computer was a job title (I was a computer before I
became a programmer).  A calculator was a machine.

    Marv Rubinstein