[capableweb]

If you want to learn languages, implementing a lisp interpreter is a great exercise, and lots of fun too. Every time I come across a new language I want to give a try, creating a lisp interpreter is one of the first things I do.

If you're curious but want a more language-agnostic guide, mal (Make a lisp) is a language+project that has a guide you can follow along with basically any language, and if you get stuck, you can look at already implemented versions in practically any language: https://github.com/kanaka/mal

Personal favorite implementations of mal: nasm (assembly) (https://github.com/kanaka/mal/tree/master/impls/nasm) and wasm (https://github.com/kanaka/mal/tree/master/impls/wasm)

mal has also been discussed many times on HN (which is probably how I came across it the first time too) for close to a decade by now: https://hn.algolia.com/?query=kanaka%2Fmal

[marcpaq]

Agreed. BYOL and MAL are excellent work.

I had fun making an interpreter in ARM assembly:

https://github.com/marcpaq/arpilisp

Since the world obviously needs another book on Lisp-making, I'm thinking of porting it to arm64 and expanding it into a book.

[KineticLensman]

I agree about MAL (which I also came across thanks to HN). I've seen comments on HN to the effect that you are better off looking at the source code of an open lisp to understand how to do it properly, but I found working through MAL really educational and motivating. I was really pleased when I got my MAL implementation (in C#) to self-host.

I only really cheated once (by looking at an existing implementation) and that was when I was implementing macros. I discovered I'd misread something in the MAL guide and was doing the correct things, but in the wrong order.

I'm now doing MAL again in Rust as a way of going up the Rust learning curve, and when I've done that (or enough) I'm going to see if I can code a garbage collected version of MAL (probably using 'Crafting Interpreters' as a guide - another really superb instructional resource).

[avmich]

I think MAL is rather demanding. Each step wants you to write specific functionalities which may not be absolutely crucial. Sometimes it's hard to assemble pieces in coherent enough MAL-satisfying whole. I guess MAL wants to be able to test automatically everything, but it still feels more problematic than it should.