My trip down memory lane leads me back to TOPS-10 and the PDP-10

May 17, 2011 | Computer Science | By: Mark VandeWettering

I’m going to be nostalgic for a few moments. If you are too young to have any sense of nostalgia, skip ahead to the bold text below. You were warned!

A few days ago, I mentioned that I was having a bit of flashback, thinking of my first experience with time sharing computers back in the early 1980s. I was a child of the microcomputer revolution: I remember reading the articles on the Altaire and the COSMAC ELF in Popular Electronics (I was a precocious 12 year old at the time) and would eventually buy my first computer (an Atari 400) in 1980. By 1982, I was attending the University of Oregon and got my first exposure to “big” timesharing computers: their DEC 1091 (running TOPS10) and their IBM 4341.

I must admit, I wasn’t all that impressed at the time. I did take FORTRAN and COBOL classes though. I actually did JCL and punch cards on the IBM. I worked in the documents room at the Computing Center for a while, and I recall that I made some small modification to their software (in FORTRAN on the DEC) that kept track of check ins and check outs. It may have been the first time I was ever paid to program.

My recollection is that by late in my second year, I was obsessed with the idea of getting an account on one of the three VAX 11/750s in the computer science department, all of which ran BSD. To do that, I needed to start taking graduate level classes. So, I applied for them. I recall sitting in Professor Ginnie Lo’s compiler class on the first day. She asked me if I was a graduate student, and I replied “no”. She then asked me if she had given me permission to take her course. I replied (somewhat nervously, as I recall) “no”. To her credit, she allowed me to stay.

I digress.

Anyway, after getting accounts on one of the department’s Unix machines (and having access to another via my job in the Chemistry department) I found little reason to continue using the DEC 1091. I doubt that I used it more than a couple of times after 1985.

Which, in retrospect, is kind of too bad. The 36-bit DEC architectures were a significant part of computing history. The PDP-10 had a pretty nice architecture, with an interesting, symmetric instruction set. I didn’t have any appreciation of it back then, but with the wisdom granted by experience (and no doubt a certain amount of nostalgia) I find that it is actually pretty interesting.

So… I embarked on a mini-project to recreate the environment that I dimly remember.

Luckily, you don’t need a physical PDP10: there are emulators that do an excellent job of recreating a virtual PDP-10 for you to program. I am using the simh emulator which is actually a suite of programs for a wide variety of early machines. The latest version of TOPS-10 was 7.04, but in experimenting with it, I found that I had difficulty making their simulated “printer” device work properly. Besides, v7.04 was actually a bit later than when I used the DEC. So, I’ve instead gotten version 7.03 up and running (which dates to around 1986).

Using the online documentation from various sources, I got the installation tapes up and running, and created a simulated system with a single RP06 disk drive. The printer is emulated just as a text file: I was thinking of creating a gadget to store them in individual files which we could view from a web page. I don’t recall anything of our networking with the 1091 (I suspect we had DECNET at the time) but TOPS-10 didn’t support TCP/IP anyway, so networking wasn’t a priority. I’ve installed BASIC and FORTRAN, as well as the TOPS-10 KERMIT tape. Of course you can program with MACRO-10 as well. I’ve got their DECMAIL system installed, but it has difficulty working without DECNET installed, and seems to require a patch. I’ll try to get that working shortly.

Eventually, I’ll get some games like ADVENT online. I created a single user account, but don’t remember some of the finesse points of creating project defaults and SWITCH.INI files. I also seem to have forgotten the logic behind SETSRC and the like, but it will come to me. I never was a TOPS-10 operator, so most of the systems level stuff is new to me (but luckily fairly well documented). For now, I can login, run BASIC programs, edit, compile and run FORTRAN and simple MACRO-10 programs, and… well… logout.

Okay, why do this?

I’m not actually one of those guys who is overly nostalgic. I stare at my iPhone, and I am amazed. I don’t want to trade it for a PDP-10. But I also think that the history of technology is fascinating, and through emulation, we can gain insight into the evolution of our modern computers by actually playing with the machines of the past.

Here’s one obvious insight: this was a time sharing operating system. It seems in many ways the bulk of the system was actually designed to do accounting on the amount of various things that you did. There is all sorts of mechanism for tracking how much CPU you used, how many disk reads and writes, how many cards you punched, and how many pages of line printer output you sent. There was a well defined batch queueing system, so that you could use every bit of available CPU to maximum efficiency. It imagined that there would always be a trained operator on duty to service the machine. In that sense, it is completely the opposite of what we saw developing from the personal computer world: when CPUs became cheap enough, it was obvious that you’d just have one, which you could do as you see fit. If it sat idle, well, it was your computer. But those early personal operating systems didn’t really have any support for multiprocessing or memory protection. It took quite some time for that to trickle into the personal computing world.

It’s also interesting to compare it to an operating system like ITS (which you can also run in emulation), which was developed in a purely academic environment. All of the accounting stuff I mentioned above are completely absent in ITS: the ITS system was designed to basically present a virtual PDP-10 to everyone who was connected to it. There was very little to protect you from mistakes that either you or someone else could make. The command interface was just DDT: the PDP-10 machine language debugger. ITS was an important step in the evolution of computer operating systems.

You can learn about these things by reading books about them, but playing with them will undoubtedly give you some insights that you can’t get by books alone.

Is anyone else interested in this stuff? I’m considering making a virtual PDP-10 available to the public for mucking around with, and maybe even typing up some short notes on how to do common tasks. I’ll probably also try to get a version of ITS running in the same way.

I’ve thought about maybe trying to scrounge some old VT100s (maybe four of them), wire them up to a modern small computer running simh, and creating a virtual system that you could bring to appropriate conferences like the Maker Faire. Kind of a “Computing Time Machine”.

I’ll think about it some more. If anyone else has similar interests (or could mentor me on the ways of 36 bit computers), drop me an email or leave me a comment below.

Share Button
Be Sociable, Share!

Comments

Comment from Rupert Goodwins
Time 5/17/2011 at 12:21 pm

I did my first programming on punched cards that our maths teacher took down to the local polytechnic once a week after Computer Club. I can’t remember much about them; I was twelve and fiercely agin digital stuff (which was remote and mysterious and utterly unobtainable) and in favour of radio (which was also mysterious, but I could get for free by taking in abandoned valve sets and building stuff out of some 1950s Wireless Worlds that a friend of the family had given me because I could talk of nothing else). The cards were fed into a Prime, which disgorged a gratifying sheaf of green-lined fanfold in return. Fast forward four years and I had my ticket (G6HVY, about which I remain inordinately happy) and a ZX81 kit bought from a summer job fixing TVs in a backstreet repair shop. Which also did a nice line in illegal CBs, about which I shall say nothing.

Fast forward another four years, and I had a wife, a small child (hey, why not) and a PDP 8/A in the attic, running TOPS-20 off twin Decassettes. And core store. I was cutting Z80 for a living, and was dimly realising – via a TNC and a converted taxi radio on 2 metres – that although digital was not so mysterious but quite wonderful, and that radio was even more magical than I had at first thought, if you put the two together… why, there might be something in that.

Except for the callsign, all of the above have long since departed. The kid’s doing fine, and I do wish I still had that PDP 8/A. Digital and radio proved really quite well suited for each other, and there’s even more magic and mystery to distract me from the stuff they pay me for. But the things I learned by flipping bits and saving T-states, and by seeing the PDP *run two things at once* (how on EARTH?), still serve me well.

It’s interesting, those comments about an OS devoted to micromanaging its own resources. It puts me in mind of the OSI/ISO TCP/IP wars, where things like X.400 were designed by committees of Big Company telco-ites to be rigorously compatible with the layered control-minded bureaucracy in whose service such things were rightly to be retained. SMTP et al were smart, quick, dirty and unrestrained – if you wanted to do the job, it was there to help you. Both could profitably have learned from each other, but I’m so glad the long-hairs won. If only for a while, perhaps.

Comment from Mark VandeWettering
Time 5/17/2011 at 1:01 pm

Heh. Nice nostalgia, Rupert. My own list of machines goes from Atari 400, to using the IBM 4341, DEC 1091, the VAX 11/750 and a MASSCOMP, to finally owning my own computer again with the 486 and higher, running mostly FreeBSD and Linux.

I still have my original Atari.

Comment from DC Stultz
Time 5/17/2011 at 2:56 pm

Thanks for the trip down memory lane. I worked for DEC for a short time and was responsible for the PDP-10 at Cybernetics in Ann Arbor, Michigan. I also installed a PDP-10 at the UofM in Ann Arbor. I started out on the RCA 301 at their plant in Palm Beach Gardens, FL, then went to CDC to work on the 6600 in Albequeque and Toulouse, France. After DEC, I worked for Univac on the 1108.

All in all, I spent 41 years in the computer business and only dropped out last year when I got the ax at age 71. Spent the last decade designing/coding interactive web applications in Perl. It was a good career and I did a lot of things that I am proud of.

Comment from Mark VandeWettering
Time 5/17/2011 at 3:29 pm

Wow. Cool. It’s hard to remember that the history of computing has unfolded in just a single lifetime, and it looks like you got to see a lot of it. :-)

Comment from kiwimonster
Time 5/17/2011 at 3:36 pm

Some context: I met Mark at the University of Oregon and we’ve been friends ever since. We would eat pizza and play Mule on his Atari.

As an undergrad, I worked as a student operator of the 1091, maybe just before you were there, I had better access to it than you did, and taught myself a lot of interesting things with it. I think my biggest personal project was a chat client (no network) circa 1985 before graduating and heading to the CIS graduate school. I did some development work with a big space battle game (text based) written in Pascal. They eventually got a C compiler for it, but the architecture of the 1091 with its 36 bit words (4.5 bytes) was a strange bedfellow to a language more designed for character processing. Character pointers were weird things indeed.

I don’t recall much about the operation of the system. We had a book with all of the procedures documented of everything we needed to know, from how to deal with a request to mount a tape, to how to call the fire department. The best procedure was labeled “punt”, which is where all the other procedures ended up when things didn’t work right. I never got to “punt”.

My user number was 443. I hope they retired it.

I never did much with the IBM 4341. It was a dull machine to work. Run jobs (very much a manual batch system), feed decks, mount tapes, rip output. When it was slow, tell the students why their programs sucked so much. My biggest programming effort was a Fortran program to do arbitrarily large integer math so I could calculate and print out the largest perfect number known at the time. It took almost an hour of run time ($$$), and was about three pages of digits if I recall correctly. Such a program would run in the blink of an eye nowadays.

Networks came later. The 1091 had no network when I used it, just a morass of serial lines throughout the campus. Modem based uucp stuff and related first, local ethernets with bizarre protocols next until we upgraded the VAX750s with 4.2BSD, and TCP/IP took off and never stopped. Don’t get me started on the ISO debates – I worked for Intel designing computer networks during that time, and had a lot of arguing to do with people whose only network knowledge was learned at trade shows. I like to claim I bought the first cisco router for Intel, and it may even be true. I still have a copy of the quote somewhere.

For nostalgia, I made a stab some time ago at creating an emulator of my first real computer: an HP 2000 Access system, upon which I learned BASIC, circa 1975 before I was in high school. Microcomputers didn’t exist then. I still have many of the programs I wrote in high school for that system, loving punched out on paper tape, including a chat client that allowed us to chat with students at other schools, and generally cause mayhem. Things like Atari seemed more like toys in comparison, even if they could go faster than 300 baud. I never finished the project.

Comment from Eric Smith
Time 5/17/2011 at 5:43 pm

I’ll gladly trade my iPhone for a PDP-10! Where is there one available for trade? :-)

I do have a non-working 2020 (KS10) and hopefully enough spare parts to get it working, and a 2065 (KL10, same hardware as 1095). I need to get some raised flooring and AC for the 2065, and hack up a Massbus disk emulator. (I’ve got some RP06 drives, but don’t want to spin them any more than necessary.)

I’ve got a design for a replacement regulator board for the ECL power supplies (nine -5.2V 35A regulators and four -2.0V 35A regulators) that works in simulation but hasn’t yet been built and tested. The original power supply was linear, running on a 12.6VDC first stage, so the replacement switching regulators should cut the power consumption dramatically.

Comment from Mark VandeWettering
Time 5/17/2011 at 8:13 pm

Hey Jeff. thanks for chiming in with an “old guy” story. :-)

I knew you achieved loftier levels of success with the 1091 than I did: my short cut to Unix curbed my enthusiasm (perhaps just a bit unfairly) for the DEC.

DIgging around for a few minutes, I found this page on the HP2000 Access, and this one, which seems to have source to the four user time shared basic. If I read this correctly, the HP2000 was actually an HP2116A, which is one of the architectures simh was supposed to support. I wonder if anyone has ever got this running?

Comment from Mark VandeWettering
Time 5/17/2011 at 8:15 pm

Hey Eric, I figured I might draw you out with this topic. :-) I suspect I’d trade my iPhone for a PDP-10 too, because I know I could make a profit selling it to you. Hehe.

I am not nearly dedicated enough to actually try to levitate such old hardware, but I am glad people like you are still around to do so. I’ll just learn what I can from the virtual architecture.

Comment from Mario Impronta
Time 5/18/2011 at 12:01 am

Totally awsome to see these stories, so here goes my own true one, and sorry I hadn’t the time to make it shorter…

A small techie adventure

Rorschach’s diary, 1982 Q1-Q4.

As an Electronics Engineering student by 1982, in Rio, I used to spent most of my time in college’s computer lab, instead of attending classes (shame on me #1). At first, as a FORTRAN user on a PDP-11/70 running RSTS/E, to have the nice pleasure of seeing my programs in a video terminal (two years before I used to punch them in cards, as a high school part-time job, in a Burroughs B1700). Then some DEC BASIC and C, and lots of VT-52 cursor-addressing programming… For that whole year, I remember having learned, besides computing stuff, just how to swim in college athletics classes.
(Calculus and Linear Algebra were promptly left behind.)

Rorschach’s diary, 1983 Q1-Q4.

Then, the Computer Science department bought 8-bit CP/M microcomputers (48kB ones!), to which I became promptly addicted. Besides the usual BASIC and Pascal (UCSD P-code, anyone?), I went deeper into assembly language (M80 macro-assembler, anyone?) and even disassemble the whole OS (DDT/ZSID, anyone?) to understand its inner secrets. I was feeling like a little kid when bought my first (and only for a while) 8-inch 128KB floppy disk – it was a really floppy Memorex one – and that disk was my partner thru my freezing 14-hour days in that lab. I eventually stepped out for having a meal, or swimming. Those were the days!

Of course, as an Engineering guy, I was a foreigner in Computer Science Lab, which led to some scheduling conflicts with the local students (shame on me #2: they were, unlike me, just on their academic duties; I was having fun).

Unfortunately, those conflicts led to a “wired-fence policy” – to my dismay, those nice 8-bit jewels became locked (literally), so only locals could access the room. The world I had learned to love and being immersed into the last 12 months was put beyond my reach.

Pain, despair, betrayal feelings.
(Not to mention Calculus was becoming a waning memory by then…)

Rorschach’s diary, 1984 Q1.

But then I saw the light: if they don’t allow me to enter the room anymore, to access those wonderful machines… I will manage to simulate them in another computer! I had learned enough about the machine’s hardware and software, so I would just need a bigger computer, powerful enough to do the task.

Fortunately, in the room next door, there was another computer lab with mainframe terminals I could have some access, due to an invaluable friend who lent me an account (tks, PL). It was the same PDP computer which formerly ran RSTS/E, but now with a strange, minimalistic, lower-case oriented system: Unix. Well, I said to myself, it is weird, but that’s all I’ve got… so let’s study it to extract the most of it – an emulator has to be truly efficient, so C and assembly would be the way.

Not only C and the host processor’s architecture should be mastered, but also the operating system’s inners, for deeper understanding and additional performance. Another immersion therapy seemed necessary. Then I bought a pen and a small notebook, and, every afternoon at the CS library, I started to copy, by hand, the Unix manual, sections 2 and 3 (kernel system calls and C library) – I had no money for photocopies anyway – and that seemed a way to force me to truly understand it, by forcing a “slow reading” process into my brain.

It worked. In three months, my Z80+CP/M emulated machine was running smoothly (almost as fast as the original ones), the emulator itself being PDP-11 assembly-coded in a Unix host system, on a CP/M virtual disk whose image another invaluable friend managed to provide me (tks, JC). I had even to develop a cross-assembler in C to ease BIOS code building – and I did it in a Forth-like stack oriented syntax – quite weird, but functional.

I was amazed when some friends, even smart ones, didn’t seem to understand what I had accomplished with that personal project. Emulation/virtualization was not a widespread concept by then, so they started wondering how I had connected my terminal to the other room, the 8-bit lab. :o)

Rorschach’s diary, epilogue.

It was a small victory, after all, but which indeed made me feel in a way better described by Asimov’s nice short story title: “The Feeling Of Power”. It boosted up my nerdish fragile ego, and allowed me to see something else, much more important.

I have met Unix. And got contamined. I still am, after 25 years, but I doesn’t hurt.

(Calculus became long-forgotten now. Is it about Newton? Is there an analogous world?)

Comment from Mark VandeWettering
Time 5/18/2011 at 7:39 am

Wow. Neat story! I do remember UCSD PASCAL/p-code: we ran it on Apple IIs for some of our introductory computer science courses. I never had access to a PDP-11 (or a PDP-8), and CP/M only drew a glancing blow on me (never had enough consistent access to one to make it worth my time).

Of course, simh can simulate 8080 and Z80 based machines that can run CP/M. I’ve run yaze before, my recollection is that it run as fast as a normal Z-80 running at several hundred megahertz.

Re: simulation and virtualization, my recollection is that my 300 level Machine Language course was all about learning to program the PDP-8, and that we did so in simulation on the DEC-1091.

Thanks for your comments.

Write a comment






+ 8 = sixteen