Seems like we are all contributing old card stories.. here is one of my
favorites from my past.
At CMU, all systems programmers working for the computer center had to put
shifts in as the operator behind the "glass door" doing the grunt stuff
(but we got all the computer time we wanted, an office and terminal - so it
was a good deal in those days). The student courses, in particular the
engineering intro to FORTRAN (WATFIV), used the TSS based 360/67 which we
programmed and ran; but they used the batch system on cards not timesharing
with the ASR 33's which was quite expensive. There was a traditional glass
room with the computer, its tapes and other gear, and a counter with a
"call human for help" button where "paying users'" could come ask questions
of the operator on duty. On the older side of the counter was the flock
of keypunch machines and a high speed card read. The printers were in
secure areas, so we would bring out student prints from their batch jobs as
needed and put them on the binds near the counter ( as was the pretty much
the standard of those days).
By rule, the system's programmers were also not supposed to help the
students with their assignments. They were supposed to get help from their
TA's and Profs, *etc*. who had regular hours. But often folks were up
very late working on assignments and no one from the course was around to
ask questions. And as the operator, if you had a minute, it was not
uncommon to have a little empathy for your brothers and sisters in arms on
the other side of the counter. As long as this was not abused, the TA's,
Profs as well as our bosses in the computer center tolerated the process.
But if we were obviously busy, we really did not have the time to do much
to help them.
One night I was working the over night operator shift with another coworker
who will be left nameless (but I will say that he's now a SVP at a large
computer firm these days). It was a very busy night for us for some
reason, probably something like printing bills, or checks for the school or
some such; along with a full backup, so we had our hands full between
mounting tapes, changing types of paper and print heads *etc.*, security
procedures with the results and the like. That night, there was also a big
assignment due shortly for one of the classes.
Sure enough the buzzer started ringing and it was a frustrated (and as I
remember somewhat clueless) student that needed help with his assignment.
He was claiming that the his deck was being rejected/was not working.
Note "turn around" from deposit card deck to receipt of print out was
probably in the order of 10-15 minutes, and sometimes longer. One of us
came out, showed him something like a missing "BATCH WATFIV" command card
or some such and reminded them of the official policy and probably pointed
to the sign, as we were very busy with our job. We would politely tell
them to try to find a TA or someone in the class that could help him.
The student went away, and we went back to work. A few minutes later the
buzzer went off again, same student, and the cycle repeated with some other
trivial issue. After the 4th or 5th time it was becoming a real issue
because we were really quite busy. At that point, my coworker came out and
said, here bring me your deck. He looked at them and quickly said -- "The
problem is you used the wrong color cards."😈
The student was completely dejected and walked away. I looked up and
said, man that was cruel. But it did buy us time to finish our work.
Never found out if he re-keypunched his cards.
Clem
Steve Johnson:
This reminds me that someone at BTL threw together a "TSO Shell". It was
a wrapper around /bin/sh that slept for 10 seconds before executing each
line...
=====
And after each command exited. Discarding anything typed ahead
during the sleep, of course.
And printed all-upper-case IEFCRAPNONSENSE messages even when a
command exited successfully.
I think I still have a copy somewhere. It dates from the 6/e era,
so it would need a lot of work to compile and run on a modern system.
Occasionally I think of converting it to ISO and POSIX even though
that seems contradictory somehow.
Norman Wilson
Toronto ON
Not quite a self reproducing program and I did take down one of the UCSD servers one day.
I was writing a shell script to do some complex and long running task. This was in the early days of the shell supporting functions. The script had a large number of functions and I named one of them to be the same name as the shell script.
I set it in motion and logged out, as I knew it would take several hours to finish the work.
The next day I logged in to find that the machine had the load spike as the shell script recursively started itself when it got to the function call that had the same name as the shell script. The admin kindly sent me a ‘top' output showing the load at several hundred and all the jobs having my name and being my shell script.
Under this he wrote: “Never do this again.”
I haven’t.
David
> Btw. It does not emulate the smell of small machine oil
or the mess of ppt punch chaff on the floor
Yes. I saw Clem's mail just as I was about to recommend
placing a small dish of machine oil beside the simulator.
Alas, it seems I missed out on the chad experience. Data was
regularly imported to the PDP-7 by ppt, but rarely exported.
Night-owl Ken must have taken some ppt backups, evidence of
which the midnight janitors whisked away.
Doug
It's a bit off-topic, but what were non-Unix filesystems like around 1969-1970?
The PDP-7 filesystem has i-nodes (file metadata) and filenames separate
from the i-nodes. This allows hard links and thus a non-tree structured
filesystem.
This has always struck me to be one of the most important features of
the Unix filesystem: names separated from the rest of the file metadata,
and arbitrary hard links so that there is no preferred filename.
Were these features in other contemporaneous filesystems?
As a side note, the PDP-7 kernel knows about the top-level directory ("dd")
but it is agnostic to the concept of "." and "..". What that means is
that you can build a filesystem with "." and ".." links and the kernel
will deal with them as per all other links. But you can also build a
filesystem without "." or ".." and the kernel doesn't care.
There's not enough evidence (source code, papers, anecdotes) to confirm
or deny the presence of "." in the PDP-7 code that Norman scanned for us.
".." does seem to exist as it is mentioned in one source file, ds.s.
It's an intruiging mystery.
Cheers, Warren
This came up today at work; what's the origin of the open file table? The
suggestion was made that, instead, a ref-counted data structure could be
allocated at open() time to serve the same purpose, and that a table of
open files was superfluous. My guess was that this made it (relatively)
easy to look up what files referred to a particular device?
> Those file structures are collected into a single, global table. The
> question is why this latter table? One could rather imagine an
> implementation where open() allocates (e.g., via malloc())
Depending on how malloc() is implemented, fragmentation can be
serious in a program that runs forever with as many frees as
allocs. Separate allocations for each item can also be costly in time.
One malloc() strategy is to divide the arena into regions,
each of which caters for blocks of a single size, so
fragmentation doesn't occur. In essence that's how the
system tables work, except that these tables have
hard limits. Now, if the tables could be reallocated
as needed ...
Another problem with per-item allocations is performance
monitoring and debugging. It's hard to see what's
going on in a well mixed dynamic storage heap.
Doug
https://newsroom.intel.com/news-releases/andrew-s-grove-1936-2016/
I know some of the processor people at intel and I was looking around,
found this, interesting read if you are into the history:
http://people.cs.clemson.edu/~mark/330/chronques.html
For those that don't know, Colwell did the P6 pipeline, I think under
Groove or right after Groove got cancer. There was P5, then P6, then
they did a different pipeline that they called Pentium 4 (made no sense
to me but their names never do). The Pentium 4 was the one where
they speculated on what the answer would be for some instructions.
As in you could do a load and they'd guess that it was zero or not.
They were going for great clock rate, and they got it, but they also
got instructions that would take 2000 cycles to get through.
That pipeline got booted and so far as I know, the Colwell P6 pipeline
lives on in every Intel processor after the Pentium 4.
Getting back to Andy, I loved his time as CEO, I think he did a lot of
good for that company. Here's to him!
Sorry to continue the detour from disk file systems to card trays, but this
> Walking down the corridors of Comp Sci, a student in front of me
> dropped his entire deck of approx 2000 cards, all over the floor...
> I have no idea whether he got them sorted, but I sure as hell used
> rubber bands after that!
reminded me that Vic Vyssotsky liked to say of his BLODI (block diagram)
language for simulating sample-data systems that it was the only card-safe
language. You could toss a program deck down the stairs, pick it up at the
bottom, submit it to the compiler, and it would work. That was 10 years
before the filing of the famous "natural order" patent on spreadsheets,
which ordered execution the same way.
Doug
