paul@unhtel.uucp (Paul S. Sawyer) (06/02/90)
In article <1990May30.065025.25861@diku.dk> jensting@skinfaxe.diku.dk (Jens Tingleff) writes: >reggie@dinsdale.paradyne.com (George W. Leach) writes: >>>But who uses punched cards these days? > >> I do! For book markers :-) >... >Actually, the use of magnetic media takes away a lot of the mechanical >charm of computer background storage. Paper tape and punched cards are more >*FUN*. Think of the endless fun you can have putting together a stack of cards >dropped on the floor.... And the first big program I wrote AFTER the one I dropped and hand-sorted had sequence numbers... (mid 70's) Pre-computer data processing with cards was fascinating. It seemed easier (to me) to grasp the concepts behind data files, records, fields, sorting, merging, etc. when you could see the cards. My first class in DP used cards, sorters, punches, verifiers, and the brain of it all, the Electronic Accounting Machine! (IBM 407 and 409, if I remember) (mid 60's) These machines were programmed using patch boards and wires, and could generate cross totals, group totals, grand totals, skip to certain places on the form (channel 1 is what we now call form feed or top-of-form) etc. The desired report was generated from one file (stack of cards) which had different types of records (cards) merged from other files (customer master, transaction, etc.) in the proper order. All based on max. 80 column records. There was a common set of fields on all the cards related to a report or process, so dropped cards could be resorted.... -- Paul S. Sawyer uunet!unh!unhtel!paul paul@unhtel.UUCP UNH Telecommunications attmail!psawyer p_sawyer@UNHH.BITNET Durham, NH 03824-3523 VOX: +1 603 862 3262 FAX: +1 603 862 2030
lerman@stpstn.UUCP (Ken Lerman) (06/04/90)
In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 column card with 73-80 used for (an optional) sequence number. As I recall, the 7090 class machine had a 36 bit word and could thus contain 24 words of data (in binary mode) plus have an 8 character sequence number. Does anyone out there know if these two "facts" are related? Ken
ejp@bohra.cpg.oz (Esmond Pitt) (06/05/90)
In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: >In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 >column card with 73-80 used for (an optional) sequence number. So was COBOL, assembler, ... It was a Hollerith card convention. >As I recall, the 7090 class machine had a 36 bit word and could thus >contain 24 words of data (in binary mode) plus have an 8 character >sequence number. I do not understand this statement. Anyway, as the 36 bits were divided into 6 6-bit (EBCDIC) characters, the arithmetic is really 72 columns = 12 words, 8 columns = 1.3333... words . >Does anyone out there know if these two "facts" are related? Doesn't sound like it. -- Esmond Pitt, Computer Power Group ejp@bohra.cpg.oz D
jt@aix.aix.kingston.ibm.com (Julian Thomas) (06/05/90)
The online card readers for the 70x binary family (704-709 [tube machines!] preceded the 7090/7094) read 72 columns a row at a time into 2 words, so that columns 73-80 were unreadable by the machine. (This restriction was relaxed by the offline card-to-tape conversion units). The program read the 9 row first, and as the card advanced (9 edge first, of course!) through the reading station, it read the subsequent rows. Load decks intended for direct input were in what was called "row binary". For reasons that probably made sense then (before the days of megabit rams) the offline card->tape units insisted on reading binary cards in "column binary format" where 3 consecutive columns went into a word once read into the machine. -- -*-*-*-*-*-*-*-*-* JTdidit - from Julian Thomas uunet.uu.net!ibmps2!aix!jt Inside IBM: jt@giverny.aix.kingston.ibm.com or JT at PLKSE Snailmail: 83AA/581 IBM DSD Kingston Compuserve: 72355,20 MCIMAIL: 173-6393
cdl@mplvax.EDU (Carl Lowenstein) (06/05/90)
In article <124@bohra.cpg.oz> ejp@bohra.cpg.oz.au (Esmond Pitt) writes: >In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: >>In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 >>column card with 73-80 used for (an optional) sequence number. > >So was COBOL, assembler, ... It was a Hollerith card convention. > Oh, well, try to dredge up facts rather than conjectures. 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. As a follow-on, the 72-bit memory got used in 36-bit computers, thus giving automatic 1-word memory readahead. And the 72-column card reader went along for the ride. Since it was probably the fastest card reader going at the time, it was also used for reading in column-oriented data like Hollerith card codes (characters), despite the software penalty of having to transpose the matrix of bits (corner-turning). But the last 8 columns never made it into the computer because there wasn't any hardware to read them. To make lemonade out of this particular lemon, the convention of columns 73-80 for sequence numbers was devised. -- carl lowenstein marine physical lab u.c. san diego {decvax|ucbvax} !ucsd!mplvax!cdl cdl@mpl.ucsd.edu clowenstein@ucsd.edu
news@ism780c.isc.com (News system) (06/06/90)
In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: >In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 >column card with 73-80 used for (an optional) sequence number. > >As I recall, the 7090 class machine had a 36 bit word and could thus >contain 24 words of data (in binary mode) plus have an 8 character >sequence number. > >Does anyone out there know if these two "facts" are related? Yes, the two are very closely related. FORTRAN was originally designed as an IBM/704 programming language. The 704 (and 709, 7090,7094) had a card reader that could read only 72 columns of a Holerth card. The particular columns to be read was controled by a patch panel located in the card reader. The common convention was to read the first 72 columns. So this was the way FORTRAN was designed. BTW: The FORTRAN printing convention of FORMAT(1H1) to do new page (as well as other column one controls) also arose from a hardware requirement. There was a machine called a 716 (I think the number is correct) that was a hard wired tape to printer machine. It used the first character of the record for forms control. Marv Rubinstein
buckland@cheddar.ucs.ubc.ca (Tony Buckland) (06/06/90)
In article <124@bohra.cpg.oz> ejp@bohra.cpg.oz.au (Esmond Pitt) writes: >In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: > >>As I recall, the 7090 class machine had a 36 bit word and could thus >>contain 24 words of data (in binary mode) plus have an 8 character >>sequence number. > >I do not understand this statement. > In the usual character mode, one card column represents one character. In binary mode, each possible hole position represents one bit, for twelve bits per column. Thus a 36-bit word can be represented in 3 columns. 24 words, * 3 columns per word, = 72 columns. Deep in my memory is a recollection that some IBM machines, possibly 7090s, had an instruction that would load 24 words in binary mode from one card into memory and then begin execution with the first word. This was the first step in bootstrapping (the 24-word program said "load a whole bunch more stuff and execute *that*").
lerman@stpstn.UUCP (Ken Lerman) (06/06/90)
In article <124@bohra.cpg.oz> ejp@bohra.cpg.oz.au (Esmond Pitt) writes: >In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: >>In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 >>column card with 73-80 used for (an optional) sequence number. > >So was COBOL, assembler, ... It was a Hollerith card convention. > >>As I recall, the 7090 class machine had a 36 bit word and could thus >>contain 24 words of data (in binary mode) plus have an 8 character >>sequence number. > >I do not understand this statement. > >Anyway, as the 36 bits were divided into 6 6-bit (EBCDIC) characters, >the arithmetic is really 72 columns = 12 words, 8 columns = 1.3333... words . > >>Does anyone out there know if these two "facts" are related? > >Doesn't sound like it. > > >-- >Esmond Pitt, Computer Power Group >ejp@bohra.cpg.oz >D Nope, EBCDIC hadn't even been invented then. But on the machines I used (if I recall correctly), the cards were read "broadside". This was called the twelve edge. _____________________________________________________________________ / | | | | | | | | | | | | | | | | | | | ---------------------------------------------------------------------- And this the nine edge. Typically the input hopper on a card reader would be labeled with the direction: "12 edge face down" Then, you could fit 2 36 bit words across the card -- the first in columns 1-36 and the second in columns 37-72. Since there are twelve rows (called 12, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 in sequence) that means that you could fit 2 x 12 = 24 words on a card. Another set of names for the 12 and 11 rows was plus and minus, respectively, because that is now you indicated the sign of a number (at least on the IBM 650 that I used). More that you really wanted to know, I'm sure. Sorry about that. Ken
cik@l.cc.purdue.edu (Herman Rubin) (06/06/90)
In article <1208@mplvax.EDU>, cdl@mplvax.EDU (Carl Lowenstein) writes: > In article <124@bohra.cpg.oz> ejp@bohra.cpg.oz.au (Esmond Pitt) writes: < >In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: < >>In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 < >>column card with 73-80 used for (an optional) sequence number. < > < >So was COBOL, assembler, ... It was a Hollerith card convention. < > > > Oh, well, try to dredge up facts rather than conjectures. > > 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. A little background: punched cards were read initially a row at a time, from the bottom (9) row up. When a card was sent to a computer, it was the left side of the 9's row, the right side, etc. Fortran was designed for the IBM 704, which was a 36-bit machine. The card-reading hardware for this machine could not read the right 8 columns of the card. -- Herman Rubin, Dept. of Statistics, Purdue Univ., West Lafayette IN47907 Phone: (317)494-6054 hrubin@l.cc.purdue.edu (Internet, bitnet) {purdue,pur-ee}!l.cc!cik(UUCP)
chuckh@apex.UUCP (Chuck Huffington) (06/07/90)
In article <5157@stpstn.UUCP> lerman@stpstn.UUCP (Ken Lerman) writes: |In the "Good Old Days", Fortran was punched in columns 1-72 of the 80 |column card with 73-80 used for (an optional) sequence number. | |As I recall, the 7090 class machine had a 36 bit word and could thus |contain 24 words of data (in binary mode) plus have an 8 character |sequence number. | |Does anyone out there know if these two "facts" are related? | >Ken Yes, they are related. In the old IBM 709, which was the vacuum tube (valve) version of the 7090 the system card reader read only columns 1-72. Thus fortran (which was designed to run in this family of machines) didn't use columns 73-80. A card was read in 24 36 bit words. As I recall the first word got the left half of the 12 row, followed by the right half 12 row. and so on down to the 24th word getting the right half of the 9 row. I believe that the earlier machines (like the 704) used the same scheme but I never used anything older than the 709 so I can't be sure. As I recall a lot of cards also came in thru an off line card to tape machine. They read the whole card and wrote it in BCD on 7 track tapes. The 709 I used had an interesting locally built kludge on it. There was a UNIVAC 1004 accounting machine (board programmed, sort of like an IBM 40X, but a lot fancier and faster). It was connected to the 709 channel and looked to the system like a tape drive. If you read a record you got the next card. If you wrote a record it printed a line. Chuck Huffington uunet!apex!chuckh
toma@tekgvs.LABS.TEK.COM (Tom Almy) (06/07/90)
In article <2219@l.cc.purdue.edu> cik@l.cc.purdue.edu (Herman Rubin) writes: > >A little background: punched cards were read initially a row at a time, >from the bottom (9) row up. When a card was sent to a computer, it was >the left side of the 9's row, the right side, etc. > >Fortran was designed for the IBM 704, which was a 36-bit machine. The >card-reading hardware for this machine could not read the right 8 columns >of the card. The IBM 407 Accounting Machine (essentually a printing adding machine for punched cards :-) read in the 12 side first. The accumulators were wheel like devices, that worked like odometers. If you were adding a field to an accumulator (as deturmined by a plug board program) the start of the card (actually when it reached the 0 row) would start the wheel rotating and as soon as a hole was reached the wheel would stop. If it made it all the way to the nine row then a 9 would be added, for instance. You could consider this to be a digit parallel design where the digit value is encoded by pulse length. You could also consider the 407 to be a multiprocessing system! As far as I know, all the unit record equipment (except for the sorter) read and punched cards in the same manner.
news@ism780c.isc.com (News system) (06/07/90)
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
news@ism780c.isc.com (News system) (06/07/90)
In article <8119@ubc-cs.UUCP> buckland@cheddar.ucs.ubc.ca (Tony Buckland) writes: > Deep in my memory is a recollection > that some IBM machines, possibly 7090s, had an instruction > that would load 24 words in binary mode from one card into > memory and then begin execution with the first word. This was > the first step in bootstrapping (the 24-word program said > "load a whole bunch more stuff and execute *that*"). The 709 (7090 and 7094) all had a LOAD-CARD button on the operator's console. This button started the I/O channel and caused 3 words to be read into locations 0, 1 and 2. As soon as these three words were into memory (and before the fourth word arrived), the word a location 0 was sent to the channel as an I/O command and the CPU started executing at location 1. For the normal boot card, the first word directed the channel to read the remaining 21 words into memory. The second word on the card (the first CPU instruction) was a branch to self if channel is busy. The third word was the first instruction of the boot loader. We don't need no stinkin boot ROM :-) Marv Rubinstein
fenske@dfsun1.electro.swri.edu (Robert Fenske Jr) (06/07/90)
In article <43535@ism780c.isc.com> marv@ism780.electro.swri.edu (Marvin Rubenstein) writes: > >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: > > ... > >The card reader could, of course, read all 80 columns. However only 72 >columns were presented to the computer. But why 2 36-bit words? Why wasn't it 2 40-bit words, or 4 20-bit words, or 5-16 bit words, or 1 80-bit word? -- Robert Fenske, Jr. Sw | The Taming the C*sm*s series: Electromagnetics Division /R---\ | Southwest Research Institute | I | | "The Martian canals were the dfsun1.electro.swri.edu 129.162.160.4 \----/ | Martians' last ditch effort."
toma@tekgvs.LABS.TEK.COM (Tom Almy) (06/07/90)
Well I had stated that the IBM 407 Accounting Machine read in the 12 edge (like the other unit record equipment), using the digit holes to turn the accumulator off. But the more I think about it (and unfortunately I cannot find the reference) it probably read in the 9 edge first. I was thinking that the 12 edge was read in first so that the zone punches (the 12 11 and 0 ) seen first. But the 407 had two read stations, so the first could be used to detect the zone punches. Also, mechanically, it makes more sense for the presence of a hole to turn the accumulator digit rotation on (and reaching the 0 punch, turn off). That way the absence of any digit punch could be treated as a 0. BTW as archaic as all this stuff was, I feel that all the "young whippersnappers" that have never used any computer other than from a crt terminal have missed a whole lot. These thing were interesting multi-processing challenges that build strong minds! Also, lets hear it for Analog computers! (Same reasons!) Tom Almy toma@tekgvs.labs.tek.com Standard Disclaimers Apply
news@ism780c.isc.com (News system) (06/08/90)
In article <7619@tekgvs.LABS.TEK.COM> toma@tekgvs.LABS.TEK.COM (Tom Almy) writes: >The IBM 407 Accounting Machine (essentually a printing adding machine for >punched cards :-) read in the 12 side first. Actually the cards were read 9 edge first. On most (if not all) IBM machines that read cards, the cards were intered 9 edge first. Card punches on the other hand processed cards 12 edge first. An exception was made for the case of the card punch on the 704 and 709* computer. On these machines the punches were also 9 edge first. This was so a read into a buffer followed by a write of the same buffer would duplicate the card. > The accumulators were wheel >like devices, that worked like odometers. If you were adding a field to >this to be a digit parallel design where the digit value is encoded by >pulse length. You could also consider the 407 to be a multiprocessing system! Indeed! The accumulator wheels could be connected together by wiring a carry proprgate from one wheel to the next. Thus the number of accumulators and their precision was under patch panel control. RPG was originally devised as a sort of simulator of the 407. The encoding was not by pulse length. Each pulse lasted for exactly the same time (called a digit pulse time). It was the time required for the punched hole to pass a read brush. The card passed between a copper drum and a set of 80 side by side brushes. If there was a hole in the card, current flowed between the brush and the drum. So the value of a digit depended on when it occured. The timing chart in front of me shows the the digit time for the card reader is about 6 miliseconds. For the 407 printer, the digit time was about 9.75 miliseconds. An interesting feature of the 407 was that supplied what was called "print echos". A print echo was the 9's complement of the digit printed. The computer had an instruction, read printer. This could be used to read the print echos for a redundency check of the printer. However, it most frequent use was to read time of day. A digital clock was available that delivered time in Holerith code. It was connected to the computer through the printer via the printers patch panel. I actually had to simulate the printer clock for the 7094 immulator that I implemented. Marv Rubinstein -- I really programmed these gadgets
news@ism780c.isc.com (News system) (06/08/90)
In article <54@apex.UUCP> chuckh@apex.com (Chuck Huffington) writes: >Y In the old IBM 709, which was the vacuum tube (valve) >version of the 7090 the system card reader read only columns 1-72. The 7090 was a transistor version of the 709 :-) The machines did not have the same architecture. The 709 had 3 index registers. The 7090 had 7. Also the 7090 had double precision floating point instructions. It is interesting that the 7090, IBM's first transister computer, was announced just after Philco announced its transistor machine, the Philco 2000. > >As I recall a lot of cards also came in thru an off line card to tape >machine. They read the whole card and wrote it in BCD on 7 track tapes. Nope, the cards were read in binary (allowing all 12 punches in a column) and written in binary. Tapes had two modes, binary and BCD. In binary mode a tape frame could represent all 64 combinations of the 6 bit frame (the 7'th bit was parity). In BCD mode only 63 combinations were allowed. Binary mode used odd parity. BCD mode used even parity. In order to detect a parity error in BCD, the data patern of all zero bits was not allowed. Marv Rubinstein -- Don't ask how I remember all this trivia, I don't know