Hacker News Reader

Comment by kluck | Hacker News Reader

Lisp was developed because McCarthy needed a tool for experimenting with AI. Found a video of McCarthy talking about AI: https://www.youtube.com/watch?v=Ozipf13jRr4

And if anyone cares, here is nice Shirt with McCarthy on it ;) https://www.teepublic.com/t-shirt/666689-john-mccarthy-lisp-...

I think it should be mandatory for CS students to implement their own little Lisp using the building blocks McCarthy described! Instead they are learning Java and ist crappy OO...

View on HN

Is there a kind of walkthrough/tutorial about how to develop a little Lisp interpreter? That sounds like a fun experiment.

PS: Sorry, I am a Java OO developper. But I like to learn :)

Yes, this quite good book, "Lisp in Small Pieces"

https://www.amazon.com/Lisp-Small-Pieces-Christian-Queinnec/...

For example: http://www.buildyourownlisp.com/

But there's plenty more.

Another one https://github.com/kanaka/mal (quite famous AFAIK)

What I did was follow Paul Graham's Roots of Lisp[1]. He lays out in simple terms the basic operations, all I did was copy his examples into unit tests and then write code until the tests passed. I didn't even bother writing a parser, I just used JS expressions like this:

    	[natives.label, factorial, 
		[natives.lambda, [n], [natives.cond,
			[ [natives.eq, n, 0], 1 ],
			[ true, [natives.times, n, [factorial, [natives.plus, n, -1]]] ]
		]]
	]

It took me about 5 hours to get the whole think working from his paper, and I learned a lot in the process.

There's this classic by Peter Norvig (of AI a Modern Approach fame) about wrting a Lisp in Python...which also happens to have an amazing title :D

http://norvig.com/lispy.html

Edit: He also links to his Scheme interpreter in Java in that article: http://norvig.com/jscheme.html

>Is there a kind of walkthrough/tutorial about how to develop a little Lisp interpreter?

At least as many as there are TODO app examples for web frameworks...

https://danthedev.com/2015/09/09/lisp-in-your-language

A Lisp implemented through JavaScript arrays.

I've made a Lisp that compiles to Ramda.js, the source code is simple, http://github.com/yosbelms/ramdascript

I think it should be mandatory for CS students to implement their own little Lisp using the building blocks McCarthy described!

That used to be part of the intro course at MIT and Berkeley, but they've since switched to Python: https://web.archive.org/web/20091209071455/http://danweinreb...

> Java and ist crappy OO

* There are those for whom writing an AST acting on lists of lists of lists comes naturally. They have Lisp. For us idiots who model things in terms of state and behavior, and who prefer to let the compiler do the hard work of figuring out an AST representing our ugly, step-by-step solution, there is "crappy OO".

While ML was the meta language for a theorem prover. Funny how these were side effects.

If there's one thing I've learned from programming it's that to build anything good you have to be driven by real use cases.

It's not clear if your comment approves or disapproves the one you've commented.

It's not clear to me whether the comment I replied to viewed this as a good or a bad thing (all it said was "funny how..."), so I can't say whether I approve or disapprove. Hopefully it's clear where I stand though.

True. The only clear thing is that nothing is clear in this particular discussion branch. I'm ok with this but can't extract any useful information.

I think there's information, we're just not taking sides for/against. Which is fine.

Just like nature.

And ML was originally written in Lisp.

https://github.com/theoremprover-museum/LCF77/tree/master/sr...

https://github.com/theoremprover-museum/HOL88/tree/master/sr...

ps: I didn't bother to check those repos. Very nice to see old lisp code. It's very very clean. I often fear messy lisp 1.5 style but that's quite pretty.

And [O]Caml was originally called "Le-ML" because it was written in Le-Lisp (and targeted the same VM, LLM3).

someone tweeted that dan ingalls first smalltalk was in BASIC, I always assumed it was in lisp (considering Kay mention lisp in influences and that lisp was teh PL clay)

https://en.wikipedia.org/wiki/L_Peter_Deutsch

He worked on both the Lisp and Smalltalk low-level implementations at Xerox PARC.

I have a deja vu, didn't we have that discussion before ?

Reply on news.ycombinator.com