Let Over Lambda

What Hacker News says

1. andaiSep 2026
   Forgive me this long list, I hadn't the time to make it short!

   Function: a mapping from inputs to outputs, vs "a chink of code that runs and does arbitrary things with global state." Some languages resolve it by using the word procedure (and keyword proc).

   (For an amusing read on this subject, see Chapter 5 of Let Over Lambda, which argues that Lisp is actually the least functional language!)

   Deserve: can refer to unconditional rights, as well as conditional privileges. (e.g. "every child deserves a safe home", vs. "this person deserves to be punished.")

   Positive/Negative have at least 3 separate meanings depending on context (good, present, self-amplifying). e.g. positive feedback can means the system is about to explode, positive symptom can mean "CIA replaced my Shasta again".

   Normal can mean "happens all the time" or "is acceptable". Often those two are not in agreement. (People often fuse this one. If it's unusual then it must be bad! If it's common then it must be okay!)

   Meaningful: something "means" something if it points beyond itself (as a symbol), or if it doesn't (direct experience).

   Example: enjoying a sunset

   The experience itself can be deeply satisfying. Or you can project ideas onto it like "I'm blessed", "I earned it", so the experience "points beyond" itself.

   (Alan Watts has an excellent video on purpose and meaning, considering our approach to them a uniquely western neurosis.)

   Serious: committed, vs overly heavy. People often confuse the two attitudes, which creates a lot of inner resistance. (And ironically produces childishness due to resistance to maturity.)

   Selfish: prone to neglect others (bad), vs taking care of yourself (good and natural to every organism, yet often vilified in our culture). You can do both of course but they're kind of independent axes.

   Several authors have written in defense of selfishness, but were so abrasive that they did the idea more harm than good!

   Meditation can mean 10,000 different things, many of which are opposites (e.g. intentionally directing the attention, vs allowing it to wander freely). (Enlightenment is similarly open to interpretation, even within the same school of thought!)

   Show morethread
2. js8Jul 2026
   Personally, I grew beyond this. I tried Common Lisp, Forth and Haskell. I enjoyed books On Lisp and Let Over Lambda.

   Now I think the best programming language is Barry Jay's Triage Calculus, which is close to combinatory logic or untyped lambda calculus.

   But unlike lambda calculus (which is easily expressed in TC), triage calculus has a built-in quoting and introspection (similar to Lisp's CAR and CDR), which lets you easily add typechecking. So in TC, you can have any syntax you want, just by building the correct abstraction. It's truly an ultimate programming language.

   TC shows that there is a false dichotomy between programming language features and syntax on one hand, and the function/API definitions in the standard library or user code on the other hand. Every time you write a piece of code intended to be reusable, you're adding to the language. It can all be expressed as some term in TC.

   All the syntactic squibbles are a matter of habit. Although one syntactic feature you really want in TC is the let over lambda abstraction, because it's somewhat annoying to order combinators by hand.

   Show morethread
3. VohlenzerJul 2026
   I finished Let Over Lambda recently. I'm not an experienced lisp programmer but it's strangely readable if you allow yourself to not understand every little detail of the Common Lisp code. For example I hadn't read On Lisp. I had read The Little Schemer.

   It's a wonderful tour of advanced macro concepts. With several of the macros presented I found myself saying "well that's just x language feature in y" but that's missing the point. The point is that Common Lisp allows you to implement your own language features, with macros of course!

   This chapter is a wonderful climax to the whole book. Lisp moving Forth moving Lisp reminded me of the intertwined nature of DNA, RNA and proteins in Biology.

   There's great humour throughout the book, I especially enjoyed the little sideways jabs at Scheme programmers!

   Show morethread
4. Archit3chJul 2026
   I'm not fluent enough in Common Lisp for that book, but the patterns in Let over Lambda translate cleanly to Julia. You can have "Let over Lambda", "Let over Lambda over Let over Lambda", "Anaphoric Macros" (though you have to break hygiene with esc(), and in practice should just use the native julia do block), "Reader Macros" (via String Macros), "Pandoric Macros", and so on.
   thread
5. klibertpMay 2025
   Yup. Somehow, I prefer[1]:

       (funcall #~s:gi/abc/def/ "Testing abc testing abc")
   

   to the five lines of the equivalent made with macros, function calls, and keyword arguments.

   I know all the problems with reader extensions, really. I understand being cautious. But at some point, you gotta wonder: what's the point of the programmable reader when you're unwilling to add programs to it?

   [1] Let over Lambda: https://letoverlambda.com/index.cl/guest/chap4.html

   Show morethread
6. kamaalDec 2024
   Perl is one of those power tools(as recommended in Let Over Lambda, together with vim and Lisp), if you learn it well enough to be good at it, and early enough in your career- You really have a mad productivity work horse. Its really one of those things which save tons of time and effort. A bit like O(1) hack of the productivity world.

   Perhaps at the core of this just how many what we called regular programming tasks are just knowing how to work with text and unixy operating system. Perl is just unbelievably awesome at this. Another big edge of Perl is commitment to backwards compatibility, most people who learned Perl early in their careers decades back can use it on-demand basis. Its universally installed, fast and scripts written from the earliest days continue to run with 0 changes, despite endless OS upgrades.

   Early enough in the timeline Perl was full unix hackers, and you learned a lot from them, this culture further bolsters Perl's productivity credentials. Not a week passes, that I have to whip up a Perl script to do something for someone has a 2 people and a month budget to do. And they are often amazed it can be done this quickly.

   CPAN is another big edge Perl has. No other language apart from JS/npm ecosystem has anything close, and these are basically competing in very different domains so to that end CPAN really doesn't have a competition till date.

   If you are looking to build using Perl do checkout the Camel book and HOP by mjd.

   Show morethread