If we&#x27;re naming names, for me personally, Lisp in Small Pieces by Christian Queinnec tops my Lisp books list. But, yes, only after perusing the SICP and The Little Schemer first.&quot;Liberal arts,&quot; nice :)

I think Lisp is more on the liberal arts side of programming languages.That the &quot;enlightenment&quot; of Lisp is that you can use functions everywhere. Write macros that look like functions and modify behavior, and build your code as a language.Things like monads are more on the evolution of functional languages, and I also fall off the bike. It&#x27;s as difficult as you want it to be, and I find scheme and lisp to be easier high level languages than javascript or python and makes more sense.The forward and preface to SICP is good reading.<a href="https:&#x2F;&#x2F;mitp-content-server.mit.edu&#x2F;books&#x2F;content&#x2F;sectbyfn&#x2F;books_pres_0&#x2F;6515&#x2F;sicp.zip&#x2F;full-text&#x2F;book&#x2F;book-Z-H-4.html#%_toc_start" rel="nofollow">https:&#x2F;&#x2F;mitp-content-server.mit.edu&#x2F;books&#x2F;content&#x2F;sectbyfn&#x2F;b...</a>The Dan Friedman books are pretty good in general: &quot;The Little Schemer,&quot;
and the sequel &quot;The Seasoned Schemer&quot; which are both more &quot;recursion&quot; books. He also has another book &quot;Scheme and the Art of Programming.&quot; Which I think is a great comp sci book that&#x27;s not too difficult and doesn&#x27;t seem too well known.How to Design Programs is supposed to be a pretty good comp sci intro:<a href="https:&#x2F;&#x2F;htdp.org&#x2F;2024-11-6&#x2F;Book&#x2F;index.html" rel="nofollow">https:&#x2F;&#x2F;htdp.org&#x2F;2024-11-6&#x2F;Book&#x2F;index.html</a>

I see mixed comments,
so let me add some praise.
I am one of countless, who match
his intro-filter:
repeatedly hearing &#x27;enlightened&#x27;
people lament that the vast masses don&#x27;t &quot;get&quot; lisp and FP,
and repeatedly attempting&#x2F;failing to pick up the red string myself.background - I am a computer science major with 30+ years experience. I did do a mandatory class of &#x27;implement your own lisp&#x27; many eons ago.
It just never really &#x27;clicked&#x27; for me.
 I do, by accident, assimilation and lazyness,employ
FP style designs in my software.
And I guess fp techniques gradually rub off on me from e.g. javascript, lambdas,closures, and map-filter-reduce.
 in particular, lambdas are useful to me.
 But I am one of the guys who
continue to read the &quot;let me tell you what monads really are&quot;, and every time I fall off the bicycle.
 So, well, I appreciated this &#x27;Xfor 5year olds&quot; :-)

There&#x27;s an upside to C&#x27;s limitations. Several times I&#x27;ve seen expressed the notion that &quot;every big Lisp project uses its own dialect of Lisp&quot;. This is less true in C, I think, because it doesn&#x27;t have the power (ignoring preprocessor abuse, which does happen, see Bourne shell source[1]). C++ has a bit more power, and there we see projects tend to use their own subset of C++.In both Lisp, and C++, taking some isolated snippet from a codebase, you can&#x27;t quite really be sure what it&#x27;s doing without reading the rest of the program because of what might be called the &quot;excessive&quot; power of the languages.In C, it is much more likely that you can look at an isolated snippet of code from some codebase and be reasonably sure about what it is doing, and be able to extract this snippet more or less as-is, and re-use it in some other, unrelated code base.[1] <a href="https:&#x2F;&#x2F;www.tuhs.org&#x2F;cgi-bin&#x2F;utree.pl?file=V7&#x2F;usr&#x2F;src&#x2F;cmd&#x2F;sh" rel="nofollow">https:&#x2F;&#x2F;www.tuhs.org&#x2F;cgi-bin&#x2F;utree.pl?file=V7&#x2F;usr&#x2F;src&#x2F;cmd&#x2F;sh</a>

There&#x27;s closures and there&#x27;s being able to transform the expression tree.Graham&#x27;s On Lisp is a really interesting book<a href="https:&#x2F;&#x2F;paulgraham.com&#x2F;onlisptext.html" rel="nofollow">https:&#x2F;&#x2F;paulgraham.com&#x2F;onlisptext.html</a>which is allegedly about programming with macros but I&#x27;d say 80% of the time he implements something with closures and then makes a macro-based implementation that peforms better. That 80% can be done in Python and the other 20% you wouldn&#x27;t want to do in Python because Python already has those features... And if you wanted to implement meta-objects in Python you would do it Pythonically.Graham unfortunately doesn&#x27;t work any examples that involve complex transformations on the expression trees because these are hard and if you want to work that hard you&#x27;re better off looking at the Dragon book.You can work almost all the examples in Norvig&#x27;s Common Lisp book<a href="https:&#x2F;&#x2F;www.amazon.com&#x2F;Paradigms-Artificial-Intelligence-Programming-Studies&#x2F;dp&#x2F;1558601910" rel="nofollow">https:&#x2F;&#x2F;www.amazon.com&#x2F;Paradigms-Artificial-Intelligence-Pro...</a>in Python and today Norvig would advocate that you do.

I don&#x27;t think you&#x27;re missing much. Yeah, the main point seems to be that if your language has closures, you suddenly can express a lot of things that were out of reach before. Not a new insight. But there&#x27;s another point I think that is hinted at on the topic of control abstractions. Or at least I&#x27;m reminded of the topic. It&#x27;s better and more succinctly and explicitly talked about in an early chapter of the free book Patterns of Software: <a href="https:&#x2F;&#x2F;dreamsongs.com&#x2F;Files&#x2F;PatternsOfSoftware.pdf" rel="nofollow">https:&#x2F;&#x2F;dreamsongs.com&#x2F;Files&#x2F;PatternsOfSoftware.pdf</a>The extra point might be that more languages should facilitate defining your own control abstractions just as they support defining your own data abstractions. Functions are one way of making data abstractions, but languages often provide multiple ways. Closures are one way of doing a type of control abstraction (involving such things as delayed or multiple evaluation), but there are other ways too. For some reason we see value and a need for defining our own data abstractions, but not so much for control abstractions, even though (according to the book) once they were often co-designed, like Fortran&#x27;s arrays and DO loop. And for some reason even in the few languages that do support making your own control abstractions, like Lisp, you&#x27;ll still find users who disapprove of doing so, claiming all you need are the standard existing methods like looping, map&#x2F;reduce style functions, and some non-local exits.

Currying is done automatically in Haskell but not in Lisp. If you wanted currying in Lisp you could write it, but Lisp programmers don&#x27;t depend on or talk about currying as much as Haskell programmers do.

In languages like Java (or C) you can build S-expression like structures like so<pre><code> Variable&lt;Integer&gt; x = newVariable();
 Expression&lt;Integer&gt; = add(x,literal(5));
 x.set(15);
 System.out.println(eval(x)) &#x2F;&#x2F; prints &quot;20&quot;
</code></pre>
and it is not that hard to either serialize these to code or run them in a tree-walking interpreter where quote() and eval() imply an extended language where you can write functions that work on Expression&lt;Expression&lt;X&gt;&gt;. Type erasure causes some problems in Java that make you sometimes write a type you shouldn&#x27;t have to and you do have to unerase types in method names which is a little ugly but it works.I did some experiments towards this to convince myself it would work<a href="https:&#x2F;&#x2F;github.com&#x2F;paulhoule&#x2F;ferocity&#x2F;blob&#x2F;main&#x2F;ferocity0&#x2F;src&#x2F;test&#x2F;java&#x2F;com&#x2F;ontology2&#x2F;ferocity&#x2F;TestFierceStrings.java">https:&#x2F;&#x2F;github.com&#x2F;paulhoule&#x2F;ferocity&#x2F;blob&#x2F;main&#x2F;ferocity0&#x2F;sr...</a>had I really kept at it I would have bootstrapped by developing a ferocity0 which was sufficient to write a code generator that could generate stubs for the Java stdlib + a persistent collections library and then write a ferocity1 in ferocity0, and if necessary ferocity(N+1) in ferocityN until it supported &quot;all&quot; of Java, though &quot;all&quot; might have omitted some features like &quot;var&quot; that are both sugar and use type inference that ferocity would struggle with -- if you need sugar in this system you implement it with metaprogramming.The idea is that certain projects would benefit from balls-to-the-walls metaprogramming and the code compression you get would compensate for the code getting puffed up. My guess is a lot of people would see it as an unholy mating of the worst of Java and Common Lisp. However, I&#x27;m certain it would be good for writing code generators.

The core point, to me, seemed to be about limiting factors in language extension. To allow something like:<pre><code> my_if (points &lt;= 100, printf (&quot;%D&quot;, points), error (&quot;Invalid point total&quot;));
</code></pre>
Where the various parameters are lazily evaluated.
Or like:<pre><code> frobnicate (frazzle: foo, frozzle: bar, frizzle: baz);
</code></pre>
Where frazzle, frozzle, and frizzle are position-independent keyword variables.Allowing those in C would require a modicum of effort, while other languages make these kinds of syntax extension fairly easy.

I find it is a real challenge to come up with a good title. On the one hand it should, probably, convey to the potential reader something about the contents of the article, on the other hand it should be something to differentiate it from the rest of the articles published on the same subject.I like those that read something like a punch-line, that come across as something different that just a summary of the article. But these maybe work best for literature, prose, movies, etc.

At least &quot;the dead C&quot; was a nice pun :D

Previously:<a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=28851992">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=28851992</a><a href="https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=44359454">https:&#x2F;&#x2F;news.ycombinator.com&#x2F;item?id=44359454</a>No comments on any of them.It sounded of interest to me, but I read it and closed the tab within a page or so as it wandered off into tech arcana. Shame. There may be an interesting idea in here but it&#x27;s phrased in terms I think few will be able to follow and understand.I did not finish it but I saw no mention of the lambda calculus or of currying, both of which -- from my very meagre understanding -- seem directly relevant to what I understood to be the core point, which seems to be about anonymous functions.

A Lisp adventure on the calm waters of the dead C (2021)