PDP-10 Incompatible Timesharing System emulator | Hacker News Reader

PDP-10 Incompatible Timesharing System emulator

github.com

78 pointsgattilorenz45 comments

Oscar Vermeulen, the genius behind the PiDP-8[0] and PiDP-11[1] is making a PDP-10 scale model console[2], shown off recently at the Vintage Computer Festival SW[3][4].

[0] https://obsolescence.wixsite.com/obsolescence/pidp-8

[1] https://obsolescence.wixsite.com/obsolescence/pidp-11

[2] https://groups.google.com/g/pidp-10/c/Q_0LxSvOjaE

[3] https://groups.google.com/g/pidp-10/c/_1MjeJOz0AM

[4] https://photos.google.com/share/AF1QipP55SKT4c2F6wcAnIGV3goB...

This GitHub user account has a wealth of other PDP-10 stuff:

https://github.com/PDP-10

The Panda TOPS-20 distribution:

https://github.com/PDP-10/panda

TENEX, or TEN EXtended, the OS BBN made for the PDP-10s they extended to have paging virtual memory:

https://github.com/PDP-10/tenex

Muddle, the language Zork was originally written in:

https://github.com/PDP-10/muddle

Two different Zork codebases:

https://github.com/PDP-10/zork-1

https://github.com/PDP-10/zork

On the topic of ITS, there's a pretty interesting paper on its PCLSRing feature, PCLSRing: Keeping Process State Modular by Alan Bawden [1]

I've read this a few times over the years, and always find it a fascinating alternative approach to handling interrupts.

[1] http://fare.tunes.org/tmp/emergent/pclsr.htm

Previously:

https://news.ycombinator.com/item?id=13514918

https://news.ycombinator.com/item?id=25869880

Such a great developer environment. The “shell” is a debugger.

It's hard to convey in words how convenient this is. Sometimes when you're debugging, you want to do file system things. In Unix you'd somehow switch out of the debugger to the shell (type ^Z or switch window, or something), do the thing, and then go back. With ITS you can just do it right away, and it somehow feels so right. Similarly, the debugger-shell has built-in math operators, so it can be your desktop calculator without switching context.

The system is wide open to a fault, even extending to the "kernel" memory image being available for debugging with just a few keystrokes.

It should be no surprise that the lispm had a similar experience. Instead of a shell it had a REPL of course but the debugger was always entered when something went wrong, and of course it was trivial to fix something and continue.

Bill Gates once laughed to my face when I described this as a feature.

Reposting this from the 2014 HN discussion of "Ergonomics of the Symbolics Lisp Machine":

https://news.ycombinator.com/item?id=7878679

http://lispm.de/symbolics-lisp-machine-ergonomics

https://news.ycombinator.com/item?id=7879364

eudox on June 11, 2014

Related: A huge collections of images showing Symbolics UI and the software written for it:

http://lispm.de/symbolics-ui-examples/symbolics-ui-examples....

agumonkey on June 11, 2014

Nice, but I wouldn't confuse static images with the underlying semantic graph of live objects that's not visible in pictures.

DonHopkins on June 14, 2014

Precisely! When Lisp Machine programmer look at a screen dump, they see a lot more going on behind the scenes than meets the eye.

I'll attempt to explain the deep implications of what the article said about "Everything on the screen is an object, mouse-sensitive and reusable":

There's a legendary story about Gyro hacking away on a Lisp Machine, when he accidentally trashed the function cell of an important primitive like AREF (or something like that -- I can't remember the details -- do you, Scott? Or does Devon just make this stuff up? ;), and that totally crashed the operating system.

It dumped him into a "cold load stream" where he could poke around at the memory image, so he clamored around the display list, a graph of live objects (currently in suspended animation) behind the windows on the screen, and found an instance where the original value of the function pointer had been printed out in hex (which of course was a numeric object that let you click up a menu to change its presentation, etc).

He grabbed the value of the function pointer out of that numeric object, poked it back into the function cell where it belonged, pressed the "Please proceed, Governor" button, and was immediately back up and running where he left off before the crash, like nothing had ever happened!

Here's another example of someone pulling themselves back up by their bootstraps without actually cold rebooting, thanks to the real time help of the networked Lisp Machine user community:

ftp://ftp.ai.sri.com/pub/mailing-lists/slug/900531/msg00339.html

Back in the 80s I moved from Queen Elizabeth College (part of University of London) which had just bought a couple of VAXen, which i thought were very smart, to Middlesex Polytechnic in north London who had a DecSystem10 running TOPS-10. It was horrible.We never ran ITS, maybe we should have.

And yet TOPS-10 was fairly advanced back in the sixties.

It is the common root of RT11, CP/M and PC-DOS / MS-DOS, but also one of the only system that allows to run batch and time sharing tasks at the same time. IBM couldn't do that, if you needed time sharing, you had the 360/67 but then you couldn't run batches.

Fun fact, Microsoft originally used a KA-10 running TOPS-10 and cross assemblers for software development. The PDP-10 was also a cornerstone of developing NCP/IP, TCP/IP, and early AI.

It's fairly hard nowadays to find 36 bits machines still running, as the 8 bits byte has taken over the world. I think XKL uses an FPGA-based PDP-10 running TOPS-20 on its TOAD2 router, but that's about all I'm aware of.

> I think XKL uses an FPGA-based PDP-10 running TOPS-20 on its TOAD2 router, but that's about all I'm aware of.

I’m pretty sure the TOAD2 is a discontinued product. I believe their current routers run a BSD variant

https://news.ycombinator.com/item?id=30520851

There has always been more than a passing resemblance to TOPS-20 and Cisco iOS CLI - while they might run a BSD variant, the feel is the same (so are some of the commands, like systat).

It is very common for embedded vendors, when changing the underlying OS, to try to keep the UI unchanged. Once upon a time, every IBM mainframe contained a PC running OS/2, which was used to perform system maintenance functions such as startup and shutdown, hardware configuration changes, OS installation, etc. At some point, IBM decided to get rid of OS/2 and replace it with a HTTP server running on x86 Linux – but they had the webapp emulate the OS/2 UI look, so it still looked like OS/2 even though it was now a webapp. (I believe more recently they've refreshed the UI so it doesn't look like OS/2 any more.) So it wouldn't surprise me if, when XKL migrated from TOPS-20 (or possibly it was their own custom PDP-10 OS) to BSD, they kept the CLI as unchanged as possible.

It also wouldn't be the first time a Unix application has used a TOPS-20 inspired interface. The most famous example of that is Kermit. Columbia MM is another.

Lynx doesn't look very Unixy too.

Its amusing, early XKL documentation called it "router style user interface" so while it might have been PDP-10 under the surface, it looked like a Cisco Router from the get go, which makes sense considering the market intended for.

This has more to do with Cisco's IOS command line being a direct clone of the TOPS-20 "Exec" than XKL attempting to clone Cisco's interface.

The first time I sat down at a TOPS-20 box, I could see the genetic similarity.

Also, I was not presuming XKL cloned Cisco - considering the shared provenance of it all.

> And yet TOPS-10 was fairly advanced back in the sixties.

first release 1970, according to wikipedia.

> It's fairly hard nowadays to find 36 bits machines still running,

true. one of our system programmers looked at buying our Dec10 but power supply and cooling problems defeated him - it was eventually sold for scrap.

It would take unusual dedication, plenty of space, and a huge budget for electricity and air con to run a KL10 at home.

I understand the attraction, because they were very popular with users - partly because TOPS-10 was relatively intuitive and could be learned by almost anyone, and timesharing was very much an experience of personal computing.

That was a huge deal when most computing still had to go through operators and other expert intermediaries.

TOPS-20 was more refined and tried to be even friendlier, with nice features like command completion.

Neither was at all UNIXy - a good thing IMO.

he was prepared to sacrifice his 2-car garage, but i think the three-phase and other electrics defeated him. of couurse, it wouldn't have been switched on anywhere near all the time. and his girlfriend wasn't keen. perhaps a bit too big for a hobby project?

If I remember correctly the DEC supplied power supplies were hugely inefficient, and CompuServe redesigned the power supplies since they were using so many of these systems.

> first release 1970, according to wikipedia.

Under that name. It goes back to the PDP-6 monitor, 1964.

I have good memories of playing Star Trek all night on a DECwriter connected to a -10.

i have good memories of playing empire :-)

Such a shame. Did he try to contact a local museum maybe? I'm looking forward to have PiDP10 but seeing a real one, especially a KA-10, would be a bit of a dream.

>Microsoft originally used a KA-10 running TOPS-10 and cross assemblers for software development - This was before they had Unix ported to their PDPs (Xenix)- and then Vaxes? Ms Piggy? Oh do tell! A lot happened between 1979, and 1984, when Xenix was released...

And a lot more so, after they decided they didn't want that UNIX business after all.

Do you mean how Microsoft "borrowed" time on PDP-10 computers that were not theirs? I believe they got a DEC-2020 (KS10) later. Ms Piggy was a PDP-11, right?

That's right, there even used to be a picture of Bill Gates and Paul Allen using the DEC-2020 at the LCM in Seattle.

https://upload.wikimedia.org/wikipedia/commons/6/63/DECSYSTE...

Sorry to be pedantic here, but that LCM computer is not a DEC-2020, and by looks of it, not the one in the photo either. The 2020 is a small machine with the KS10 processor. The ones in the photos look like some larger KL10 based DEC-20 models: 2040, 2050, 2060, or 2065.

You're absolutely right, thank you for pointing this out to me. I indeed meant a KL-10 based DEC-20, not a KS-10 2020.

I was at Middlesex Poly in the late 80s / early 90s doing an AI degree. I'm pretty sure one of the things we used was the EXSYS expert system shell running on VAX/VMS (because that's where I first came across the name). We didn't use it much though because the AI group had a bunch of early Macs that everyone preferred.

ITS it's the most amazing OS (with Emacs and "TV") you can try there.

Besides ITS proper, there were many subsystems that were more or less tied to ITS, some of them with their own operating systems. Others like the TV and XGP had dedicated PDP-11 computers running special software.

Just to list a bunch: PDP-6, Logo PDP-11/45, Minsky's 2500, Imlac PDS-1, GT40, Robotics PDP-11/40.

From the offices at Tech Square, you could also call the elevator to your floor (by pressing Terminal-D), and buzz the elevator lobby door open from the comfort of your Lisp Machine (by pressing Terminal-E), via the PDP 10/11 interface on AI.

Random tourists could just pound on the door, and somebody would usually buzz you in without checking who it was, just to get some peace and quiet.

Lars, do you know anything about the wire wrapping robot that was on the 9th floor? Henry Minsky says he thinks either Holloway or Knight built it (Tom Knight would know), and they used it to make the CADR lisp machine boards. Those were huge freaking wire wrap planes, the size of a tabletop.

Here's Marvin Minsky demonstrating the 2500:

https://www.youtube.com/watch?v=c4kMzrDr4jQ

Cynthia Solomon's got a lot more amazing historic videos from that time:

Atari Cambridge Research- parts 1-6:

Introduction:

https://www.youtube.com/watch?v=CR2CwKculBU

Margaret Minsky demonstrates a gestural system:

https://www.youtube.com/watch?v=-Wq6SQTVM9M

It's 1984 and Ed Hardebeck shows a gestural system and Gary Drescher shows object-oriented Logo:

https://www.youtube.com/watch?v=ClKQHgIoLPc

A force feedback joystick, a puppet machine and a program of dance and body movement are presented:

https://www.youtube.com/watch?v=R3qPCZ5z0UQ

David Levitt shows the music box:

https://www.youtube.com/watch?v=ocwsVkqEKys

Music box with Tom Trobaugh and drum machine with Jim Davis:

https://www.youtube.com/watch?v=DhA0FGsin_s

The elevator and door hardware was in the TV-11. The IO pins are available in the emulator, but alas not connected to anything.

I have heard about the wire wrapping robot, but not who made it. The boards were made by Augat.

You can run Empire on a PDP-10:

https://github.com/DigitalMars/Empire-for-PDP-10

In theory. As far as I know, attempts were made to resurrect this, but didn't get all the way there.

https://github.com/paulnank/nankervis-pdp10-js/issues/1#issu...

Yeah, I was really looking forward to run the real SHRDLU [1] (one of the first natural language understanding programs) on ITS, but also that is... challenging. As you found out, it's possible to run a demo recording of it [2], and it's quite impressive too.

[1] https://en.wikipedia.org/wiki/SHRDLU

[2] https://github.com/PDP-10/its/issues/147

I have tried several versions of SHRDLU, binary and source, but so far I haven't found one that works. Some people claim it never really worked well. Winograd himself seems to think it did, and there is what seems to be a working demo in a 1973 TV documentary. Others say it needed heavy manual patching to be somewhat usable, and those patches didn't make it to the source code files.

Do you have a link/reference to the documentary?

Yes, I've seen the sources that say it never was stable, but I assume that at least what's in the recorded demo was at some point possible to run; of course it might be coming from a long-lost source/or binary.

Terry and SHRDLU at 8:23 here: https://archive.org/details/what-about-tomorrow-on-the-side-...

See this for some more information: https://github.com/PDP-10/its/issues/425#issuecomment-145588...

The way I debug such things is to start with a trivial FORTRAN-10 program, and get it to compile, link, and run. Then start adding pieces of Empire to it, and when it stops compiling and linking, then do a binary search on the code till the culprit is found.

ITS...

https://www.youtube.com/watch?v=i2s4tpqYrIg

Another fun tidbit related to this is that there were two prononciations of "ITS". The AI lab (where ITS originated) and the adjoining Project MAC slash LCS PDP-10s running ITS pronounced it as an acronym: "eye tee ess". But the Dynamic Modeling group (also in Project MAC), who were the first to adopt ITS outside the AI lab and had offices a few floors down, called it "its". I only learned about this recently when I talked to former DM people on video.

Reply on news.ycombinator.com