
Say it's 1962, you're lucky enough to be a programmer working with an IBM 7090 - ohjeez
https://twitter.com/Foone/status/1201956309941116928
======
Animats
No, no, you did not need to interleave blank cards with original cards to
duplicate a deck. That was something you could do on a keypunch if absolutely
necessary.

The IBM 519 Document Originating Machine was a 514 Reproducer with a mark-
sense reader attachment. That was the "document originating" part. Loaded with
an 80-80 reproduce board, either machine could copy a deck of cards. Two
feeders, one with a reader, and one with a punch, going to separate output
stackers. Duplicating a card deck was its most common use, although it could
do a few other tasks.

The 514 and 519 could be cabled up to a 407 accounting machine, using a cable
almost 2 inches in diameter and a huge connector about two by six inches. This
allowed the 407 to generate new punched cards with results from a tabulator
run.

The little glass window front and center was the comparison display. The
original and new card were usually re-read by a second set of brushes and
compared, as an error check. That display showed any differences.

The 1401/7090 combo was fairly common. A lower end configuration used the IBM
7040, and that setup was popular with universities. The usual setup was to
have some tape drives shared between the two computers, with manual switches.
Cards were read into the 1410 and written to tape, and output was written to
tape on the 7090 and printed on the 1401, using a 1403 printer like the one at
the Computer Museum in Mountain View.

Here's what a job, as a deck of cards, looked like.[1]

[1] [http://sky-visions.com/ibm/7090/ibsys/jobs/arg1.fo](http://sky-
visions.com/ibm/7090/ibsys/jobs/arg1.fo)

~~~
cjslep
Me, 2015: "This engineering code is some serious fixed FORTRAN"

My 80+ year old boss at the time: "Yeah it had to be" _Whips out several boxes
of punch cards_

~~~
7thaccount
What kind of engineering code you dealing with? Just curious.

~~~
cjslep
It was a tornado risk assessment wind fragility modelling software, used by
the nuclear power industry.

~~~
7thaccount
Like for the spread of fallout?

~~~
cjslep
No, like "what happens if a tornado hit the powerplant and chucked trees and
other debris at various parts of the powerplant".

------
bluenose69
I'm glad I learned to program using punched cards, in a batch-job system.

At my university, the local (IBM 1130) machine was used during the day to send
jobs to a larger (IBM 360?) machine at an affiliate university. The turnaround
from putting cards in the output tray and getting output was often over an
hour, since a local operator sent jobs in groups, and separated printouts only
when there was enough paper to justify interrupting her other work. The whole
computer system was behind locked doors, and this operator was like a god who
took our offerings and bestowed her blessings when she felt like doing so.

Past 6PM or so, the local machine was available only to researchers, who
worked through the night. I think the weekend was also dedicated to local
research, so mere mortals (undergraduates) like me did not get a lot of
chances to meet our deadlines.

The upshot of these restrictions is that code often worked the first time. You
didn't write it on coding sheets until your logic made sense. And you didn't
punch cards from those sheets until you had gone through them again, and were
sure not just on the logic but the variable spelling, etc. Then you punched
the cards. Then you worked through the deck, one by one, imagining yourself to
be the machine. Every extra hour spent this way increased your chance of
getting results before the end of day.

The difficulty of the process led to good habits.

~~~
asdfman123
As a younger developer, I feel like I would have enjoyed the work of writing
code for those sorts of machines more. These days it's just too easy to throw
a bunch of junk at the wall and seeing what sticks.

I would have loved to be able to slow down, have an incentive to really know
my stuff, think through all the possibilities and write out a few lines of
beautiful, efficient code.

I suppose I can still do that with discipline -- but it's too easy to lean on
the debugger, and even if you want your code to be clean, the codebase you're
working on isn't necessarily going to be.

~~~
SilasX
Sorry for the plug, but you can kind of simulate that process in the
nand2tetris.org course (also available on Coursera).

In that course, you build a computer (through hardware simulators) that can
run binary programs. Then you build up a programming toolchain: stack based
virtual machine language that compiles to assembly, and a high level language
that you compile to the VM language. You also write the assembler that
translates your assembly into ones and zeros, which are like the punch cards.

So you can simulate what it's like to be writing the binaries: if you take out
the compilers, you can go through the process of manually translating your
high level code into punchcards. The high-level lines become stack operations,
which become assembly commands, which become binary words.

(For efficiency reasons, you'd probably program directly in assembly where
possible, but you can add on the abstraction levels.)

~~~
asdfman123
That sounds like a great course. Plugs are welcome when they benefit the
readers -- they're only bad when they only benefit the authors.

~~~
SilasX
Fair enough. I was just worried that HNers might feel that that course gets
promoted too much here. (IMHO, nand2tetris deserves that level of promotion! I
just recently gave a talk about it for the Austin Python meetup.)

------
jonjacky
These old photos do not convey the noise and spectacle. The guys are in white
shirts and ties, but those old machine rooms were more like a factory floor
than an office. Part of the reason they were separated off was to try to
contain the noise. Those line printers struck the page with 132 characters at
once - WHAP! WHAP! WHAP! - and the paper is almost flying out the top. Those
high speed card readers consumed a stack of thousands of cards in a minute -
it reminded you of a log moving into the whirling blade at a sawmill. Then
there was the roar (not hum) of the fans and the banging of the keypunches and
teletypes - much louder than typewriters. You really got the sense that
computation was a physical, mechanical process that consumed a lot of energy.

------
dbcurtis
My favorite PL/I trick from the punch card days. It takes two cards:

    
    
      DEBUG = 0; /*/ ;1 = GUBED
      */
    

Reverse the card to turn on the debug switch. Not invented by me, I forget who
showed me that. A professor I had as an undergrad, I think.

~~~
Robin_Message
I've done something similar in C type languages to switch between blocks of
code:

    
    
        /*/
        This block is inactive
        /*/
        This block is active
        /**/
    

Just swap the first star to two stars to flip between them.

~~~
ncmncm
That is what #ifdef, or #if 0, is for.

------
GnarfGnarf
I programmed and earned a living with this technology 1965-1980. I don't miss
it. I wrote a 4,000-card Assembler program that required two metal trays to
transport.

Did anyone else "insert" and "delete" columns by pressing down on one card in
the keypunch while duplicating? This enable one card to advance while keeping
the other in place.

We invented the "240-column" card at the insurance company where I worked. We
stored three digits per column (four bits per digit times three equals twelve
rows). Being the 70's (0111), our cards looked like lace doilies.

------
afandian
I love the trick with the diagonal red line to indicate the order (and help
you to sort if you did drop them). It's so beautifully neat, and simple.

[https://twitter.com/Foone/status/1201959165926592513](https://twitter.com/Foone/status/1201959165926592513)

~~~
graycat
Run the cards through one of the punched card machines and put sequence
numbers in columns 73-80. Then if the cards get out of order, take them to a
punched card sorting machine. Yup, it was fast, generally faster than the
_fastest possible, meets the Gleason bound_ heap sort. How? That machine used
radix sort!

------
_emacsomancer_
More readable perhaps as
[https://threadreaderapp.com/thread/1201956309941116928.html](https://threadreaderapp.com/thread/1201956309941116928.html)

------
sriram_malhar
I learnt programming on punched cards. As a student, we were limited in the
number of cards we were given for free.

I remember cannibalising older stacks for cards containing (fortran IV)
statements like "DO 100, I = 1, N", and "100 CONTINUE". My first exposure to
reusable code :)

~~~
Symbiote
How much did they cost?

Even special cardboard seems like it ought to be very cheap.

~~~
sriram_malhar
I have no idea. This was India in 1981. There was this "general knowledge"
that it was expensive so I never even bothered to find out! Esp. since my
beginning programs were well within 300 lines, and the rest I could get by
using cards from friends. I never thought of this way until now, but we were
trading cards: "Does anyone have a 'FORMAT INT2' card"?

I'm not sure it built any character!

------
AnimalMuppet
Love the comment by Kathleen:

> My dad, a mainframe guy for the army in the late 60s-early 70s, claims that
> the (men) programmers knew which of the (women) punch card operators to take
> your deck to, because some would thumb through and say “sure you want to
> submit yet? I think you have an error... here.”

~~~
graycat
In the days of batch computing with turnaround time of several hours, a good
idea was to take the deck of cards to a machine that right away would just
_list_ the deck, that is, print the cards. Then go over the listing line by
line to _desk check_.

In those days, some of the _job control_ cards were tricky to get right. So,
at a big meeting about the computing services, one frustrated user stood and
explained that when he had a job control card that worked, he would laminate
it in plastic, punch a hole in one corner, and hang it on a chain.

~~~
schoen
The laminate didn't end up re-covering all of the holes?

~~~
graycat
He (not me!) used clear plastic so that, sure, he could see the holes, but,
really, usually the top edge of the card had printing for the characters so
that for a human doing the reading, didn't really have to see the holes. And
for the machines, no way would they accept the plastic! He was so desperate to
find a way to get errors out of the control cards that he wanted the plastic
for durability and was willing to copy the card at a key punch machine.

Once I was working in fluid flow calculations at the Naval R&D Center, the one
with the ship model towing tank. I was at a keypunch machine typing in my code
and comments, and the head of the place, a Navy guy, said that I should use
the keypunch machines only for small changes and otherwise should write my
code in the little blocks on the coding sheets and have the keypunch staff do
the typing. I responded that I was good with a keypunch machine, since I could
make _control cards_ maybe better than the keypunch staff, and could sit at
the keypunch machine and type my code just from my rough notes faster than I
could fill out the forms AND could _ad lib_ and type in the comments without
ever writing them down, in total MUCH faster. The Navy guy let me do it my
way!

E.g., for extended comments, say, at the top of some code, could have a simple
control card that would type the 'C' Fortran comment delimiter in column 1,
indent to, say, column 7, permit typing, and at column 73 automatically move
to the next card, type the 'C', and stop at column 7 again. Semi-, quasi-
amazing!

For moderately advanced _jobs_ the IBM JCL (job control language) was so
tricky that a good solution was to use a keypunch machine to make copies of
control cards that had actually worked! Then either use the exact copies or
make small changes -- net reduce JCL errors, important when job turn around
time was in the hours.

At one time I was writing PL/I code to run on an IBM 360/91, the one at the
JHU/APL Navy lab, to read 7 track tapes written in submarines at sea. Each
reel of tape had data from several _trials_. The guys on the submarines were
really good about putting delimiters between the trials: They used a Dymo
label maker and put the sticky plastic label on the tape. Then on the 380/91
-- you guessed it! -- the tape started reading, really fast, powerful tape
drive motors, and suddenly BAM, WHAM, POP, CRACK, SNAP, flutter flutter, the
Dymo label hit the reading heads, stopped cold, and the tape broke and flapped
in the vacuum columns! It was IBM's job to fix it!

When we got tapes with the dymo labels off, I had to read the data in in
_binary_ , lay over it a _based structure_ , _based_ because it was relative
to a pointer. The structure had lots of bit string fields for the intricate
structure on the tape. Then my code had to do various conversions and return
easy to use data! It was a box of cards -- took a while.

Later one week I raced through Blackman and Tukey, _The Measurement of Power
Spectra_ , got smart on power spectral estimation (mostly chi-squared
statistics), typed PL/I code furiously, for about 1000 lines of code, and had
the code generate _white noise_ , pass it through a filter, record the
resulting power spectrum, and show that as the noise signal continued the
estimated power spectrum converged to the one used in the filter.

The code illustrated clearly how long a stream of data was needed for an
accurate estimate of the power spectrum. Basically what is needed is enough
cycles at the frequencies of interest. But since their data was to be from
ocean wave noise, the frequencies were really low so that for enough cycles
the length of data they needed for accurate estimates was quite long, in
uncomfortably many HOURS.

But my illustrative code cleaned up a technical point in a competitive
proposal for some software, and as a result of my little PL/I effort got our
little company "sole source". Ah, punched card days.

When I got to Ohio State as a B-school prof, the students were STILL forced to
use punched cards. I mounted an effort to get a good time-sharing computer,
with ADM dumb terminals, for the B-school. The CIO opposed me. IBM and their
super salesman Buck Rodgers opposed me. The Deans took my advice, and I won.

We got a Prime, nice computer, a single board bit-sliced super-mini version of
Multics, maybe the one Mike Bloomberg started with. Nice _multiple virtual
storage_ machine, with security rings (Intel 386 borrowed?) with a nice
hierarchical file system with security from _capabilities_ and _attribute
control lists_ , all in 40 KB of code! Nice machine!

I was appointed Chair of the college computing committee and put on a
committee to pick a new CIO for the university. I taught a grad seminar in the
selection and evaluation process. Fun days!

------
fizwhiz
OT: Do people really enjoy reading information like this sprinkled over
multiple tweets? Is it so that the can granularly react to a specific segment
of information?

~~~
umanwizard
[https://twitter.com/Foone/status/1066547670477488128](https://twitter.com/Foone/status/1066547670477488128)

~~~
0x445442
The explanation makes it sound as if the author of one of these tweet threads
can start working on one but leave it in some unfinished state until such time
when the author can publish it all at once. If that's the case then I can kind
of understand the medium although I still think a blog post is a better fit.

------
Balanceinfinity
Learned to program assembly language on punch cards to run on the IBM 370. One
line per card - just like in the story - and you don't want to fall down and
drop your cards....imagine trying to reorganize 10000 lines of code (I like
the red line in the photos - can't recall we using that). Sometimes, the
computer just ate the cards....and no matter what, you weren't getting more
than 24 runs in a day 9assuming you stayed up all night, which we did), so you
had to really think through the code before sitting down to write it. Mine was
the last class to learn assembly on the punch cards (1983) - the next year
they wheeled the punch card readers out....but you could still only do
programing at the terminals in the computer lab....no programming in your
room. That's how I learned Pascal, machine language, Fortran, and C.

------
masswerk
Relive it here for modern languages (Python, Perl, JavaScript):
[https://www.masswerk.at/card-readpunch/](https://www.masswerk.at/card-
readpunch/)

For a proper reenactment, write you program by pen(cil) and paper first, then
punch. Let a few hours pass before execution in order to raise anticipations
to appropriate levels. Refer to your pen-and-paper listing for debugging.

------
RankingMember
Here's the entire thread compiled into an easier-to-read format in case anyone
prefers:
[https://threadreaderapp.com/thread/1201956309941116928.html](https://threadreaderapp.com/thread/1201956309941116928.html)

~~~
degenerate
Archive of that link, for posterity:
[http://archive.is/9xQlw](http://archive.is/9xQlw)

------
neovive
For those interested in the history of computer programming, "Uncle" Bob
Martin gave an excellent talk in 2016 called "The Future of Programming",
starting with Alan Turing in 1936. It's a fascinating introduction to the
evolution of hardware and programming languages. I was particularly amazed at
how Turing used CRT screens for memory and output.

The history discussion starts at around 11 min:
[https://youtu.be/ecIWPzGEbFc?t=672](https://youtu.be/ecIWPzGEbFc?t=672)

~~~
gshubert17
A version from 2019 is at:

[http://www.globalnerdy.com/2019/08/22/robert-c-uncle-bob-
mar...](http://www.globalnerdy.com/2019/08/22/robert-c-uncle-bob-martin-the-
future-of-programming-2019-edition/)

------
andyjpb
> The 7090 ran at 458.7 kHz \--
> [https://twitter.com/Foone/status/1201977408175235072](https://twitter.com/Foone/status/1201977408175235072)

That's actually _really_ fast for 1962.

By 1980 the workstation market was thinking about 3M: A megabyte of memory
(RAM), a megapixel display and a million instructions per second (all for less
than a "megapenny"). \--
[https://en.wikipedia.org/wiki/3M_computer](https://en.wikipedia.org/wiki/3M_computer)

OK, the machines of 1980 we're desktop sized rather than room sized, but, as
Foone points out, the 7090 was also really a single-user (at a time) machine.

These days you can get a similar spec (within approximately an order of
magnitude) in an Arduino: 8,000 or 16,000 kHz with 32kB (rather than the
7090's 144kB) of RAM.

Moore's law is strong but the applications are varied and sometimes the form
factor is what changes the game rather than the raw specs.

~~~
graycat
The 360/91, still in the punched card days, had a 60 ns cycle time. So that is

60 x 10^(-9)

seconds per cycle or

(1/60) x 10^(9)

Hz or 17 MHz. Not so shabby!

It read memory 64 bits at a time interleaved 64 ways. And it had IRCC 8
locations of 64 bits each of an instruction cache. Some loops could fit in the
cache at which time the machine would go into _loop mode_.

------
graycat
It may be that the plug board wiring of the IBM punched card machines was
similar to early microcode, i.e., had to work with the different signals at
different points in the cycle.

On how to program an IBM 7094? Could use Fortran. And then could use Formac,
IBM's formula manipulation compiler pre-processor to Fortran for algebraic
expression manipulation. E.g., supposedly an effort was to use Formac to
develop local solutions to the Navier Stokes equations of fluid flow.

------
ralphc
Georgia Tech, got out (we don't say "graduated") in 1984. First couple of
years included submitting jobs on card decks to the Control Data Corporation
mainframe. One day, waiting for my job to run, I hear someone say "the
computer is slow today, I had to submit my job six times before I got it
back." Wanted to slap them.

------
cable2600
I went to a community college with an IBM 370 that used punch cards. When they
got rid of the mainframe they had punch cards left over that they gave out to
students to write notes on them or study cards.

The IBM PC/XT replaced the Mainframe on a Novell Network using DOS programs.

~~~
DrScump
De Anza had a 370 in the early 80s, but I don't know what replaced it.

------
shrubble
The only problem is that APL was running in interactive mode by late 1966 on
far smaller systems like APL/1130 which ran in about 8K.

Then soon after APL/360 was also available for the 360 line. Multiple users
could sign on at once and run commands intetactively.

------
leoh
Computation was extremely expensive back then. Was it typically financially
beneficial?

~~~
TheOtherHobbes
Computation was so financially beneficial that performance could be trimmed by
a couple of orders of magnitude, and people still found it beneficial as long
as it was interactive.

For any application that didn't require scientific supercomputing, a
mid/late-70s 8-bit interactive command line microcomputer with 16K of memory
and paper tape or cassette storage was far more financially beneficial than a
7090 or System360 - not just in terms of cost, but in terms of the ability to
get useful output in a quick-enough time frame.

Speeding up the development cycle and simplifying data entry was more valuable
than raw processor speed. The metric that mattered was problem throughput, not
clock speed. Some problem classes were cycle-bound, but many weren't - and
still aren't.

~~~
leoc
And business calculations at many companies were automated or semi-automated
by tabulating machines before those were finally replaced by fully
programmable computers. The IBM 1401 released in 1959 was designed to make
inroads into that market as a drop-in substitute or upgrade. Earlier computers
would probably not have been financially viable in many of those roles:
[https://www.youtube.com/watch?v=ZPpV8X91neQ](https://www.youtube.com/watch?v=ZPpV8X91neQ)

------
forinti
One product I think could have had success in the late 70s and 80s was using 8
bit micros as a pre-processor for COBOL. You could type and verify the syntax
using a micro before you would submit the code to the mainframe.

~~~
rbanffy
A lot of data entry jobs in the early 80's was done on 8-bit computers that
wrote the data to 8" floppies that were then read by the mainframe. Some other
setups had tape output. I interned at a company that did input to tape, which
fed an IBM 4341.

That lasted a couple years.

------
JoeAltmaier
I learned programming with a terminal on an HP2000. It had a serial link to
our IBM 360.

College class assignment - punch a deck with a simple program, submit it and
turn in the deck and output.

So I would type my programs in, submit a punch job to the IBM, get the deck
back, add JCL and hand it to the operators to run.

This was required for class. But I forgot the step where you had the program
printed on the top of each card - they called that 'interpreting'. I handed in
a blank deck to the TA. Fortunately they never noticed.

------
gumby
This shows how advanced Doug Engelbart was that he imagined interactive
editing and real-time use back in 1950s.

Also shows how far-sighted ARPA was back then.

------
sevencolors
Was curious how a statement was converted to punches. Found this.

[https://craftofcoding.wordpress.com/2017/01/28/read-your-
own...](https://craftofcoding.wordpress.com/2017/01/28/read-your-own-punch-
cards/)

Imagine only programming with 64 CHARACTERS :)

~~~
vermilingua
Can imagine that quite easily really, only characters missing from that list
that would be used often would be curly braces.

~~~
kps
Unless your shop only had the commercial version, so your A(I)=B(I)+C(I)
looked like A%I¤#B%I¤&C%I¤.

------
gorpovitch
Mandatory mention [0] of the amazing talk of Uncle Bob "The Future of
Programming", and his timeline of programming since Turing. Fascinating
conference

[0]
[https://www.youtube.com/watch?v=ecIWPzGEbFc](https://www.youtube.com/watch?v=ecIWPzGEbFc)

------
utf985
Surely this is better suited for a blog post rather than a series of hard to
follow twitter comments.

------
GEBBL
How interesting that that is the reason for the 80char limit default setting
of many terminal apps!

~~~
strathmeyer
It was the common character width of a page on typewriters.

------
msluyter
This is all incredibly fascinating, but was anyone else's first thought "geez,
look at those incredibly uncomfortable chairs/desks. How did they manage?"

------
mekkkkkk
What was the process of debugging these programs? Did you get any sort of
error code or card number that gave you clues as to what had gone wrong?

------
ggm
Still have mine. Stopped using them for notes still use as bookmarks.

132 column lineprinter paper was made for kindergarten

------
asdfman123
This post is great. I've never understood why they used punchcards in the past
until now.

------
jankotek
My father used similar punch cards at his works way into 80ties (socialist
country). Every shopping list in my childhood was written on those

~~~
tapland
Why the socialist country comment? They weren't mass replaced until the 80s
anywhere.

~~~
ncmncm
My (state) university abandoned cards and scrapped its mainframe and punches
in 1980. The punches were unwanted anywhere. The most prized parts of the
mainframe, a CDC 6600, were the smoked-glass doors.

------
doggydogs94
Don’t forget the distinctive aroma of the computing center.

------
layoutIfNeeded
“So whatever device you're reading this on either has a direct linage back to
a 7090 (with Android/iOS/macOS/Linux being varieties of Linux)”

Yikes. macOS & iOS has nothing to do with Linux.

~~~
samplatt
Oh, so what if it's not a direct descendant and only a cousin? It shares
enough DNA that people looking at the structure would assume common elements.

~~~
mtrower
It's like saying the Taurus, Camaro and Camry are all varieties of Mustang.
The statement is false. Those are all varieties of cars, or automobiles - but
not varieties of Mustang. Similarly, the listed Operating Systems are not
varieties of Linux...

~~~
timbit42
Seems obvious he meant they are varieties of Unix.

~~~
mtrower
Maybe. I've met an awful lot of people to whom such a distinction is just not
obvious. People who would, for example, assert with perfect sincerity that
MacOS is built on Linux, or that Solaris (or OpenSolaris, or Illumos, etc...)
are the same thing as Linux. It may have been a typo, or it may not have been.
The person I was directly responding to didn't seem to think so.

Anyway, that's where the sentiment is coming from.

