Notes about the General Turtle TT2500

[larsbrinkhoff]

Notes about the General Turtle TT2500.

It's a custom TTL design mostly by Marvin Minsky. The hardware consists of a CPU executing 16-bit microinstructions out of a 4K control store. There are 8 fast registers, and 32 slower scratchpad locations. The main storage is a 16-bit wide up to 64K RAM. There is a keyboard for user input, and UART for talking to a host computer. There are two displays: one for text, and another for vector turtle graphics. The microcode refreshes both displays and interprets macrocode which is a display list for turtle graphics.

Danny Hillis wrote the microcode and invented SPIN and GROW.

[larsbrinkhoff]

MINSKY; 2500 MEMO is a detailed description of the machine.

[larsbrinkhoff]

The SW directory (Sylvia Weir) has programs for the General Turtle 3500, which had an LSI-11 processor.

[larsbrinkhoff]

MINSKY; SIM 130 is another simulator.

[larsbrinkhoff]

MINSKY; TVDIS 3 is a 2500 program. Also TVDIS LIST and TVDIS ASCII, and another copy in GJD's directory.

ADIS; PREISS STUFF has an appendix with a 2500 program.

HQM; TVTES 3 maybe test?

[larsbrinkhoff]

MINSKY; ZAP 115 and PZAP 16 are assemblers.

[larsbrinkhoff]

The 2500 directory has lots of code and tools.

[larsbrinkhoff]

HQM has an AR3 2500 archive and SUDS drawings.

[larsbrinkhoff]

MARG has many 2500 files.

[larsbrinkhoff]

The DANNY directory has many files: B-LOAD 29 (boot ROM?), CONSOL LAP (console program), DANNY 187 (assembler?), DIS 34 (2500 console program), LOADER (secondary boot loader?), _^RSV 326 (console program), ZAP 53 (assembler?).

[larsbrinkhoff]

Simulator for Minsky's 2500 machine, written in Lisp machine Lisp for running on the Maclisp Lispm simulator.

HENRY; MMSIM 128, timestamp 1975-09-17

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;                     2500 SIMULATOR                       ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;

;;Simulator for Marvin Minsky's 2500 computer written in LISP machine
;;LISP, to run on LISP machine simulator on ITS.
;;;
;;To compile, :LISPM;QMCP , (MAKE-Q-FASL 'MMSIM)
;;To load into LISP machine simulator, (FASLOAD MMSIM QFASL DSK HENRY).

[larsbrinkhoff]

The latest versions of the 2500 software seems to be in 2500; ARC 1.

[larsbrinkhoff]

Managed to run the assembler using the Maclisp image SYS; PURBIB 1247, like this:

(setq gc-overflow '(lambda (x) x))
(fasload zap)
(uread tvdis >)
^Q
(zap tvdis)

The ARC file has bootstrap ROM, LOADER, and TVDIS software.

[larsbrinkhoff]

General Turtle was initially formed to sell floor turtles. Here a photo of one on Tasmania.

[larsbrinkhoff]

A small ad in Creative Computing, v2n6 November/December 1976.

[larsbrinkhoff]

@hqm remembers a double-size font designed by @GuySteele. Based on his clues, I have located files called S2500D in the GLS, MARG, and 2500 directories. One of them plausibly looks like it could contain 8x16 rasters that could be combined to form the 16x32 characters.

[GuySteele]

Yes, I did design such a font, although my memory is that I designed a set of 8x8 rasters (by hand, on graph paper) such that they could be pieced together in quadruplets to make 32x32 characters. I remember that I was most pleased with the fact that the same raster could serve as the lower-right quadrant of both “Q” and “&”.

IIRC correctly the underlying hardware supported 8x8 rasters, expecting one character to fit in each.

—Guy

On Oct 11, 2020, at 12:38 PM, Lars Brinkhoff notifications@github.com wrote:

 @hqm remembers a double-size font designed by @GuySteele. Based on his clues, I have located files called S2500D in the GLS, MARG, and 2500 directories. One of them plausibly looks like it could contain 8x16 rasters that could be combined to form the 16x32 characters.

— You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub, or unsubscribe.

[larsbrinkhoff]

Thank you @GuySteele,

You are absolutely correct, the AST file says the characters are 8x8. Here is a screenshot of FED with the S2500D font.

[larsbrinkhoff]

The TT2500 was featured in Computer Lib/Dream Machine.

[GuySteele]

Hi, Lars,

I’m puzzled. I didn't remember this material, but it is clearly in Nelson’s style, so I got out my own copy of Computer Lib/Dream Machines (second printing, which I received in February 1975), which I hadn’t looked at in 20 years or more. I leafed through the entire book three times (wow, what a trip down memory lane) but could not find this material. I did find the mention of General Turtle on page 57 (which I now see is referenced in the item you sent), so I know I was looking fairly carefully.

So, can you tell me, please, on what page “Minsky’s Computer” appeared? And was it perhaps only in a later edition?

—Guy

On Nov 5, 2020, at 2:19 AM, Lars Brinkhoff notifications@github.com wrote:

The TT2500 was fatured in Computer Lib/Dream Machine. https://urldefense.com/v3/__https://user-images.githubusercontent.com/775050/98209356-0d365f80-1f3f-11eb-847f-05b1cbbbc8f8.png__;!!GqivPVa7Brio!M_HBoyIADkhdxdIcggMb7WLa2Tle92khq9PWxF8AGT02OaHkIAbW1rj_msz1Bg06$ — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub https://urldefense.com/v3/__https://github.com/PDP-10/its/issues/1962*issuecomment-722192864__;Iw!!GqivPVa7Brio!M_HBoyIADkhdxdIcggMb7WLa2Tle92khq9PWxF8AGT02OaHkIAbW1rj_mmcL36PY$, or unsubscribe https://urldefense.com/v3/__https://github.com/notifications/unsubscribe-auth/AAXU22TFJGIFEC33KDR4UHDSOJGZ3ANCNFSM4RWFK2PA__;!!GqivPVa7Brio!M_HBoyIADkhdxdIcggMb7WLa2Tle92khq9PWxF8AGT02OaHkIAbW1rj_mnWsa4Kr$.

[larsbrinkhoff]

Hello Mr Steele,

I believe I found it in this file: http://worrydream.com/refs/Nelson-ComputerLibDreamMachines1975.pdf

It's page 5 in the PDF, or 126B in the book. Since the scan is somewhat grainy, I went looking for a better copy. The ones I found didn't look better, but they had the same text. PDF page 3 says "special supplement to the third printing, august 1975" so it looks like it was updated. That would also explain the odd 126A/B/C/D page numbering.

Hope this clears things up!

[GuySteele]

Cool, thank you so much! I had never seen this “Special Supplement” before. I really appreciate your bringing this to my attention.

I also note, on that same page 126B, a brief mention of the “Greenblatt Machine” (aka MIT Lisp Machine), just above an equally brief mention of the forthcoming Cray-1.

—Guy

On Nov 20, 2020, at 3:52 PM, Lars Brinkhoff notifications@github.com wrote:

Hello Mr Steele,

I believe I found it in this file: http://worrydream.com/refs/Nelson-ComputerLibDreamMachines1975.pdf https://urldefense.com/v3/__http://worrydream.com/refs/Nelson-ComputerLibDreamMachines1975.pdf__;!!GqivPVa7Brio!L17AuBoRNEEV1yaBL9fJr3Rdosqg2hBCYOu7cL1MToR2-P2s0nQwXWyxcrx-sh4d$ It's page 5 in the PDF, or 126B in the book. Since the scan is somewhat grainy, I went looking for a better copy. The ones I found didn't look better, but they had the same text. PDF page 3 says "special supplement to the third printing, august 1975" so it looks like it was updated. That would also explain the odd 126A/B/C/D page numbering.

Hope this clears things up!

— You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub https://urldefense.com/v3/__https://github.com/PDP-10/its/issues/1962*issuecomment-731401231__;Iw!!GqivPVa7Brio!L17AuBoRNEEV1yaBL9fJr3Rdosqg2hBCYOu7cL1MToR2-P2s0nQwXWyxck1bYCgN$, or unsubscribe https://urldefense.com/v3/__https://github.com/notifications/unsubscribe-auth/AAXU22UZJB6NUEU55EE65RLSQ3JHNANCNFSM4RWFK2PA__;!!GqivPVa7Brio!L17AuBoRNEEV1yaBL9fJr3Rdosqg2hBCYOu7cL1MToR2-P2s0nQwXWyxcu_ElK7D$.

[larsbrinkhoff]

Found the microcode for the big font.

A gotcha is that this microcode expects the UART to transmit bits in the wrong order.

[GuySteele]

My son Matt has taken up the hobby of writing new games for the original Nintendo GameBoy. He’s enjoying writing assembly code for that weird 8-bit microprocessor that includes special support for video RAM and sprites. There is a wonderful toolkit and emulator for this specific community, and one of the things Matt had to figure out is that at least some instances of the CPU chip had subtle bugs associated with the interrupt logic, such that the hardware did not quite match the documentation, and the emulator faithfully emulates those bugs because some existing games from that era depend critically on the buggy behavior. He’s getting a real taste of what the world was like decades ago (and maybe still is?). :-).

On Dec 1, 2020, at 10:10 AM, Lars Brinkhoff notifications@github.com wrote:

Found the microcode for the big font.

A gotcha is that this microcode expects the UART to transmit bits in the wrong order.

https://urldefense.com/v3/__https://user-images.githubusercontent.com/775050/100758123-7189f900-33ef-11eb-8b62-580476fb9b25.png__;!!GqivPVa7Brio!LDl82S2FHIO62lXrYcSVnokHQ3KsVs1SmzZBAkKeF1XLNCPkxSAsCnAHlIlCVL7l$ — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub https://urldefense.com/v3/__https://github.com/PDP-10/its/issues/1962*issuecomment-736614055__;Iw!!GqivPVa7Brio!LDl82S2FHIO62lXrYcSVnokHQ3KsVs1SmzZBAkKeF1XLNCPkxSAsCnAHlOzQjXjj$, or unsubscribe https://urldefense.com/v3/__https://github.com/notifications/unsubscribe-auth/AAXU22VHS6ILTFJSFYECLY3SSUBODANCNFSM4RWFK2PA__;!!GqivPVa7Brio!LDl82S2FHIO62lXrYcSVnokHQ3KsVs1SmzZBAkKeF1XLNCPkxSAsCnAHlBFP_LCX$.

[larsbrinkhoff]

Hello @gporais,

I have collected some information about the 2500 in this GitHub issue, including a few photos and a video.

I'm adding this sketch of the 2500 with dual displays, as suggested by Ted Nelson on the same page as the previous clip.

[gporais]

@larsbrinkhoff Cool! Thanks! I have downloaded the PDF and will read about this more.

[larsbrinkhoff]

From https://sisr.swissinformatics.org/wp-content/uploads/sites/28/2019/08/1980-1981-Cahier-Pacific-N%C2%B0-1-Une-tortue-dans-une-classe-une-anne%CC%81e-dexpe%CC%81rimentation-en-cours-de-2e-C.Berdonneau-et-R.-M.-Dumas-20190521141417100.pdf

[gporais]

cool! but its in French :)

On Wed, Apr 21, 2021 at 7:02 PM Lars Brinkhoff @.***> wrote:

From https://sisr.swissinformatics.org/wp-content/uploads/sites/28/2019/08/1980-1981-Cahier-Pacific-N%C2%B0-1-Une-tortue-dans-une-classe-une-anne%CC%81e-dexpe%CC%81rimentation-en-cours-de-2e-C.Berdonneau-et-R.-M.-Dumas-20190521141417100.pdf

[image: tt3500_et_tt2500] https://user-images.githubusercontent.com/775050/115535734-541fd380-a299-11eb-83f3-3f1f0823f469.png

— You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub https://github.com/PDP-10/its/issues/1962#issuecomment-823940485, or unsubscribe https://github.com/notifications/unsubscribe-auth/AAMKIWOUQESNIRE2DVL4PTDTJ2PBXANCNFSM4RWFK2PA .

[larsbrinkhoff]

Some background history posted to comp.lang.logo.

By @brianharvey:

Many, many people have been involved in the development of Logo.

Wally Feurzeig started the whole thing by organizing a group at Bolt, Beranek, and Newman, Inc., to study the educational effects of teaching kids a programming language. The first language they used, like most programming languages, was focused on numeric computation, and it was Wally's idea that kids would find it more natural to work in an area they knew better, namely natural language; therefore, he set up a team to design a language featuring words and sentences. Wally made up the name "Logo."

The team Wally put together at BBN included Seymour Papert and Dan Bobrow. The three of them are credited as the designers of the first version of the language; Dan wrote the first implementation. In a BBN report dated August, 1967, credit for additional work is given to Richard Grant, Cynthia Solomon, and Frank Frazier.

Seymour later started a Logo group at MIT, where Logo development continued. The MIT versions of Logo were substantially different from the BBN ones, both in the notations used and in the things the language could do. Most notably, turtle graphics was added at MIT.

Among the many people who contributed to the development of Logo at MIT, at the risk of leaving someone out, are Hal Abelson, Paul Goldenberg, Dan Watt, Gary Drescher, Steve Hain, Leigh Klotz, Andy diSessa, Brian Silverman... oh, lots of people.

I think that most of the early documents are out of print now, but whatever documentation there is of the early efforts will be in the form of technical reports from BBN and from MIT. You may have to visit Cambridge to find them!

By @leighklotz:

In the mid 1970's, when the AI Lab Lisp Machine project was just getting underway, Marvin Minsky and Danny Hillis (later to found Terrapin, and still later, Thinking Machines) put together a project to build a Logo machine. It had two components: a PDP-11 processor (the 3500) and a separate vector-graphics display (the 2500). Guy Montpetit, a Canadian entrepeneur, funded development eventually, and a company called General Turtle was formed. General Turtle built and sold the 2500/3500 system. Henry Minsky, then about 12, worked on the design of the 2500, using the Stanford Draw program, one of the early electronics CAD systems. (The 2500 had this really great barrell shifter stolen from the Lisp machine design, but it was later found not to work, so it was never used.)

Anyway, the 2500 was a true vector graphic display: the turtle commands added to a display list, and the vector processor moved the electron beam across the display tube, repeatedly tracing the display list. There was no raster scan bitmap, which saved on memory and processing speed, and hence cost. One of the really neat things you could do was issue SPIN and GROW turtle commands, in addition to RIGHT and FORWARD. SPIN caused the all succeeding commands (until a CLEARSCREEN, of course) to rotate at the specified rotation rate. (It's as if you had put the turtle at the center of a spinning plate at that point, and then done all further drawing on the plate.) GROW was analogous, drawing a line which grew in the FORWARD direction at the specified speed. Hal Abelson and Andy diSessa spent days going over the group theoretics of SPIN and GROW. Simple turtle geometry programs with FD and RT replaced by SPIN and GROW produce amazing mindblowing displays. Sprites don't even come close to what SPIN and GROW can do, in terms of intellectual stimulation for all ages.

Alas, the world was not ready for Logo machines, and General Turtle crawled to Canada and became Societe Tortue General, and the 3500 became a desktop word processor, and eventually the company went out of business.

Meanwhile, back at the AI Lab, in the late 1970's Henry Lieberman and Kenneth Kahn (I think) wrote a version of Logo in Maclisp for the PDP-10. It compiled Logo procedures into Lisp and then executed the Lisp, displaying on a 512x512 pixel green tube CRT driven by an auxillary PDP-11 with 16 display buffers. The problem with the LLOGO approach was that Logo parsing is ambiguous: it depends on the number of arguments to a function, so if you redefined a function to take a different number of arguments (for example, if you made an error), you had to go define everything that called it again.

Around 1977-1978, Gary Drescher and someone else whose name escapes me at the moment wrote a version of Logo in Pascal, as part of a project with Texas Instruments, for the TI 99/4 Home Computer, because Pascal was the only high-level language supported. They finished it and compiled it, and it produced something like a 300Kb program. That doesn't sound like much, but considering that the TI 99/4 in its most burly configuration had 32Kb, it was tremendous.

So, the Logo Lab hired Edward Hardebeck to be a human compiler for the TI 99/4. The machine had twice as many registers as a PDP-11, but only half as many addressing modes, so it wasn't possible to implement a PUSH/POP stack for function call and return, or for data push and pop, in a single instruction. Furthermore, all but 256 bytes of the memory was accessed off-chip through a 12-clock-cycle interface. In other words, most of the time, the machine ran at 1/12th of its designed speed, which was pretty slow in the first place.

The machine had register windows, which is much like current RISC processors, and the 256 bytes were intended for those. Ed implemented some common subroutines in part of the 256 bytes, and used the rest for registers.

Anyway, the machine had a SPRITE chip, which was the result of a collaboration between Danny Hillis and TI. The idea of a SPRITE chip was Danny's bachelor's thesis... The idea of getting out Logo on such a machine, and the possibility of having the first microcomputer version of Logo available for use in real schools, pushed everyone on. TI had a couple of programmers assigned to the project in Texas, and they did the final work of shoehorning everything in to fit into the 99/4 -- we're talking about a few hundred bytes here and there total. It must have been grueling work. For example, they shortened all abbreviations to two letters -- memory was that tight.

In 1979, a high school freshmen named Stephen Hain came (who had previously come to the Logo Lab on an NSF-sponsored summer program) started working at the Logo Lab as a part-time job during school. Hal Abelson assigned him the task of producing an Apple II version of Logo. The Apple II wasn't yet a big success. In fact, I believe Bill Gates had sold Apple the BASIC for it for a small flat rate -- he didn't think it was worth collecting royalties on. Hain read a book ont the 6502 instruction set, and wrote about 300 pages of 6502 code, based on Gary Drescher's PLOGO model. There was not a single comment in the entire file.

One day he cross-compiled it on a PDP-10, and downloaded it to an Apple II with a 16Kb memory extension ("language") card. It didn't work.

The Logo Lab hired Patrick Sobalvarro to fix things. After one month, he got it to initialize and then crash.

Patrick moved on to write the screen editor, based on Craig Finseth's bachelor's thesis "A Cookbook for EMACS," which described how to implement a redisplay for an EMACS-like editor. Back then, editors still had insert mode'' andoverwrite mode,'' and it was a big deal to be in ``insert mode,'' because you had to move characters over and do memory intensive operations, and it was slow. Nowadays, nobody would use an overwrite-mode editor, but back then it was a radical move to have such an editor in a machine. It wasn't until the Macintosh came out in 1984 that the idea of always being in insert mode and having an explicit delete key won out in the popular mindset!

Anyway, after a year or so in 1980, I dropped out of MIT and joined the Logo lab as a Sponsored Research Staff member. I helped finish the Logo, and turned it into something ready for release to the world. Since the NSF had funded its development, there was a big question as to how to turn the results into a product. It was an early test case for the productization of NSF-sponsored university research. The final decision was to offer licenses to all qualified comers. Five companies stepped forward: Terrapin, Krell, and three others who dropped out. Patrick and I went to Terrapin, which we had goaded into buying a license. Terrapin was at the time moribund, with only some floor turtle robot kits left, and one part-time employee (the bookkeeper).

Around this time, Guy Montpetit reappeared from Canada, with offers to create a new company. He founded Logo Computer Systems, Inc., and based it in Boston, in the North End, I think. While Patrick and I went to Terrapin to support the Logo we'd brought to near-product readiness, Gary Drescher went to LCSI with the idea of writing a new Logo based on the old LLOGO idea of parsing, but this time with reparsing as the fix for the redefinition problem. Gary also wanted to regularize the syntax some, for IF and so on, to make it more Lisp-like and less English-like.

Margaret Minsky, Brian Silverman from Ottawa, Ed Hardebeck, and Steve Hain went to LCSI, as did the late Greg Gargarian, who was at the time Seymour's administrative assistant but who later obtained a PhD from the MIT Media Lab. LCSI bought two Lisp Machines, Inc. machines from Richard Greenblatt's company, and Gary and Ed wrote a 6502 assembler in Lisp. Its big feature was that it would automatically assign Page 0 memory locations, which were in short supply and were necessary for certain vital instructions. They finished it, and it took about two hours per compilation.

Against all odds (Danny was laying 2-1), LCSI finished its Logo about the same time that the NSF/MIT legal issues about Logo royalties got resolved. The speed was about the same, within 10%. LCSI's Logo required time for reparsing every procedure after each redefinition, so it ran about 10% more slowly in interactive use, but about 10% faster if you didn't change anything. With Seymour Papert supporting LCSI, they easily won Steve Jobs's attention, and LCSI Logo became the offical Apple Logo.

Terrapin and LCSI competed vigorously for quite some. There was a great atmosphere of fun, with both sets of us feeling we were doing something we really liked, and also ``saving the world'' at the same time.

I contacted Virginia Grammar, and E. Paul Goldenberg, two people who had written Logo papers on working with children, and with whose I was particularly impressed. Terrapin paid them to write tutorials, and it worked out great.

Krell competed on price. They sold the Logo disk exactly as received from MIT, for $25. It had bugs in the garbage collector that caused it to crash regularly, and other problems as well. I added MEMBER? and related operators after going to Terrapin, and found and fixed many bugs. When Consumer's Report magazine did an article on software, they recommended Krell Logo because they said it was obviously the same product for a better price, without even asking Terrapin. From then on, I have assumed that Consumer's Report magazine has done the same level of investigation of anything on which they report.

About a year later, right after the IBM PC was announced, I found out about the Commodore VIC-20. Terrapin's president Jock McClees (brother of one of the founders) called Commodore on the phone and said, ``Hi, we're Terrapina and we do Logo, and we want to do Logo for your VIC 20.'' Well, the VIC 20 had about 4K of memory, and I knew we couldn't do Logo for it, but I figured we could work something out -- a memory extension or something. It turned out that Commodore was in development of a new product with 64K memory, and they wanted Logo.

So, Jock and I flew off to King of Prussia, PA, and did a dog-and-pony show. At the time, Terrapin was a one-room walkup startup in scuzzy Central Square, Cambridge, MA. It was terribly noisy, and I couldn't hear myself think. We bought time from BBN on one of their DEC 20's for cross-assembly, and I got an office in Harvard Square. It was perhaps one of the most dismal programming jobs I'd ever had. There was no window, and only a bare bulb, a bean bag chair, and a 1200-baud modem connection over a Heathkit 24-line terminal I had to buy myself. I had to convert Logo from 6502 code to 6809, and remove every reference to the empty list [] because reading or writing that location made the C64 disk go haywire! I studied secret C64 kernel listings printed in blue on green paper (copy protection) to figure out which Page 0 locations we could use.

Occasionally, I'd wander back into Central Square and talk to people about the Apple II Logo on the phone. One day I ran into Charles Frankston in Radio Shack, when we were both buying a tiny colored-pen plotter than ran on adding machine paper. Frankston and Dan Bricklin were the authors of Visicalc, for the Apple II. They were across the street from Terrapin. I heard from them that Visicalc's former marketing guy named Mitch had left and had started a company called MicroFinance, in a basement around the corner. Patrick, Jock, and I went over to ask for marketing advice -- it was that kind of a world then. The marketing guy showed us a program he'd written in BASIC. It took Visicalc data files and drew pie charts on the screen. The pie charts were ovoid, because the pixels weren't square on the Apple. We wrote the same program for him in Logo in about 3 minutes. He laughed, and said he'd have us talk to his programmers, who were busy coding his program into assembler. He finished the program, sold it back to Visicalc for $1M in royalties. We were impressed. Next time we went to see Mitch, the MicroFinance sign was down, and a new one said ``Lotus.'' I often wish we'd spent more time listening instead of showing him Logo.

By this time, Terrapin had hired Mark Eckenwiler, a Harvard student, to pack boxes. It became clear he had other talents, and he edited the new documentation for the C64.

Terrapin had moved from its one room to a former radio station studio located in a publishing company building in Cambridge. It was pretty quiet back in the studio where I worked, and I got a lot more done, and finished C64 Logo quickly. (There's still this bug in it though, where the same Page 0 location is assigned to two things, and after some number of tail recursive calls to a function, something gets overwritten and you get a weird error...) There were two big problems with the location though: (1) It was next door to the city jail, and they'd bring in drunks and they'd shout and scream all night and bang on the bars. (2) The publishing company had an alarmed storage basement, but they didn't know how to turn off the alarm, so whenever they wanted books, they'd go down there, trip the alarm, and wait 20 minutes for it to stop ringing. Even my soundproof spot-recording studio wasn't quiet enough to keep that noise out.

But, Terrapin didn't do too badly with the Commodore Logo. The C64 was the biggest selling machine of its time. 3,000,000 in the US and 5,000,000 worldwide, and over 150,000 copies of Logo sold for it.

In 1984, when the Macintosh came out, Patrick Sobalvarro and I approached Terrapin with the idea of developing a C version of Logo. We felt that since we would be moving on to other things, we could provide them with a portable system, with its first target being the Macintosh, and maybe the second being the IBM PC, if it ever became important in the education market. Terrapin hired someone to do the second version, but decided not to focus on the business-use PC, but instead the new 68000-based Sinclar QX, Sir Clive's second export computer after the Timex one. Unfortunately never left the dock, and the programmer quit, and Terrapin never (to my knowledge) developed a PC version of Logo (though, see below).

At the time, all Mac software was compiled on the Lisa in Pascal. We bought a 68010 Unix system and cross-compiled. We ordered a Sun 2, but it was backordered, so we bought a machine from another company, long since defunct (I hope). We compiled and tested the portable version on the Unix box, and cross compiled to the Mac.

Patrick Sobalvarro was in charge of the interpreter and garbage collector, and I wrote all the Logo primitives, the Mac OS and turtle graphics systems, and handled the cross-compilation. We had lots of trouble -- system crashes, disk crashes, etc. that kept us out of operation for months at a time. Once, when Terrapin threatened legal action against the company because they couldn't provide us with a working C compiler and debugger, they put their president on the phone to say to Terrapin's president, ``Your guys are just bluffing you. There's nothing wrong with our machine. Real programmers debug with print statements.''

I finished the Mac Logo just as after 512K Macs and the "Hierarchical File System" came out. It ran for ten without requiring any upgrades, and Terrapin is still selling it.

In the meantime, LCSI had gotten the deal from Steve Jobs to do the official Logo for the Macintosh. Eventually, Apple gave it back to them, and told them to sell it.

There were other companies producing Logo in the interim years. Researchers in Edinborough, Scotland used it for serious AI programming for years, almost back to the BBN days.

A brilliant computer scientist named Jonathan Allen (sp?) developed some wonderful versions of Logo with innovative ideas for computer science and education. He made a series of versions for failed computer companies: one for the Mattell computer which was withdrawn from the market within weeks of its first sales, and I believe he did a deal with Osborne just before they went bust, though that could be a confabulation.

Allen also approached the late Gary Kildall of Digital Research, and got him so fired up about Logo that he decided to ignore Allen and write his own, in C. It was terrible! They called it Dr. Logo, and it ignored years of research into Logo usability studies (fixed vs. floating point errors, words/string confusion, etc.), and years of work on speed. It was 10x slower than the Apple II Logo, when running on a PC XT!

After Digital Research's failure with Logo, they tried to bluff Terrapin into selling the company to them for a song. I managed to keep it from happening, by refusing to accept the pitiful deal they offered me, and DR went away. I doubt Terrapin would exist now if they had merged with Digital Research.

Harvard Associates also developed a version of Logo, written in C, in conjunction with one of the IBM PC Lisp companies, I believe. Harvard Associates was run by a former Terrapin manager, among others, and came out with one of the first PC versions of Logo.

I heard from Terrapin last week that they have entered into a joint marketing arrangement with Harvard Associates, in a further consolidation of the Logo market.

Like Brian, I've left out many people who worked on Logo over the years: Brian Fox and Flavio Rose worked for me at Terrapin on a contract basis briefly, as did vagabond programmer Devon McCullough (who used to dial in with a 300 baud modem he'd written in entirely software using the parallel game port, with an 80-column mixed-case display done with 3x5 pixel characters; when the modem detected the call waiting click on the line, it would make the Apple II speaker make the telephone ringing sound -- a feature which I just saw a US patent filed on, not by Devon.), and the frustrated Sinclar QX programmer, who I suspect doesn't want his name used. Of course, there were tons more people at the AI Lab in the pre-commercial days...

Following up on my own message -- I forgot two items: Hal Abelson directed the Logo for the Apple II project at MIT, and Brian Harvey directed a Boston Children's Museum project which developed a version of Logo that has had a long life, finding its way into at least one of the public domain versions of Logo now written in C.

OOPS! You're correct. The C64 used a 6510, which was a modified 6502 made by MOS Technologies, owned by Commodore. The main difference was the presence of a parallel I/O port at location 0 and 1. That's what caused me so many problems in dealing with the empty list, since the MIT Logo depended on those locations containing 0. To debug he C64 Logo, Commodore had MOS Technologies fabricate a special 6510 with an extra pin which signalled whether the CPU was fetching instructions or data from memory. They hooked a Nicolet-Paratronics logic analyzer to the chip, and ran it with a BASIC program on a Commodore PET, usings the IEEE-488 instrumentation bus!

I was confused about the 6809 because another thing I did with Logo was help produce the first Logo in Japanese, on the Hitachi Basic Master Mark IV, for Leona Publications, KK, in Tokyo, in 1983. It was the first Logo to use Hiragana, the syllable-based writing system which children learn first. But, that (and the more succesful LCSI version for the Fujitsi F7) is another story...

[larsbrinkhoff]

A photo of the word processor that evolved from the 3500.

EDIT: This is just a Concept-100 text terminal, but supposedly it's attached to a 3500. A close inspection reveals it's running the French language version of Logo.

[larsbrinkhoff]

In 1978, the Logo group applied for a duty-free purchase a TT3500 from Société Générale Tortue. From "Federal Register, Volume 43 No. 64-71". https://books.google.se/books?id=19j5gvgE8fYC

[larsbrinkhoff]

There even was a brochure. Courtesy of @hqm and Richard Amster.