By popular demand, the story of the “Minsky machine”.
Backdrop. Most research on the Logo programming language moved from BBN (having developed the “Ghost” language on a PDP-1) to the MIT AI lab around 1970. Logo was provided as an educational tool for children, first running on the timeshared AI lab PDP-6 and 10. Remote hardcopy terminals and vector graphics displays were provided to schools over phone lines. A Supernova minicomputer drove the graphics. Later, Logo was moved to a dedicated PDP-11/45 with vector graphics boards built by Tom Knight.
In the mid-1970s, Marvin Minsky envisioned a small and inexpensive computer for this educational market. He designed a custom 16-bit machine in TTL logic. The computer had two displays: one for text, and another for graphics. It was intended this computer should run Logo, but due to RAM constraints this was not possible. The machine was revamped as a remote terminal to be attached to a host computer running Logo. Danny Hillis, of Connection Machine fame, wrote the microcode to emulate a Datapoint 3300 text terminal as found on the AI lab PDP-10, and to refresh the two displays in real time. The computer was named for the target price: $2500. However, it was no a commercial success. Perhaps only a dozen or so were built. A simple host computer based on the LSI-11 was also built, called the 3500.
The technology was handed over to the General Turtle company, which already existed to sell Logo turtles. The company moved to Canada, where it was called Societe Generale Tortue. The 3500 was redesigned and sold as a word processor.
I made an emulator for the 2500, based on Marvin Minsky’s description as found on AI lab backup tapes. It’s not part on the SIMH suite. The microcode (firmware) is built using an assembler written in Maclisp running on ITS. Since the microcode emulates a Datapoint 3300, it works well with ITS.
I also added support for the special hardware found on the dedicated Logo PDP-11/45. It runs a one-off timesharing system called SITS, or Small ITS. (An interesting story in itself, see: https://retrocomputingforum.com/t/mits-sits-timesharing-system-running-logo) When you run Logo on this computer, you can tell it to output codes for the 2500. Hillis implemented special SPIN and GROW turtle graphics commands which dynamically updates the graphics.
Here’s a little demo where I have logged in to SITS from the 2500 text display and entered a small Logo program which draws on the vector display.
Two of Minsky’s children were involved: Henry entered the schematics into SUDS (the Stanford CAD program written to design the Super Foonly; it was ported over to ITS), and Margaret designed the text fonts.
I want one… with full 64K.
Can it be redesigned using modern logic, like cmos PAL’s.
Emulation just don’t work for the real crt display.
Ben. Drooling on the keyboard.
AI lab hacker extraordinaire Guy L Steele was also involved. He designed a double-width, double-height character set. There’s no support for this in hardware, so each character is composed of two-by-two cells. The font looks like this:
When used by a special version of the microcode that knows how to put this together, it looks like this:
Some symbols look a little strange, because how parts are reused for various shapes!
I used up my quota of ‘round 2 its’ for this month, on a miniscule 36 bit computer design. Maybe some day, I might port a vector display to this machine.
My 36 bit design using 2901’s, needed to wait till the 1980’s for memory and logic to catch up to the design. 9 bit buffer’s and 9 bit
D flip/flops as well as 9 bit memory (no longer made) are all CMOS
from about 1988. Power hungry bipolar logic around 1980 is the
basic design, with only a few modern components for cleaner logic,
that require a power on reset, and CMOS subsitutes.
I suspect most PROTO-TYPE computer designs, like this 36 bit design (1976) are just too advanced for the tech of the day. I would be nice
to see some retro hardware design, other than just on 6502’s
or 6800’s.
No rush on updates, turtles are slow:)
Discussions of some kind of remake of e.g. a KA10 is a perennial favourite. But since it’s in the ballpark of 1000 boards, the conclusion is always that the cost would be prohibitive.
An FPGA PDP-10 has been done, but I suspect you’d say it doesn’t have the right kind of charm, and I’d understand your point.
Thanks for all your efforts to rescue this great project from total obscurity! I first heard of it a few years ago when I saw the Minsky and Papert demo on Youtube. Since I tried to build my own Logo computer back in 1983 I have always been on the lookout for similar projects.
It is interesting that this Logo has line numbers.
Unlike most people, I don’t consider the PDP 10 the greatest thing since
sliced bread. I beleve nowdays you can get a PDP 10 front panel with
a PI inside running it all, or SIMH driving it. Remaking a true PDP-10
is hard because it used state of the art 1970’s tech, and them parts are not around any more. A simplified design might be possable as project. The data path using 2901 parts is only 3 chips for 36 bits.
It is the microcode that takes up all the space, but still posable,
The PCB for my cpu is 8" x 11" and that is for the microcode and
bit slices. 12" x 12" card as guess for PDP 10 style machine
with out floating point.
Thanks for the kind words! In that case, you may also be interested in SITS. Arguably, SITS Logo was the pinnacle of Logo implementations from MIT. The basic system is written in assembly language, but most of the applications are written in Logo! As luck would have it, the four disks were imaged near the end of its lifetime, and they mount and run fine under SIMH.
The old-style Logo implementations for the PDP-10 and PDP-11 only have editing using line numbers. But e.g. MIT’s Apple II Logo (not the Apple Logo) did have a full screen editor.
Excellent! In this case, then, you used a 6809, 32k ROM and 64k of RAM - confirming, perhaps, that the 2500 didn’t have the resources to do the same, which (as explained) is why it turned into a terminal. However it seems to be rather more than a terminal, or even a vector terminal, as it seems - I may be reading between the lines - to perform local animation. Am I reading too much into it?
Yes, it did manage a limited form of animation locally. E.g. the SPIN command makes the turtle rotate, and this state is stored in the display list.
The 2500 had an addressing capability of 4K of 16-bit microcode words, and 64K of RAM. But the machine was only build with 1K microcode and 4K RAM, so this strongly limited what could be done.
In the video, the REPEAT function uses a line number as a label like in Basic or Fortran. That was the part I thought was odd. All other Logos I have seen would use recursion instead to implement the same functionality, though without tail call optimization the stack size would be a serious limit.
I believe these Logos don’t implement tail recursion and that iteration using GO is the common idiom. The PDP-10 implementation stems from the late 1960s, and the PDP-11 version is not much newer, so I guess some modern concepts weren’t widely accepted yet.
