
A micro manual for Lisp – Not the whole truth (1978) [pdf] - tosh
http://www.ee.ryerson.ca/~elf/pub/misc/micromanualLISP.pdf
======
lispm
An only slightly altered version for Common Lisp. The LABEL syntax is slightly
different to make it valid CL.

[https://gist.github.com/lispm/d752d5761f7078de4041d4e453e70c...](https://gist.github.com/lispm/d752d5761f7078de4041d4e453e70cbe)

Tasks to explore:

Check that it is actually equally to the published code.

Check that it can interpret itself.

Understand the language it implements and the consequences of no error
checking...

    
    
      MCLISP 139 > (mclisp:mccarthy-repl)
      mce> (label example (lambda (foo bar) (cons (cons foo 'nil) (cons 'bar 'baz)))
                  'qix 'qux)
      ((QIX) BAR . BAZ) 
      mce>

~~~
marcpaq
An only slightly altered version for Raspberry Pi/ARM assembly:

[https://github.com/marcpaq/arpilisp](https://github.com/marcpaq/arpilisp)

------
drtse4
And some implementations in:

\- C: [https://nakkaya.com/2010/08/24/a-micro-manual-for-lisp-
imple...](https://nakkaya.com/2010/08/24/a-micro-manual-for-lisp-implemented-
in-c/)

\- Python: [https://github.com/mario-goulart/not-the-whole-
truth](https://github.com/mario-goulart/not-the-whole-truth)

\- Javascript:
[https://kybernetikos.github.io/Javathcript/](https://kybernetikos.github.io/Javathcript/)

\- Swift: [https://www.uraimo.com/2017/02/05/building-a-lisp-from-
scrat...](https://www.uraimo.com/2017/02/05/building-a-lisp-from-scratch-with-
swift/)

~~~
flavio81
For practical (mature, usable in production) implementations i'd recommend:

in C: ECL compiles Common Lisp down to C or allows it to be embedded in a C
program

Python: "Hy" allows to write Python with lisp syntax

Javascript: Parenscript compiles a Common Lisp subset to javascript.
Clojurescript compiles a Clojure subset to javascript.

~~~
mark_l_watson
I spent a whole evening last week playing with Hy Lisp (written in Python). It
was fairly easy to write to the Keira’s APIs. Can anyone share any interesting
HyLang uses/ applications?

------
shawn
Lots of Lisp interest today! Here are a few resources.

On Lisp:
[https://www.lurklurk.org/onlisp/onlisp.pdf](https://www.lurklurk.org/onlisp/onlisp.pdf)

Lumen - a Lisp for JavaScript and Lua:
[https://github.com/sctb/lumen](https://github.com/sctb/lumen)

The Art of the Interpeter:
[https://dspace.mit.edu/bitstream/handle/1721.1/6094/AIM-453....](https://dspace.mit.edu/bitstream/handle/1721.1/6094/AIM-453.pdf?sequence=2)

(^ this last one is _very_ practical. If you reach the point of wanting to
implement a practical interpreter, this paper will force you to consider many
unexpected cases.)

Simulating circuits with Lisp:
[https://mitpress.mit.edu/sites/default/files/sicp/full-
text/...](https://mitpress.mit.edu/sites/default/files/sicp/full-
text/book/book-Z-H-22.html#%_sec_3.3.4)

My favorite part of SICP:
[https://mitpress.mit.edu/sites/default/files/sicp/full-
text/...](https://mitpress.mit.edu/sites/default/files/sicp/full-
text/book/book-Z-H-24.html#%_sec_3.5.4)

War stories: [http://paulgraham.com/avg.html](http://paulgraham.com/avg.html)

Lisp in _Jak 'n Dexter_ / _Crash Bandicoot_ : [https://all-things-andy-
gavin.com/2011/03/12/making-crash-ba...](https://all-things-andy-
gavin.com/2011/03/12/making-crash-bandicoot-gool-part-9/)

Fun fact: Lisp is still used today in gamedev! _Last of Us_ uses it heavily:
[https://www.youtube.com/watch?v=Ox2H3kUQByo&t=2415s](https://www.youtube.com/watch?v=Ox2H3kUQByo&t=2415s)

~~~
jihadjihad
+1 for the link about Andy Gavin's work on _Crash Bandicoot_ and _Jak and
Daxter_. This past winter I dusted off my PS2 and started playing Jak and
Daxter again, the first time in about 15 years. I noticed something I had
never noticed before: even though it is one of the first games released on the
PS2, the game loads _almost instantaneously_ when you hit the "New" or "Load"
buttons.

I had to know why, and came across that exact link you referenced. AG had
figured out how to do a lot of preprocessing while the game boots up,
obviating the need for a lengthy "Loading..." screen. Naughty Dog wrote some
very impressive software, that is for sure!

~~~
shawn
Yes! I've been fascinated with GOAL / GOOL for nearly a decade. I ripped a
copy of Last of Us and tore through the game data looking for the lisp code,
but unfortunately they only ship the compiled output.

What I wouldn't give to see the source... And Viaweb's source, and HN's
source, and gosh there are so many amazing Lisp systems out there.

~~~
pjmlp
Well you can the Lisp code of Abuse, which was quite entertaining in the late
90's.

[http://abuse.zoy.org/](http://abuse.zoy.org/)

[https://archive.org/details/abuse_sourcecode](https://archive.org/details/abuse_sourcecode)

~~~
shawn
oh

my

you just made my week, month, and year. I've been looking for a practical
Lisp-based game design since I was a teen! Dude.

Thank you.

EDIT: THIS IS SO COOL
[http://abuse.zoy.org/browser/abuse/trunk/data/lisp/guns.lsp](http://abuse.zoy.org/browser/abuse/trunk/data/lisp/guns.lsp)

Edit2: Whoops, fixed the link. I meant to link to this lisp codebase, not
SICP. :)

Suffice to say, Abuse is amazing. Thanks! This is an absolute gem of a
reference for seeing what worked in practice for Lisp-based gamedev. And in
1995 too!

