Finding Lisp

I mean the famous example is of course,

(define (eval exp env)
(cond ((number? exp) exp)
((string? exp) exp)
((symbol? exp) (lookup exp env)
((eq? (car exp) 'quote) (cadr exp))
((eq? (car exp) 'lambda)
(list 'closure (cdr exp) env))
((eq? (car exp) 'cond) (eval-cond (cdr exp))
(else (apply
(eval (car exp) env)
(eval-list (cdr exp) env)))))

which uses a Lisp to define itself. This means roughly that if you understand enough Lisp to understand this program (and the little recursive offshoots like eval-cond), there is nothing else that you have to learn about Lisp. You officially have read the whole language reference and it is all down to libraries after that. Compare e.g. with trying to write Rust in Rust where I don't think it could be such a short program, so it takes years to feel like you fully understand Rust.

Indirectly this also means that lisps are very close at hand for “I want to add a scripting language onto this thing but I don't want to, say, embed the whole Lua interpreter” and it allows you to store user programs in a JSON column, say. You also can adapt this to serialize environments so that you can send a read-only lexical closure from computer to computer, plenty of situations like that.

Aside from the most famous, you have things like this:

1. The heart of logic programming is also only about 50 lines of Scheme if you want to…

Also from David A. Wheeler's 6502 Language Implementation Approaches (archive.org-ified to the time the links were written, or best approximation):

https://web.archive.org/web/20181112182918/https://dwheeler.com/6502/

Lisp/LOGO

The "skimp" page also includes a list of several 8-bit LISP implementations, including several for the 6502 [1]. This discussion lists more [2]. One useful implementation discussion (of many!) is R. Kent Dybvig's "Three Implementation Models for Scheme". University of North Carolina Computer Science Technical Report 87-011 [Ph.D. Dissertation], April 1987 [3].

neslisp [4] is a small subset of Lisp that generates 6502 code (NES); the as of version 0.1 it is released under the GPLv2 license (and thus is open source software). An older version is available via neslisp on Google code [5].

Picobit [6] (GPLv3) looks interesting. You program in Lisp (specifically a variant of Scheme) on a larger system; it then compiles to a VM that runs on the target. Currently it does not support the 6502, but the system is designed to be portable and it looks to me that it'd be relatively easy to port to a 6502.

Lysp [7] (MIT license) is another small implementation of Lisp. It doesn't directly support 6502 and is in C, but it's small... so it might not be hard to transliterate. A related program from the same developer is Maru [8], which can self-host. This could be a reasonable starting point for creating a 6502 Lisp.

Turning the Apple //e into a lisp machine,…

First off, I like the elegancy of the CPS approach, however...

The continuation-passing approach doesn't scale. Not only to multiple machines, as papersmith points out, but on a single machine. news.yc has (had?) problems with a theoretical DoS which pg has acknowledged in email: http://news.ycombinator.com/comments?id=18083 (post formatting corrupted by pg hiding then unhiding the post).

Dave Roberts has an interesting write-up of the approach: http://www.findinglisp.com/blog/2004/11/web-application-design-rest-of-story.html In email he said that talking about it with pg one time, pg made clear that for Viaweb it was only used for the web site the merchants accessed, not the many hoards of customers who accessed "normal" links, and only the links on the current page for that merchant worked, i.e. if you pressed the browser's Back button all the links on that old page were broken and the server would just present you with the current page again. In summation Dave said if your site is small enough continuations may work fine, but if it's meant to be the next big thing use REST and I agree.

C is the language some may love to hate, but an experienced developer will create clean, concise code. I remember reading through cifsd [1] by cinap_lenrek and thinking, ``my god, this is beautiful''. No boilerplate, just straightforward code. And yes, unobtrusive error handling.

Also, a blogpost post comes to my mind: ``A Timeless, Desert Island Language'':
`And that's why I'd choose C as my desert island language. Because in less than 10 pages of C, I can bootstrap a basic Lisp interpreter (...)'.

--

[1] http://plan9.bell-labs.com/sources/contrib/cinap_lenrek/cifsd.tgz

[2] http://www.findinglisp.com/blog/2008/06/timeless-desert-island-language.html

He rambles a lot, but he's right about the need for a new Lisp, and refers to the ILC'05 presentations by Dussud, Baker, and McCarthy on "Re-inventing Lisp". Those are some pretty radical proposals. (Summaries: http://www.findinglisp.com/blog/2005/06/ilc-2005-wednesday-report-late.html).

I think the trouble with Lisp (and Scheme) is that there's so much cruft and inconsistency beneath the veneer of simplicity (see http://tnovelli.blogspot.com/2009/08/lisp-crisis.html). Lisp is a great language to study; I just wish it was more practical and popular. It sucks having to choose between awkward (Lisp) and inflexible (everything else). :-(

Reddit was initially built on CMUCL on FreeBSD. Here is what Steve Huffman said on why they switched to python one weekend.

"The biggest trouble that plagued us was that we could never quite get Lisp reddit stable enough to sleep at night. There were weird threading issues that would bring the site to its knees a couple times a day and required constant monitoring."

You can read more of it in this blog entry.

http://www.findinglisp.com/blog/2005/12/reddit-and-lisp-psychosis.html

Edit: Corrected :-)