If you ever wondered how to write a programming language, this is probably the best resource to get started (and then of course Crafting Interpreters).
I've always found MAL ("Make-A-Lisp" https://github.com/kanaka/mal) a bit more approachable, probably because I was out after creating my own programming language before I've written much Python. It's language agnostic, and really easy to follow along with most programming languages out there, explaining everything as you progress.
That it's language agnostic and somehow matters feels weird now a lot of time (and experience I suppose) afterwards, but back when I only knew 1-2 languages by heart, also having to face understanding Python at the same time from Norvigs guide/reference made it slightly more complicated for me.
I use this as a litmus test now when coming across new languages (implementing MAL in the new language), as it's such an easy approach to practically test large parts of the new language, and there is always host-language-specific tricks you can learn along the way.
I've been working on a similar (ish) project for a while: Ribbit (https://github.com/udem-dlteam/ribbit). Supports a full R4RS REPL (with tail-calls) in the same sizes as Lispy (8Kb for JavaScript and 6.5Kb for x86)!
Interestingly enough, linguists also use Lisp-like parentheses or brackets to annotate sentence structures. Trees and brackets are isomorphic, as both phrase structure grammarians and the original SICP lectures pointed out.
The brackets in the title sentence would look a lot different though. ;-)
My Lisp from 1975 was actually used in real world and highly lucrative. Gemini could read the source code, but it told that my code was piece of shit and cannot be implemented in 64-bit world without drastic changes, so it made an example. But that version was just too advanced and too complex as a study subject. There are already enuff good Lisps in the world, methinks.
There are two problems with Lisp parentheses in my opinion:
1) Humans are not that equipped to handle that level of nesting without some other aid, this is why Lisp code is usually indented.
2) Parentheses aren't just about grouping, and this is unintuitive. For example, x is not the same as (x). This is a bit like in set theory where x is not the same as {x}, but parentheses do not look like the kind of sign that would work like that.
@bananaflag, the x versus (x) distinction is also what makes this evaluator so small: the AST uses atom versus list as the dispatch boundary, so grouping and application deliberately share syntax. An infix parser moves that complexity into precedence and associativity rules; it does not eliminate it. Indentation is still essential, but that is a tooling and display issue rather than a grammar issue.
I changed my opinion about parens when I stopped formatting like C, and used indent rather than parens to denote blocks. That is, a large amount of them at the end is totally fine.
I actually perfected the Norvig Lisp at one time. It has compiler to python and just everything. Those very few here that can actually read code, understand why this project soon exploded into biggest piece of odorous excrement.
There are edge cases where this fails, but `def parse(s): return json.loads('['+re.sub('([")])\s*(["(])','\g<1>,\g<2>',re.sub('[^()\s]+','"\g<0>"',s)).replace('(','[').replace(')',']')+']')` is a surprisingly robust lisp parser.
There is always someone better than you at almost everything you do, this is statistical reality.
If all you care about is the artifact and not the path, there is no reason to do anything.
Use the tool to better yourself, your understanding and push the limits of what is possible. If a Lisp in assembly with GC is now hello world, change what a hard project is.
I see this attitude a lot, and I think it is rooted in a sort of self-centered elitism. Anyone can do it, so why do it? Instead you could have the AI teach you how to implement it yourself with a deep understanding that no human, even if you paid them, would put up with.
It's funny, in the 8-bit days a lot of us learned programming for its own sake without much expectation it'd be lucrative. Took ~50 years to get back to that spirit as the default.
It depends why you're doing it. Are you doing it for the product or the process? (Of course, they're not mutually exclusive.) I do it for the fun of building, in which case AI is irrelevant.
> I don’t think a good learning resource gets worse[...]
Probably not, but they become irrelevant. The other day I found an old programming book at my parents’ and while it was still a terrific resource, I couldn’t image anyone learning a language from a book nowadays.
AI is doing the same thing but 100 times effectively than anything else.
Blog tutorials, guides, programming books and youtube tutorials. They are completely irrelevant in a time where you have a personal tutor willing to explain every single detail of a subject.
That's like saying your grandfather is irrelevant now that he's spawned children and grandchildren. Good luck to those personal tutors without this source material.
Related:
(How to Write a (Lisp) Interpreter (In Python)) (2010) - https://news.ycombinator.com/item?id=39665939 - March 2024 (91 comments)
(How to Write a (Lisp) Interpreter (In Python)) (2010) - https://news.ycombinator.com/item?id=30443949 - Feb 2022 (9 comments)
(How to Write a (Lisp) Interpreter (In Python)) - https://news.ycombinator.com/item?id=30327437 - Feb 2022 (3 comments)
(How to Write a (Lisp) Interpreter (In Python)) - https://news.ycombinator.com/item?id=26036431 - Feb 2021 (1 comment)
How to Write a Lisp Interpreter In Python (2010) - https://news.ycombinator.com/item?id=20590439 - Aug 2019 (29 comments)
How to Write a Lisp Interpreter in Python (2010) - https://news.ycombinator.com/item?id=12777852 - Oct 2016 (28 comments)
How to Write a Lisp Interpreter in Python (2010) - https://news.ycombinator.com/item?id=7825054 - May 2014 (41 comments)
(How to Write a ((Better) Lisp) Interpreter (in Python)) - https://news.ycombinator.com/item?id=1746916 - Oct 2010 (10 comments)
(How to Write a (Lisp) Interpreter (in Python)) - https://news.ycombinator.com/item?id=1745322 - Sept 2010 (39 comments)
See also part 2 https://norvig.com/lispy2.html
That it's language agnostic and somehow matters feels weird now a lot of time (and experience I suppose) afterwards, but back when I only knew 1-2 languages by heart, also having to face understanding Python at the same time from Norvigs guide/reference made it slightly more complicated for me.
I use this as a litmus test now when coming across new languages (implementing MAL in the new language), as it's such an easy approach to practically test large parts of the new language, and there is always host-language-specific tricks you can learn along the way.
The brackets in the title sentence would look a lot different though. ;-)
Common Lisp for Python: https://github.com/marcoheisig/cl4py
call Python from CL: https://github.com/digikar99/py4cl2-cffi
https://github.com/timonoko/nokolisp
Illuminating experience and it will also help you see (among many other things) the parentheses in a different light.
Needless to say that was my opinion and every day I think, more and more, how right he was.
(later I did make some gui apps that included scripting and chose s-expr syntax because of how simple it is to implement it)
1) Humans are not that equipped to handle that level of nesting without some other aid, this is why Lisp code is usually indented.
2) Parentheses aren't just about grouping, and this is unintuitive. For example, x is not the same as (x). This is a bit like in set theory where x is not the same as {x}, but parentheses do not look like the kind of sign that would work like that.
had brackets been displayed as curly braces in C - everything would look much more manageable
(aar (bar1 1 2 3) (bar2 1 2 3) (bar3 (car1 2 3)(car2)(car3)))
https://github.com/timonoko/nokolis.py
https://www.codesections.com/blog/raku-lisp-impression/
If all you care about is the artifact and not the path, there is no reason to do anything.
Use the tool to better yourself, your understanding and push the limits of what is possible. If a Lisp in assembly with GC is now hello world, change what a hard project is.
I see this attitude a lot, and I think it is rooted in a sort of self-centered elitism. Anyone can do it, so why do it? Instead you could have the AI teach you how to implement it yourself with a deep understanding that no human, even if you paid them, would put up with.
But sure, get depressed. But why tho?
just because someone or something else does it better?
I don't think a good learning resource gets worse just because there's a newer alternative.
Probably not, but they become irrelevant. The other day I found an old programming book at my parents’ and while it was still a terrific resource, I couldn’t image anyone learning a language from a book nowadays.
AI is doing the same thing but 100 times effectively than anything else.