5

Wikipedia has a long list of Logo implementations, but I'd like to know what the earliest implementation is on a microcomputer, or, more likely, what are the earliest ones if there isn't one with clear priority. (I am not interested in mainframe or minicomputer implementations.)

I'm looking for the language implementation here, not just something that lets me do turtle graphics. (In fact, if it doesn't have turtle graphics, I couldn't care less.)

And if the earliest ones on microcomputers did not offer tail call optimization, which one is/ones were the first to do that? (I ask because it appears to be that TCO is pretty essential to Logo, unless a lot more extensive iteration support is added beyond what the standard language seems to provide.)

Bonus points if you can point me to a source for the code so that I can run it in an emulator (or on real hardware).

  • 5
    (not my downvote) - See discussion here: retrocomputing.meta.stackexchange.com/questions/739/… . "What was the first..." - questions seem to be controversial – tofro Sep 16 at 6:45
  • 1
    I don't understand why knowing the earliest microcomputer Logo implementation is useful in any way, when the language developed from mainframe and minicomputer implementations and was only eventually ported to micros. If you want to understand why some features are present and some are not in a particular implementation, you can't ignore the predecessors. – dirkt Sep 16 at 11:28
  • 2
    But none of this is captured by "first microcomputer implementation". If you want to know how much of the language could be made to run, you want to look at more mature implementations on the same hardware as the first implementations. And not the first implementations themselves, which would inevitably sacrifice features for being able to sell a working product. – dirkt Sep 16 at 11:59
  • 1
    "So go ahead and check it." Finding the implementations to do so is precisely why I asked this question. So we're in I guess what you would call "violent agreement" here, then? – Curt J. Sampson Sep 16 at 12:30
  • 1
    What's a micro? A PDP-11 for example is exactly a PDP-11, regardless of whether it's in a 19" rack or some BK-0010 or H-11 type thing. In the former case it's a more or less a mini, but in the latter case it's definitely a micro. So are you interested in Logo implementations for the PDP-11 architecture? – Wilson Sep 16 at 14:50
8

Wikipedia has a long list of Logo implementations, but I'd like to know what the earliest implementation on a microcomputer is or, more likely, what the earliest ones are if there isn't one with clear priority. (I am not interested in mainframe or minicomputer implementations.)

A good starting point is here, as a quick introduction to understand from where the first logo microcomputer implementations came from.

The first LOGO implementation in its inception was designed at the MIT Artificial Intelligence Lab (1967) as a simplified derivative/dialect of LISP. After spreading across several labs they started to work with several elementary schools, even though no microcomputers where still publicly available at that time (1971).

LOGO had to wait to jump into the microcomputer market at the late 1970s. Among the earliest microcomputers to have a LOGO implementation there's the Apple ][ (1980 LCSI Logo;PASCAL-based) as well as the Texas Instruments TI 99/4 (1981, PASCAL-based)

And if the earliest ones on microcomputers did not offer tail call optimization, which one is/ones were the first to do that?

Neither LISP nor PASCAL supported TCO (more details there), so the first LOGO implementations didn't support either TCO as long as they were based on these early, high level languages.

It looks like there's a Berkeley's UCBLogo based program mention about a 'tailend recursive call' here. We find another example in the following link, so probably UCBLogo may be the first one.

For further reference, here's an astounding list of all the Logo derivatives produced for any machine and a family tree with their relationships at the final pages to review.

Bonus points if you can point me to a source for the code so that I can run it in an emulator (or on real hardware).

A real trip to another time may be to try this IMP-based implementation, or dive into a Common LISP implementation there. Here's a tail call implemented, modern approach for Windows and another tail call implemented one in JavaScript.

Finally, here's an UBCLogo compatible example with TCO.

Just as trivia:

  • Scheme (1970) is among the earliest mainframe languages to support TCO
  • Micro-Prolog (1980) was a popular TCO-supported language for 8-bit microcomputer machines, sold until 1990.
  • Actually, I'm specifically intersted in only microcomputer Logo implementations here, not anything running on mainframes or minis. I've also updated my post to explain why I'm interested in TCO in Logo specifically. – Curt J. Sampson Sep 16 at 11:04
  • Ok! I've updated the post with all what I could have found at this time. Looks like UCBLogo is the answer, it's source code is available and there's a github project that works around the language and TCO too. – ignos Sep 16 at 11:56
  • 2
    Early source code for the Apple II MIT Logo (cross-compiled on a PDP-10) is e.g. here. – dirkt Sep 16 at 12:09
  • Cool! I've found that Micro-Prolog supported TCO for Apple II there. You can also find the disassembled source code of Micro-Prolog for the ZX Spectrum there – ignos Sep 16 at 13:16
  • 1
    @ignos Thanks. The Apple Logo II (1984) descendent of MIT Logo definitely had TCO (I have verified this), and from the review of earlier derivatives in the August 1982 BYTE magazine it looks like those did too; the author specifically mentions writing test routines to remove tail calls in order to avoid TCO. There's also a comment in the '82 MIT source, "UFUNCL calls a ufun, pushing a new stack frame or calling XTAIL to tail-recurse." – Curt J. Sampson Sep 16 at 16:35
3

Given that much of the early '70s work on Logo was done at the MIT AI Lab (link from ignos), it seems quite possible that the microcomputer implementations that they started in 1980 were at least among the first, if not the first.

The sources for various early versions (and some other software and documentation) are available in the files/aplogo/ subdir of the ITS archive (link from dirkt). There are also some other programs and some usage documentation They're a bit of a mess, but poking through them we seem to have the following:

  • usage.doc: A brief summary of the commands. Undated, and many of the commands in this appear not to exist in the versions of Logo below. (The screen editor commands are documented here.)
  • logo.958 (13451 lines): Seemingly the earliest version, marked "Preliminary Version" and "Assembled 8/06/80." There's a disk image, LOGO.dsk, available in the pneubauer/ptp2bin repo on GitHub that appears to be a build from this source. (The README in that repo points to a different repo that now has newer source, but this source is in its history.) This version seems to be a bit buggy; in my testing it frequently crashed into the machine-language monitor.
  • nlogo.931 (13348 lines): Hard to tell if this is earlier or later than logo.958; it has the same "Assembled" date embedded in it.
  • slogo.1 (14858 lines): "Development version; Assembled 11/22/80."
  • lsave.1300 (14445 lines): "Assembled November 25, 1980."
  • msave.6 (14480 lines): "Assembled December 18, 1980," "For MIT internal use only."
  • nlogo.378 (13014 lines): "Assembled 11 June 1981," "For use at authorized test sites only."
  • logo.299 (15018 lines): This seems to be the version for which there are many disk images on archive.org, usually labeled "MIT LOGO for the Apple II" and sometimes "1.0". Contains "This version assembled 7/9/81."

The logo.299 version has tail call optimization (or supports an improbably large call stack of at least depth 5000). I wasn't able to test the logo.958 version because I couldn't seem to get it to store procedures correctly.

The August 1982 BYTE magazine has a review including the commercial releases of these, "Logo for the Apple II, the TI-99/4A, and the TRS-80 Color Computer" (p.230). It covers the Apple Logo, Kriel Logo and Terrapin Logo variations. Archive.org has an image of Terrapin Logo 1.0 (4am crack).

If you need a version with more free nodes (heap, memory), Apple Logo II (1984) and its Apple Logo II Reference Manual is the 128K Apple IIe/IIc descendent of these. And Terrapin's later (3.0) LOGO for the Apple II Technical Manual has some technical information about their implementation that may be useful.

  • 2
    It runs well enough that 4am has compiled a working disk which can be tried out in your browser on on archive.org – dirkt Sep 16 at 12:15
  • 2
    Manual (sort of). – dirkt Sep 16 at 12:18
  • @dirkt Great find! Booting the image from GitHub it shows that it does indeed seem to have been built from the earlier 8/06/80 version whose source I linked, though the link in the README for that repo links to newer source. Do you want to cons up an answer for this, or shall I just edit mine? (BTW, the archive.org link you give is to the newer version, not the older one.) – Curt J. Sampson Sep 16 at 12:26
1

I can't answer the question "what was the earliest microcomputer Logo implementation", but I can give some details on one early microcomputer Logo implementation, namely MIT Logo.

As ignos has outlined in his excellent answer, LOGO started as a simplified Lisp variant on a PDP-10 mainframe, and then was ported to microcomputers, among those the Apple II.

The source code for Apple II logo has recently been found; it's available on github, and more files and variants are in a sister repository.

Note that development all happened on a PDP-10 under ITS; it's cross-assembled to the Apple II, and it's complete enough you can run this on a PDP-10 emulator, then convert the resulting file to an Apple II disk image, and run this image in an emulator, for example online on archive.org directly in your browser.

So how would the porting process work? You'd need to write a lisp-like interpreter, first for the core functions, then for the rest of the functions; finally you'd hit the space constraints of the microcomputer, and would have to make decisions which parts to keep; you'd tinker with the implementation to compact it and get a bit more space, or you'd add an overlay or paging system etc.

This is of course conjecture to some degree, but if you've ever written programs yourself, you'll know there's not much choice in this. You can see traces of this in various of the files:

DOC.187 mentions three "unwritten" routines, XFLOAT, XINT, and XFCOMP (which seem to be implemented in the actual code files), so that's the kind of non-core features you won't implement at first and add later.

If you compare logo.958 (older) with logo.299 (newer), you'll see

;      LOGO:     $4000 - $95FF: $5600 bytes (21.5K bytes)

versus

;      LOGO:     $4000 - $977F: $57FF bytes (22.5K bytes, maximum) Logo code

so in the later stage the code has been tinkered with to allow for more space for the user-defined Logo code (while increasing the interpreter source code size from 209,446 bytes to 278,794 bytes).

And so on.

Actually, LOGO isn't the only system which was ported from a mainframe to micros in this way (using some sort of virtual machine), two others are Zork and UCSD-Pascal (which ended up using paging and overlays, respectively, while LOGO didn't seem to have made this step).

BTW, this LOGO variant ran on a Apple II with 48K and a language card (64K RAM total), no need for an 128K //e or //c. (And I know this from personal experience, because I used it back then on an Apple II).

So you see, if you are

interested specifically in how much of the language could be made to run and how useful it could be in within the constrained resource environment (particularly memory) of early microcomputers,

you (a) cannot dismiss the mainframe code, and (b) cannot restrict yourself to the "earliest" implementation; lots of interesting things happen in the later implementation.

In particular, it probably would be very educating to compare this one to the PDP-11 implementation (also available in the github repositories mentioned) and the original PDP-10 lisp implementation.

So, please, don't ask about "what is the earliest microcomputer implementation of X?" if you are really interested in "how do LOGO implementations on microcomputers deal with the resource restriction on micros?"

These are two completely different things. For the latter, you need the context (like all intelectual exercise, software development doesn't happen in a vacuum): both before (on non-microcomputers) and after (not the earliest variant).

  • I think we had a simple miscommunication: when you talked about looking at "later" versions I assumed you meant something like Apple Logo 2 (which did not run on a 64K Apple II), not that you meant I should look at a final 1.0 release that came out only a half-kilobyte larger than a previous preliminary release of the code. I agree that it's fine to look at logo.299 instead of logo.958; I consider both those to be more or less equally the earliest version that we know of (at this time). – Curt J. Sampson Sep 16 at 19:36
  • That said, comparing logo.299 to, say, the LLOGO source, I'm having difficulty figuring out how the latter gives me insight into how Logo can be packed into a much more constrained environment than a PDP-10; perhaps you could go into a bit more detail about that, with an example or two? – Curt J. Sampson Sep 16 at 19:45
  • It doesn't give you insight into "how Logo can be packed into a much more constrained environment". Actually, even the Apple implementation doesn't give you that insight, it only tells you "how can I implement a reduced Lisp on the Apple II, and which features do I prefer to keep, and which do I throw away." However, comparing it to the PDP-10 and the PDP-11 implementation (a PDP-11 segment only has 64KB, so it's not that far from the Apple II) does tell you which Logo features the developers consider important, and which they consider less important. – dirkt Sep 17 at 13:39
  • If you want insight into "how can I pack more things into an Apple II", the way the software developers would do that is to throw away the whole thing, and start over based on the experiences with the first implementation. So if you can find a second implementation by the same developers, that would be worthwhile looking at. (And in general, the answer to "how can I pack more things into constrained space" is nearly always "increase code density by doing some kind of interpreter": this trades space (less bytes for code) against time (interpretion is slower)). – dirkt Sep 17 at 13:42
  • This doesn't seem consistent with the actual code, though. I spent a day or so playing with Apple Logo II, which required 128K instead of the 64K that Apple Logo required, and they had stopped using tricks like using the graphics memory as the edit buffer for the full-screen editor. (And that kind of trick is what I was looking to find.) – Curt J. Sampson Sep 17 at 14:16

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.