Card Columns (was Why did they make ... ?) 
Author Message
 Card Columns (was Why did they make ... ?)



Quote:


> >IMO systems where you don't need JCL are better designed for humans
> >to use.

> How do you design a system where you don't need JCL? You can, of
> course, change the nomenclature, and there are a lot of ways that you
> can structure it, but you need some way to specify what functions to
> perform, where the inputs are and where to place the outputs.

Once upon a time, we had systems that didn't use JCL - or any other command
language.
The 1401, 1410, 1620, 1710, 709, etc. In all of these machines, there was no
real file system; each program read directly from and wrote directly to the
I/O devices.


Thu, 21 Jul 2005 13:17:28 GMT  
 Card Columns (was Why did they make ... ?)


Quote:

> > The UNIVAC cards had round holes.  Years later, IBM produced a 96 column
> > card with smaller round holes.

> IBM's original cards had round holes too.  They switched to the
> rectangular ones when they moved from 45 to 80 columns.

> The story (true or false) is that they changed the shape because
> they couldn't patent the number of columns they used, but they
> could patent the superior structural integrity the rectangular
> holes supposedly gave the cards.

> Eric

The rectangular holes were there to allow the wire brushes to contact the
brass drum and produce an accurately timed, crisp signal. Each column of the
407 read stations had a brush approximately the width of a punch-card hole.
As the card was fed over the rotating brass drum, the timing for each row
registered within the machine. If at the time that a particular row
registered, a current was flowing between the brush and the drum, the punch
was detected. The 407 patch panel had holes for each card column for each of
two read stations. It also had holes for devices to which the signals could
be fed. The simplest wiring would connect the card columns with the
corresponding print columns. This produced the "80-80 listing", since 80
card columns were wired to 80 print columns. There were many reasons for two
read stations: one could wire the 407 to do sequence checking by comparing
the card at station one with the card at station two - the panel could be
wired to do increment and carry; other operations required station one to
set up a signal that could not be electromechanically reacted to until
later, station two would re-read the card and the setup would be carried
out.

My first experience with this machine was in wiring the board for an "80-80
listing". My second was to wire it so that I could print a full 120 columns
by using two cards, each with a different control punch to cause the shift.

The university where I worked ran all of their administrative work on 407,
409, 519, 026 machines for years. Even after they got a 1620 computer, the
tab equipment was still the mainstay of their operations. This didn't change
until several years after I was gone and they moved into S/360 equipment.

Note: The two read stations in the 407 influenced program design for years
(and perhaps still does). I remember many programs written with two read
buffers where the logic was little more than a simulation of the operations
that were possible on the 407. As programmers got further away from the unit
record heritage, this design was refined, but echoes of it are still present
in
many older programs.



Thu, 21 Jul 2005 14:10:52 GMT  
 Card Columns (was Why did they make ... ?)

Quote:

> Once upon a time, we had systems that didn't use JCL - or any other command
> language.
> The 1401, 1410, 1620, 1710, 709, etc. In all of these machines, there was no
> real file system; each program read directly from and wrote directly to the
> I/O devices.

Not altogether.  Even when (as usual) 1401 application programs were
individually booted off the card reader, they often used IOCS for tape,
and almost always used it for disk.  (The unit-record equipment usually
wasn't given over to IOCS unless the "Overlap" feature [i.e., channel]
was being used.)  Even more so on the 1410.  I don't know about the
1620/1710, and I'm not sure about the 709, but its transistorized
successors had usable operating systems, and even going back to the 701
some kind of I/O subroutine library was common, because I/O on that
series was a {*filter*}.

--
John W. Kennedy
"The poor have sometimes objected to being governed badly;
the rich have always objected to being governed at all."
   -- G. K. Chesterton, "The Man Who Was Thursday"



Thu, 21 Jul 2005 15:23:44 GMT  
 Card Columns (was Why did they make ... ?)

Quote:





> > >IMO systems where you don't need JCL are better designed for humans
> > >to use.

> > How do you design a system where you don't need JCL? You can, of
> > course, change the nomenclature, and there are a lot of ways that you
> > can structure it, but you need some way to specify what functions to
> > perform, where the inputs are and where to place the outputs.

> Once upon a time, we had systems that didn't use JCL - or any other command
> language.
> The 1401, 1410, 1620, 1710, 709, etc. In all of these machines, there was no
> real file system; each program read directly from and wrote directly to the
> I/O devices.

Not true of 1410s (and 7010s) which had a choice of two operating systems,
PR108 and PR155.
--
Nick Spalding


Thu, 21 Jul 2005 20:06:54 GMT  
 Card Columns (was Why did they make ... ?)

Quote:
>               I'm not sure about the 709, but its transistorized
>successors had usable operating systems, and even going back to the 701
>some kind of I/O subroutine library was common, because I/O on that
>series was a {*filter*}.

For example, to print the letter "A" in the 72nd column, you had to set
up a 24-word data block (at 36 bits/word):

  OCT  0,1,0,0,0,0,0,0,0,0,0,0   BITS FOR ROWS 12-3
  OCT  0,0,0,0,0,0,0,0,0,0,0,1   BITS FOR ROWS 4-9

with the "1" words setting a punch in the last columns of the 12-row
and 9-row.  (The punch code for "A" is 12-9)

And that's just the data.  Once you've got that done then you go into
the joys of issuing an RCHA, waiting for the operation to complete,
doing error checking to verify that the printwheels really did
print what was expected, etc. etc.

Joe Morris



Fri, 22 Jul 2005 20:45:54 GMT  
 Card Columns (was Why did they make ... ?)


Quote:
>Once upon a time, we had systems that didn't use JCL - or any other
>command language.

We had computers that didn't require JCL, but not operating systems.

Quote:
>The 1401, 1410, 1620, 1710, 709, etc. In all of these machines,
>there was no real file system;

I can't speak to the 1620/1720, but the rest had IOCS, and two of them
had an[1] operating system as well.

FSVO "an" greater than one.

--
     Shmuel (Seymour J.) Metz, SysProg and JOAT

Any unsolicited commercial junk E-mail will be subject to legal
action.  I reserve the right to publicly post or ridicule any
abusive E-mail.

I mangled my E-mail address to foil automated spammers; reply to
domain Patriot dot net user shmuel+news to contact me.  Do not



Sat, 23 Jul 2005 03:25:14 GMT  
 Card Columns (was Why did they make ... ?)


Quote:
> The rectangular holes were there to allow the wire brushes to
contact the
> brass drum and produce an accurately timed, crisp signal. Each
column of the
> 407 read stations had a brush approximately the width of a
punch-card hole.
> As the card was fed over the rotating brass drum, the timing
for each row
> registered within the machine.

A minor nitpick here... Although I was never formally trained on
the 407, ISTR that the read mechanism, rather than using the
brass drum commonly used in many piece of UR gear, instead used a
plate consisting of 960 separate contacts and a brush block
consisting of a full 960 brushes, one for each punch position.
And that there were two of them, one for each of the two
consecutive cards from the deck being fed through.  Or, I may be
thinking of another machine of the 40x series.

Most of my contact with the inner workings of a lot of
Unit-Record gear came during my first month of employment by IBM.
During that time, I was assigned to work under the informal
tutelage of the CE assigned to the Acacia Mutual Insurance
Company in Washington, DC.  They had a big room full of UR gear,
in addition to a 1401 and a 7070.  I picked up a few concepts of
UR operations during that time, although I seldom worked on any
of that equipment, except while working on second-shift and often
was sent to service machines I wasn't formally trained on.

Quote:
> There were many reasons for two
> read stations: one could wire the 407 to do sequence checking
by comparing
> the card at station one with the card at station two - the
panel could be
> wired to do increment and carry; other operations required
station one to
> set up a signal that could not be electromechanically reacted
to until
> later, station two would re-read the card and the setup would
be carried
> out.
<SNIP...>
> Note: The two read stations in the 407 influenced program
design for years
> (and perhaps still does). I remember many programs written with
two read
> buffers where the logic was little more than a simulation of
the operations
> that were possible on the 407. As programmers got further away
from the unit
> record heritage, this design was refined, but echoes of it are
still present
> in many older programs.

You didn't mention the main reason for the two read-stations and
for card-to-card compares. It wasn't mainly for
sequence-checking, as such. That was usually done via a collator,
if required at all.

It was for detecting a *change* in some individual field(s), for
the purpose of triggering operations such as outputting totals or
subtotals, clearing counters, advancing the paper, printing
headers, and punching cards on the "summary punch".  This
"transition detection" function was, IIRC, called a "control
break", and was key to the totalling and formatting functions of
the accounting machine. This basic mechanism is still very much
an essential function of any report-generating system. Or, for
that matter, any other business computing process that is done in
a sequential fashion, whether the input comes from punched cards
or from rows in a relational result-set, where "group by" and
"Order By" SQL clauses are used. In essence, I don't think it
ever required much in the way of "refinement". It is a classic
algorithm, even though it apparently gets short-shrift from
academic "computer science" curricula.

Indeed, each machine in the family of UR devices can be viewed as
the embodiment of a "classic" algorithm, such as sorting,
merging, and tabulating (totalling, summarization, and
reporting). It's quite amazing what kinds of work can be
accomplished by combining those basic operations, in various
ways, into an overall process. I recall reading, for example,
that under the direction of physicist Richard Feynman, most of
the calculations performed during the Manhattan Project were done
with IBM punched-card gear.

The most advanced of these machines, devices such as the 407
accounting machine, with attached summary-punch, had almost no
"memory", apart from a small set of counters (accumulator
registers, if you will), plus the contents of a pair of
consecutive cards from a card deck. In the light of that, it's
quite impressive what could be done with this equipment.

The science of classic batch processing doesn't get enough
respect from programmers today, IMO. The emphasis today is on
interactive, real-time transaction processing. While obviously
more convenient, it's clearly not nearly as efficient as batch
techniques. The inherent efficiency of that method made it
possible for large businesses to handle their accounting, before
computers were invented, even with incredibly slow machines. It's
becoming a lost art, from what I've experienced in the past few
years.



Sun, 24 Jul 2005 01:20:43 GMT  
 Card Columns (was Why did they make ... ?)

Quote:

> A minor nitpick here... Although I was never formally trained on
> the 407, ISTR that the read mechanism, rather than using the
> brass drum commonly used in many piece of UR gear, instead used a
> plate consisting of 960 separate contacts and a brush block
> consisting of a full 960 brushes, one for each punch position.
> And that there were two of them, one for each of the two
> consecutive cards from the deck being fed through.  Or, I may be
> thinking of another machine of the 40x series.

I think you are correct.  The standard 407 operated at 150 cycles per minute and
the panel was usually wired to feed a card on each cycle, but it didn't have to
be.  The 407 had rudimentary programmability (5 steps if I recall) and I pretty
sure you could read from the same card more than once.

Quote:
> The most advanced of these machines, devices such as the 407
> accounting machine, with attached summary-punch, had almost no
> "memory", apart from a small set of counters (accumulator
> registers, if you will), plus the contents of a pair of
> consecutive cards from a card deck. In the light of that, it's
> quite impressive what could be done with this equipment.

The 407 was indeed advanced for a tabulator, but it was basically limited to
addition, subtraction, and comparison.  It was used primarily for printing
invoices, checks, various reports required for payroll, accounts receivable and
payable, and inventory control, etc.  To perform the more extensive computations
required to get from time cards to net pay, usage to amount payable for utility
billing, etc., calculating punches such as the 602 and 604 were used.  The 602
was electromechanical and was based on rotary counters and relays; it had 12
program steps but they could be used repeatedly with clever wiring.  The 604 was
electronic (vacuum tube); it could have up to 50 program steps (even more could
be added on a RPQ basis).


Sun, 24 Jul 2005 05:08:39 GMT  
 Card Columns (was Why did they make ... ?)

Quote:

> For example, to print the letter "A" in the 72nd column, you had to set
> up a 24-word data block (at 36 bits/word):

>   OCT  0,1,0,0,0,0,0,0,0,0,0,0   BITS FOR ROWS 12-3
>   OCT  0,0,0,0,0,0,0,0,0,0,0,1   BITS FOR ROWS 4-9

> with the "1" words setting a punch in the last columns of the 12-row
> and 9-row.  (The punch code for "A" is 12-9)

Did this machine not use the same card codes as the 1401 and System/360?  In
which case, "A" is 12-1; 12-9 is "I".

--

        (who *still*, after 27 years on PDP-10's, thinks of alphanumerics
         in 026/029 punch codes and System/360 EBCDIC rather than in ASCII)
  "You get what anybody gets.  You get a lifetime."  --Death, of the Endless



Sun, 24 Jul 2005 07:40:35 GMT  
 Card Columns (was Why did they make ... ?)

Quote:


>> For example, to print the letter "A" in the 72nd column, you had to set
>> up a 24-word data block (at 36 bits/word):

>>   OCT  0,1,0,0,0,0,0,0,0,0,0,0   BITS FOR ROWS 12-3
>>   OCT  0,0,0,0,0,0,0,0,0,0,0,1   BITS FOR ROWS 4-9

>> with the "1" words setting a punch in the last columns of the 12-row
>> and 9-row.  (The punch code for "A" is 12-9)
>Did this machine not use the same card codes as the 1401 and System/360?  In
>which case, "A" is 12-1; 12-9 is "I".

Ouch.  Please press the "reset" button for my fingers; the posting should
have said "I" instead of "A".  For an "A" in cc72 the data would have been:

   OCT  0,1,0,0,0,0,0,1,0,0,0,0
   OCT  0,0,0,0,0,0,0,0,0,0,0,0

If anyone's trying to figure out how these constants map to the card,
take the first eight words of the constant and express them in binary
with two, 36-bit words to the line, and you'll get:

000000000000000000000000000000000000000000000000000000000000000000000001
000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000001

If you now pad out the data stream with eight more rows of zeros
you'll see that you have a 12-1 ("A") punch in cc72.

Consider the amount of coding required to translate between BCD and
card codes -- especially given the maximum memory address space of
32K.  And my recollection -- subject to confirmation if I can ever
find the box with the listings -- is that under FMS the typical
core load included the UR interface programs even if the program never
used it.

Remember that the online UR equipment for the 701/704/709/709x (but *not*
for the 704x) operated exclusively in row-binary.  Each 36-bit word
represented half of one 72-column row, and well into the era of column
binary (through offline spooing, usually through a 1401) the PoO for
the mainframes still had to explain the row-binary concepts and define
terms such as "12-row left"...and give examples (hopefully not referring
to "A" when "I" should have been used <grin>).

Joe Morris



Sun, 24 Jul 2005 21:39:30 GMT  
 Card Columns (was Why did they make ... ?)


Quote:
> The 407 was indeed advanced for a tabulator, but it was

basically limited to
Quote:
> addition, subtraction, and comparison.  It was used primarily
for printing
> invoices, checks, various reports required for payroll,

accounts receivable and
Quote:
> payable, and inventory control, etc.  To perform the more

extensive computations
Quote:
> required to get from time cards to net pay, usage to amount
payable for utility
> billing, etc., calculating punches such as the 602 and 604 were
used.  The 602
> was electromechanical and was based on rotary counters and
relays; it had 12
> program steps but they could be used repeatedly with clever

wiring.  The 604 was

Quote:
> electronic (vacuum tube); it could have up to 50 program steps
(even more could
> be added on a RPQ basis).

True. None of the regular tab machines could multiply or divide,
and the 60x
machines were designed to perform just that ... maybe it was only
multiplication,
come to think of it.  However, sometime in the late '60s, IBM
came out with an
add-on gizmo for the 407, an electronic calculator device that
was attached to the
side of the machine. I don't know much detail about it, but I'm
pretty sure it
included some forms of arithmetic higher than addition and
subtraction. The device
used IBM's Solid Logic Technology for packaging electronics ...
the same as was used
in System/360.  Adding that to a box full of relays and
mechanical counters was
a striking case of technological anachronism, if there ever was
one.

I can't remember what they called this feature... it was
something like "Advanced
Function Unit".  Anyone remember more about this gadget?



Mon, 25 Jul 2005 00:07:37 GMT  
 Card Columns (was Why did they make ... ?)

Quote:
> Consider the amount of coding required to translate between BCD
and
> card codes -- especially given the maximum memory address space
of
> 32K.  And my recollection -- subject to confirmation if I can
ever
> find the box with the listings -- is that under FMS the typical
> core load included the UR interface programs even if the
program never
> used it.

The coding for translating between Hollerith code and BCD had
some simplifying
aspects, as 6-bit BCD was simply a more compact way of
representing
12-bit Hollerith. All "legal" characters in Hollerith had either
0 - 3
punches per column.  If there were two holes (alpha or '/'), one
of the holes
was a 12, 11, or 0 punch ("zone"), and the other was 1 through 9
("numeric").
If there were three holes, the "numeric" part had an '8' in
combination with one
other numeric punch of 2, 3, or 4 (IIRC). It was also legal to
have an 8-something
combination without any "zone" punches, giving only two holes.

Any other pattern was an "invalid" character. I also remember
that the 709x
machines also used a somewhat different version of BCD character
coding
*internally*, which was different from the BCD of other IBM
equipment,
and that the tape controller could perform the translation, on a
Read or
Write operation. So, the tape operations consisted of "Read/Write
BCD",
and "Read/Write Binary" forms.  Mostly, the difference between
the two codes
was in the two high-order "zone" bits. Anyway, I remember that a
"space"
character was octal 60 internally, but 00 externally.

Also, the "standard" BCD character code was slightly different
when writing
tape in "even-parity" mode, because 00 would have no parity bit,
and therefore
could not be written to an NRZI tape, so an octal 12 was
substituted. Binary
tapes had to be written in odd parity. (NRZI tapes had to have at
at least
one 1-bit per character, because the 1-bits provided the only
timing signal).

Quote:

> Remember that the online UR equipment for the 701/704/709/709x
(but *not*
> for the 704x) operated exclusively in row-binary.  Each 36-bit
word
> represented half of one 72-column row, and well into the era of
column
> binary (through offline spooing, usually through a 1401) the
PoO for
> the mainframes still had to explain the row-binary concepts and
define
> terms such as "12-row left"...and give examples (hopefully not
referring
> to "A" when "I" should have been used <grin>).



Mon, 25 Jul 2005 00:49:00 GMT  
 Card Columns (was Why did they make ... ?)

Quote:


> > The 407 was indeed advanced for a tabulator, but it was
> basically limited to
> > addition, subtraction, and comparison.  It was used primarily
> for printing
> > invoices, checks, various reports required for payroll,
> accounts receivable and
> > payable, and inventory control, etc.  To perform the more
> extensive computations
> > required to get from time cards to net pay, usage to amount
> payable for utility
> > billing, etc., calculating punches such as the 602 and 604 were
> used.  The 602
> > was electromechanical and was based on rotary counters and
> relays; it had 12
> > program steps but they could be used repeatedly with clever
> wiring.  The 604 was
> > electronic (vacuum tube); it could have up to 50 program steps
> (even more could
> > be added on a RPQ basis).

> True. None of the regular tab machines could multiply or divide,
> and the 60x
> machines were designed to perform just that ... maybe it was only
> multiplication,
> come to think of it.  However, sometime in the late '60s, IBM
> came out with an
> add-on gizmo for the 407, an electronic calculator device that
> was attached to the
> side of the machine. I don't know much detail about it, but I'm
> pretty sure it
> included some forms of arithmetic higher than addition and
> subtraction. The device
> used IBM's Solid Logic Technology for packaging electronics ...
> the same as was used
> in System/360.  Adding that to a box full of relays and
> mechanical counters was
> a striking case of technological anachronism, if there ever was
> one.

> I can't remember what they called this feature... it was
> something like "Advanced
> Function Unit".  Anyone remember more about this gadget?

Are you sure it was SLT?  The 1401 era SMS sounds more likely.  
--
Nick Spalding


Mon, 25 Jul 2005 02:32:39 GMT  
 Card Columns (was Why did they make ... ?)

Quote:

> Are you sure it was SLT?  The 1401 era SMS sounds more likely.

No, I remember distinctly that it was described as an SLT board,
not SMS. I hasten to add, however,
that I only read about the device in an IBM employee mailing. I
never actually saw one. However,
I do recall that it was introduced within the 360 time period
(late 1960s), and that this
product announcement came sometime after I started working for
IBM in 1966. So SLT certainly
makes sense from a timing perspective.

I remember this particularly because it was the subject of a lot
of coffee-break shop-talk
among CE's at the time. Most of us were frankly amused at the
bizarre juxtaposition of
really old technology married to the new.  I remember, too, one
particular CE in the Washington
Midtown branch office, whose career had been sidetracked into
maintaining the "old iron". He was
e{*filter*}d over the chance to work on something using SLT
technology.

For the record, though, I will acknowledge that the System/360
line of I/O devices did include
a fair number of machines using SMS technology. But, as far as I
remember, all such machines
were adaptations of 1400- and 7000-series devices. For example,
the 2401 tape drive was
essentially a 729 in a nice-looking new box, and with 2 extra
data tracks.

This 407 add-on, however, did not have a predecessor from the
"SMS era". It was a brand-new
product designed for low-end customers who couldn't afford
computer systems. I imagine IBM
created this product to keep these tab-shop customers in the IBM
fold, until they were ready
to step up to real computers. Sort of a transitional product, in
other words.

At least that was the thinking. I don't know how many 407
customers actually took the bait.



Mon, 25 Jul 2005 06:47:23 GMT  
 Card Columns (was Why did they make ... ?)


Quote:
>Ouch.  Please press the "reset" button for my fingers; the posting
>should have said "I" instead of "A".  For an "A" in cc72 the data
>would have been:
>   OCT  0,1,0,0,0,0,0,1,0,0,0,0
>   OCT  0,0,0,0,0,0,0,0,0,0,0,0

Not according to my copy of the manual, which claims that the first
two words are 9 row.

--
     Shmuel (Seymour J.) Metz, SysProg and JOAT

Any unsolicited commercial junk E-mail will be subject to legal
action.  I reserve the right to publicly post or ridicule any
abusive E-mail.

I mangled my E-mail address to foil automated spammers; reply to
domain Patriot dot net user shmuel+news to contact me.  Do not



Tue, 26 Jul 2005 23:11:35 GMT  
 
 [ 373 post ]  Go to page: [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] [16] [17] [18] [19] [20] [21] [22] [23] [24] [25]

 Relevant Pages 
 

 
Powered by phpBB® Forum Software