David Keenan

For a visual representation, the classic "To Dissect a Mockingbird" is always good: https://dkeenan.com/Lambda/

This is a classic book (related to lambda calculus): https://en.wikipedia.org/wiki/To_Mock_a_Mockingbird This is a very cool article on lambda calculus that relates to it: https://dkeenan.com/Lambda/

I thought the same thing, and was going to link to that same article. The paper giving the BLC self-interpreter is one of my favourite ever. For anyone interested in the graphical representation of terms like this I recommend To Dissect a Mockingbird: https://dkeenan.com/Lambda/

For what it's worth, this intuition is sound and I think it works just as well if you formalize[1] it to be used to illustrate the lambda calculus. [1] http://dkeenan.com/Lambda/

Here's another from a long time ago: https://dkeenan.com/Lambda/

Re: visualizations of lambda terms, also see "To Dissect a Mockingbird" https://dkeenan.com/Lambda/

In 1996 DC Keenan wrote "To dissect a mockingbird" [1] giving a graphical notation for lambda calculus, expressing it in pictures with an evocative semantics. 28 years later the linked piece gives a categorical string-diagram version. Applications arise when you are interested in mappings that have extra behavior other than that of functions, as in probabilistic programming, automatic differentiation. [1] https://dkeenan.com/Lambda/

That's 9 bits, or 512 total combinations in that grid; thus, theoretically one should be able to fit all of ASCII, but many of the characters would be very difficult to distinguish or recognise. (Incidentally, a common 7-segment display can also fit all of ASCII, and if you include a decimal point too, can represent a single byte completely: https://dkeenan.com/7-segment%20ASCII%20characters.txt )

(I think) this is a modern rendition of David Keenan's To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction [1], also linked in the OP. Perhaps you might appreciate the original better. [1] https://dkeenan.com/Lambda/

They're called "Lambda Diagrams". See the inventor's homepage [1], and some animations [2]. There's actually a long and obscure history of visualizations for lambda calculus. One of the originals is "To Dissect a Mockingbird" [3], which if I recall correctly, was the main thing on the internet in 1996. [1] https://tromp.github.io/ [2] https://www.youtube.com/playlist?list=PLi8_XqluS5xc7GL-bgVrxpA2Uww6nK0… [3] https://dkeenan.com/Lambda/

Are you referring to the bird songs from Raymond Smullyan's "To Mock a Mockingbird?" I found this breakdown after a cursory search http://dkeenan.com/Lambda/

I have Turing’s Theta Combinator: http://dkeenan.com/Lambda/Graphical_lambda26.gif

Previous discussions (I wish HN did this automatically): https://news.ycombinator.com/item?id=4586692 https://news.ycombinator.com/item?id=600736 Related: "To Dissect a Mockingbird" http://dkeenan.com/Lambda/index.htm (also previously discussed on HN: https://news.ycombinator.com/item?id=7684210)

I don't actually find this explanation easier to understand... I find "To Dissect A Mockingbird" a more intuitive and simpler explanation of Lambda Calculus. I think the visuals help a lot. http://dkeenan.com/Lambda/

In case you're wondering, I believe the reference is to this page: http://dkeenan.com/Lambda/index.htm

In pure functional programming, so well mentioned in some PG's articles, you have only functions - no numbers. You can make numbers from functions, though. Then, you may have a basis - a set of functions which are sufficient to represent arbitrarily complex algorithm, i.e., Turing complete set; see here - http://dkeenan.com/Lambda/ . Such a set may consist from only one function. So, the whole program is a structure of calling that function. Writing down such a program, we obviously don't need to write the function - it comes by default; we only need to write the structure, which can be represented by ( and ) . In a different way, than what I see here, but still - one bit per parenthesis, very simple processor, lots of memory and lots of steps for simple operations - a Turing tarpit...

A relevant read is To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction at http://dkeenan.com/Lambda/index.htm

Graphical programming and lambda calculus can go together well. Have a look at "To Dissect a Mockingbird: A Graphical Notation for the Lambda Calculus with Animated Reduction" (http://dkeenan.com/Lambda/) for some ideas.

Its like a version of math where you're representation of "2" is "++" so the expression 2 + 2 becomes "++" + "++". "It is a wonderfully bizarre fact that each song of a combinatory bird is not merely the name of another bird but is actually a complete description of the internal plumbing of that other bird. That is, each song is actually a brain map of some bird. Since a song is a complete description of how some bird will respond when it hears another bird, and the only important thing about a combinatory bird is how it responds when it hears another bird, we see that songs and singers are interchangeable. So we can say that the birds sing birds to each other, or we can equally say that what we have is a bunch of songs that sing songs to each other! Combinatory birds exist at an almost mystical level. Their language has no distinction between verbs and nouns. A description of action can equally well be a name." https://dkeenan.com/Lambda/ The bird K was defined as True, and KI as False (try not to think about the fact True(x) / False(x) evaluates to something). The claim is that the bird M is logical OR. We can test this exhaustively. M repeats the first word twice, K omits the 2nd word, and I is just there. Leftmost bird is always the next in line for evaluation. or(false,false): M(KI)(KI) : (KI)(KI)(KI) : I(KI)(KI) : (KI)(KI): I(KI) : (KI) = false or(true,false): MK(KI) : KK(KI) : K = true or(false,true): M(KI)K : (KI)(KI)K: I(KI)K : (KI)K : IK : K =…

Just a warning: at least for me, once I got started, it became addictive to try, Oulipo-like (http://en.wikipedia.org/wiki/Oulipo), to write simple programmes in these ever-more-restrictive languages. I was helped along immensely by Hindley–Seldin (http://www.cambridge.org/us/academic/subjects/computer-science/program… and, for, as one would expect, a more friendly but still thoroughly mathematical introduction, Smullyan (http://en.wikipedia.org/wiki/To_Mock_a_Mockingbird). I am not alone in my admiration for the latter; see, for example, http://www.angelfire.com/tx4/cus/combinator/birds.html. EDIT to add: Speaking of 'Mockingbird' articles, you may be interested in Appendix A of http://dkeenan.com/Lambda/index.htm, whose author discusses another interpretation, attributed there to Barendregt, of Booleans and numerals. For someone who regards the Church encoding as 'intuitive', they were very surprising!