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].
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.
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:
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.
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.
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?
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.
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.
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.
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.
>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...
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?
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.
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.
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.
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.
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.
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.
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.
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.
[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...