34 comments

[ 1.5 ms ] story [ 53.7 ms ] thread
Second edition, with a new chapter on lambda calculus.
Thanks. I recently had to reinvent LISP to script my CRDT database. That was not much work, because I already had the notation (I use RDX, a JSON superset with CRDT types). Still, I stumbled at the idiosyncratic LISP bracketing. Luckily, RDX allows for different tuple notations. So, I styled it to look less alien to a curly-braced developer. Like this https://github.com/gritzko/go-rdx/blob/main/test/13-getput.j...

For example, print change-dir make-dir; is equivalent to (print (change-dir (make-dir) ) ) in the old money. I wonder if I am reinventing too much here.

Did LISPers try to get rid of the brackets in the past?

Looking at file church.scm from the provided zip file [1], I see the following functions used to construct lists:

    (define kons
      (lambda (x) (lambda (y) ((pair false) ((pair false) ((pair x) y))))))
    
    (define kar   (lambda (x) (first (second (second x)))))
    (define kdr   (lambda (x) (second (second (second x)))))
    
    (define nil   ((pair true) ((pair true) false)))
    (define null  first)
    
    (define atom  (lambda (x) (first (second x))))
That's 2 extra booleans per list element. While the one for recognizing atoms is probably necessary, the other one for recognizing nil is not:

    (define kons
      (lambda (x) (lambda (y) ((pair false) ((pair x) y)))))
    
    (define kar   (lambda (x) (first (second x))))
    (define kdr   (lambda (x) (second (second x))))
    
    (define nil ((pair true) false))
    (define null (lambda (x) (((second x) (lambda (a) (lambda (d) (lambda (z) false)))) true)))
    
    (define atom  (lambda (x) (first x)))
The use of null+car+cdr can usually be avoided by using a matching construct instead like

    (((second list) (lambda (a) (lambda (d) (lambda (z) deal_with_car_a_and_cdr_d ) deal_with_nil)
[1] https://t3x.org/lfn/church.zip
tug2024 wrote: > Doesn’t lisp extend lambda calculus (abstraction . application)? As a consequence, lisp (abstraction . application . environment)!

Another valid question downvoted into oblivion.

The environment in (lexically scoped) LISP is an implementation detail. Lambda calculus does not need an environment, because variables are substituted on a sheet of paper. So lambda calculus equals lexically scoped LAMBDA in LISP.

Sure, you could view LISP as LC plus some extra functions (that are not easily implemented in LC).

As somebody who read a couple of the author's books, and also somebody who spent almost a decade studying compilers, I am genuinely curious about the author himself.

These works are something I both understand and would never achieve myself. These are cultural artifacts, like deeply personal poetry, made purely for the process of it. Not practically useful, not state of the art, not research level, but... a personal journey?

If the author is reading this... can you share your vision? Motivation?

Read the author’s “Raja Yoga Revisited”.
+1, long time follower of nmh's work. His books are brief and concise, but carry a peculiar "something", a precision of expression etc that is hard to put into words - but can often be noticed in long-time practicioners of some mental teaching. :)

It is always interesting to spot a person on the interwebs who seems to actually have managed to turn buddhist or some other teachings into real world deeds. Living really modestly (IIRC, he/you also uses modest, underclocked laptops?), publishing for the benefit of many, and doing all this for years and years. Like, there seems to be no "overhead" in this way of living. Hugely inspirational.

I would also point out the "Essays" section on nmh's webpage, especially the ones discussing sensitivity and high IQ: https://t3x.org/#essays

Having purchased several of your books, thanks for your work, nmh!

> These are cultural artifacts, like deeply personal poetry, made purely for the process of it. Not practically useful, not state of the art, not research level, but... a personal journey?

I can't speak for the author but this is exactly how I look at the lisp I'm developing. It's a lifetime project. I had some kind of vision depicting how different things could be, and at some point I started trying to make it happen. I want to convince myself I'm not insane for thinking it was possible in the first place.

Many thanks to everybody who is wrote in this thread! Your words mean a lot to me! I will reply to some individual messages. If I don't, please substitute "thank you!" :)
"... and the chicks for free "?
I have listened to that song probably 100s of times and always heard "checks," so I just learned something new about that song. Thanks.

Maybe less embarrassing than talking about Rock the Cashbar by The Clash (though that one was corrected the first time I saw the back of the album).

The book looks awesome. However, I find some irony in the presence of a “no AI” badge on the back cover considering Lisp was AI research.
The title "Lisp from nothing"

doesn't seem to fit with:

"INTENDED AUDIENCE This is not an introduction to LISP."

on page 10.

Would you also think that "Energy from Nothing" must be an introductory physics text? :)
Has anyone here read his “Practical Compiler Construction”? It’s on of the shorter compiler books Ive seen, seems like it might be a good way to learn a bit more about assembly
I was very curious about this too. I've had my finger hovering over the "buy" button for months but there are next to no reviews on it. I'm wondering how it differs from other, similar works
Looks awesome. Just ordered a copy. I'm just now picking up Peter Seibel's Practical Common Lisp again and taking another stab at immersing myself in the world of Lisp. So this is perhaps fortuitous timing.
I love Lisp (I'm an Emacs user and often write in Racket for personal projects) but the one thing I never understood about the Lisp community is the emphasis placed on metacircular evaluators.

I sure find them beautiful and all, but why do they take center stage so often? Beside the aesthetics and instructional value, I don't get the appeal. Also I feel that a bunch of the heavy lifting behind metacircular evaluators is actually done by the Polish notation syntax as well as the actual implementation, and these concepts don't get nearly as much love.

Any Lisper who can illuminate me?

Damn. I ordered the first edition a few weeks back and now the second edition is out :D
Did you guys hear Ladybird is gonna be ClojureScript by default /dream
Under “The Intended Audience” (page 10 of the PDF sample on the site), it says that this is not an introduction to LISP and that it would be more enjoyable with some prerequisites.

Where does one — who has no knowledge of these prerequisites or about LISP (except that the latter has been heard in programming circles as something esoteric, extremely powerful, etc.) — start, before reading this book?

Can anyone compare this with Queinnec's Lisp in Small Pieces? I was waiting for an English version of the 2nd edition but I guess it's never happening and my French has unfortunately regressed since then.
The entire website of the author is worth exploring: https://t3x.org/index.html

I love it so much, and seeing your bibliography makes me feel like a kid in a candy store. The confluence of Asian philosophy and computing is delightful.

To put you in the correct headspace this Saturday morning: https://t3x.org/whoami.html

When it will stop ? The minimal languages... To be useful for something language need to have at least minimal standard library.

Or just possibility to do syscalls to do something. What is more important then new syntax and sugar over basic instructions.

I clicked on this and immediately wanted to buy it. But then someone in the comments said to also look at your other books and well damn, now I want to read all of them and I can't choose which to start with.
A hacker and a mystic. We need more of those.