herbie@watdcsu.UUCP (Herb Chong, Computing Services) (11/25/84)
-----------------------
When I was 5, my dad rented a keypunch, and I THOUGHT I was
playing on a computer as I merrily wasted cards....
-----------------------
Oh yeah, that first 7090 program worked right the first time,
then I tried to improve it. It never worked again.
-----------------------
I remember reading about spooling and thinking it didn't sound
very practical; we only had one disk drive....
-----------------------
The level of expertise among the operators (of which I was one)
was measured by two scales:
1) How fast you could stop the disk without burning your fingers.
Remember, both systems are down.
2) How big of a stack of cards you could pick up and put in the
reader without dropping them. If you dropped a lot of cards you
were in BIG trouble because all of the sorting was done in
another room.
I got really good at lining up forms on the 1403 printer because
if I didn't get it right the first time I had to cancel the job
and start feeding all the cards in again.
-----------------------
In the mid '50s I sent decks of cards (by automobile) from the
University of Rochester to Cornell's Card Punch Calculator (CPC).
The memory consisted of the holes in the cards which were passing
through it. If you wanted a piece of data preserved, you punched
it from a card about to leave into an entering card.
-----------------------
I remember the day lightning hit the computer center and my 2741
nearly snapped its bands! The AED compiler that had OCO
diagnostics: it printed the program in metalanguage and
pronounced ERROR. Multics was beginning to coalesce out of the
cosmos; 8K memory expansions [came] in 6 foot racks; computers
had lights and they went almost slow enough to read. Someday we
must all get together and raise a glass.
-----------------------
Later I learned about assemblers and life got really easy. My
oldest machine was a Standard Telephones and Cables ZEBRA, with
drum main memory (6,000 RPM) and a telephone dial as the
operator's console. It was really good at working out which day
of the week you were born, given your birthday.
One of the operators could get the main ledger update through in
about one quarter of the time it took everybody else. Eventually
we discovered that his secret was to get the transaction files
and manually select out from the main file just those records
that were due for update. He'd then run the update and then
merge the updated cards back into the main file. The last I
heard, he got promoted.
-----------------------
After the 650 I moved to a 1620-I, also known as CADET for Can't
Add, Doesn't Even Try. This was at least a transistor machine.
-----------------------
We ran disk spooling to the 2311 using a tail-chasing algorithm
that ate the beginning of a job if it wouldn't fit. Worked great
until you needed to restart the job!
-----------------------
The things I remember about it [the IBM 1620] were the console
typewriter and the card reader/punch. The typewriter had real
keys and type bars (none of this modern selectric typeball
nonsense). As a result, it often managed to get several letters
in motion at once and jammed frequently. The Fortran compiler
was two pass; the first pass punched cards which one then loaded
back into the reader for the second. I remember that one often
had time for lunch while a large compile was running. (Anything
over 50 lines of Fortran was large.)
We also had an old machine, still operational in '61, called
SWAC--Standards' Western Automatic Calculator. It was one of the
first of the stored program computers. All tubes, of course.
Memory was a Williams tube--sort of two CRT's with the screens
glued together--one gun wrote the bits on the screen, the other
gun on the other side read them out. I think there were 256
words of main storage.
-----------------------
My first CPU was also an HP-2000 running Basic. It had the most
interesting COBOL that was written in Basic (ugh). I played with
the COBOL for nearly 6 months, but never got it to work all the
way.
-----------------------
We had the usual complement of goodies, like SONG (which played a
variety of melodies using the hammers on the 1132) and TSONG
(which played several others using the CPU and the core array as
the tone generators and an AM radio sitting atop the CPU as the
output device). A cute point about the 1442 is that it has a
single feed hopper, it was either a reader or a punch (but not
both) at any one time. As a result, another inevitable toy was
CHOMP, which, when invoked at the console (via GRIN) turned it
into a punch and punched out all the holes in every card.
We also had the infamous Spanish BASIC, with its Spanish
keywords.
-----------------------
You were considered an experienced user if you could tell whether
or not your compile worked by the sound of the disk and printer.
At 60 lines per minute, the printer was probably working about
the same speed as the disk.
C27 Syntax error in FORMAT statement!
C07 variable name longer than 5 characters!
D06 Entry point already in LET/FLET!
-----------------------
P. S. What am I bid for listings of the original PDP-1
SPACEWAR?
-----------------------
If the interpreter found a syntax error while reading one's card
in, it would beep. I knew I would be good in computer science
because my cards beeped less than anyone else's.
-----------------------
We used FORTRAN without FORMAT statements.
-----------------------
It ran the first time. If it hadn't I'd be a starving musician
today.
-----------------------
Of course all arrays were two dimensions max, and space for both
the BASIC text (tokenized) and data was 10K 16-bit words, but in
eighth grade, paper tape, ASR-33's, and acoustic couplers at 110
baud were all sheer magic, so what did we care?
-----------------------
I programmed a UNIVAC I in machine language (that is
numbers--none of this fancy high-level stuff like assembly
languages). Ah yes, no messy operating system to worry about.
It was a million dollar personal machine. You signed up for an
hour of machine time, loaded your tape onto the tape drive, set
the console switches, booted, and off you went. You listened to
the loudspeaker (on the high-order bit of the accumulator) to
tell how well the program was doing. That was a real computer;
you could walk inside the CPU. It had 1000 words of memory. Of
course, those were real words: 48 bit (or was it 64 bits?).
You did real programming of this beast. None of this structured
stuff. You wrote code to save space and time, and you learned
how to make the program modify its own code so that one
instruction could be used several places in the code, as
different instructions (it wasn't any easier to do than to say).
-----------------------
My first program was in BASIC, a very simple game of some sort
(eg. like moon lander). As I was a completely hopeless typist,
I had a very trying time. Eventually I had my mother come to
school and type the program in for me. After that I decided that
programming was a complete waste of time, and didn't go near a
computer again until my first year....
-----------------------
In eigth grade (1970) I typed my first text into a computer: "WHO
WAS THE FIRST PRESIDENT?" The response was "WHAT?" so I typed it
again. After the second "WHAT?" I looked up at my teacher who
explained that computers only know what they are programmed to
know. He then introduced me to BASIC.
-----------------------
This brings back memories (nasty ones), even though it's only
been a few years ago. I started on a CDC Cyber 6000 learning
Fortran IV on punch cards in 1979. It wasn't until a year later
that I found out that I could have used the 300 baud terminals in
the same room. When I finally did get around to using terminals,
I found out that interfacing directly to CDC's NOS operating
system wasn't any more enjoyable than submitting batch jobs by
cards.
-----------------------
It was the computer at my high school, and if the "night man"
felt like loading the compiler, he'd run the programs. Maybe.
Turnaround time was usually overnight, but frequently longer.
-----------------------
We also had a Fortran simulator written in BASIC that would
execute 1 Fortran statement every 2 seconds.
-----------------------
The fun came the day we found the sysopr password and tried a few
of the more interesting commands in the book. It took them three
days to bring the system back up....
-----------------------
The machine had a digitizer which required realtime response and
a great deal of memory. Every morning at 10:45 they would turn
on the digitizer, and every morning at about 10:55 I would get a
frantic call from the staff "Log off, log off!! We're trying to
save the system." It would crash, of course, about 11:00. Then
they'd bring it back up and everything would be fine.
-----------------------
I used the Johnniac, a vacuum-tube machine built at Rand along
the Princeton design. I think it was about the fourth general
-purpose computer built. It ran JOSS (Johnniac Open Shop
System), an interactive language which predated Dartmouth BASIC
(falsely claimed by its developers to be the first time-sharing
system). I first used it in about 1965, well after most other
vacuum tube machines had been abandoned.
-----------------------
When you had a subscript out of range it dumped core--onto the
printer--including all 64 KB modulo sections of core which were
zero.
-----------------------
In the machine language every statement had a "next instruction
here" section to mitigate the problem of loading instructions and
data from the drum--essentially every instruction was a goto!
Arithmetic was integer bit serial, though software floating point
could achieve as much 3 FLOPS....
The G-15 resembled a coke machine--complete with neon lights on
the front panel.
-----------------------
I programmed the Royal McBee LGP-30. It was the first computer
at the University of Saskatchewan (1959) and was a drum-and-tube
machine with a 16 instruction set that had mnemonic HEX codes so
a machine language program looked like assembler code.
-----------------------
The first machine I programmed was a home build one that looked
like a PDP8. It was made of DEC modules in 1964.
-----------------------
I wrote my first program for the Silliac at the University of
Sydney (Australia), a clone of the Illinois Illiac, in 1957.
Silliac used punched paper tape input and output, and had 2048
words of cathode ray tube memory. There was no assembler
language. It was like scratching your calculations in the dirt
with a stick.
-----------------------
The 610 had a five-column paper tape reader on which the program
resided to be read instruction-by-instruction. A loop was made
with scotch tape.
-----------------------