Joe Marshall (funcall)

The classic issue of who made the first tongs could be inserted here, with some hammering. (It's a classic legend. There is an Islamic legend that Allah gave the first pair of tongs to the first blacksmith because you need a pair of tongs to make a pair of tongs. There's a Nordic legend that Thor made the first tongs. In reality, somebody probably used a bent piece of green wood, which didn't last long, but could be easily replaced.) His piece "Vibe Coding, Final Word"[1] is relevant right now. [1] https://funcall.blogspot.com/2025/04/vibe-coding-final-word.html

Worth reading only if "because ignorance" is useful knowledge to you. In any case, you'd be better off starting at http://funcall.blogspot.com/2009/04/you-knew-id-say-something.html, which tries to clear up some of the misconceptions Guido was laboring under at the time.

It's a lovely blog series, worth delving into other bits and pieces. This one is particularly relevant. Tail-call optimsiation _not_ implemented and why. Usually the sort of thing that is not mentioned when celebrating all the good fun of lisp. https://funcall.blogspot.com/2009/04/lmi-flashback.html

This post does a really good job of analyzing first-class environments and explaining why "first-class environments are useless at best, and dangerous at worst": http://funcall.blogspot.com/2009/09/first-class-environments.html

It's worth reading the Abstract Heresies' entry that turned my attention to this paper: http://funcall.blogspot.com/2010/05/c-vs-lisp.html (After giving it a thought I posted this entry to HN too, as I probably should have done in the first place... :)) The date is interesting, 1992 - it would still take years for Java to implement it...wrong.

Also, this blog post (which did the rounds on HN a while back) was excellent for understanding it: http://funcall.blogspot.com/2009/04/you-knew-id-say-something.html (It's part of a 5 part series... but you don't have to necessarily read all of them... it kind of wanders.)

I came to ruby from the perl side. It was "here's a Redmine server, here's a feature request for one of the in house built plugins." I forget the specifics (it was 2011) ... but trick of the feature was to add a function to the object being created so that it would have the function some other module was expecting. And it worked... Things like that made me give it the sideye for anything more than I could keep in my head at once... if I started needing to look at other files to determine if there was anything odd there... "can I create a function here in this parameter passed to me? What if someone else created a function of the same name before they passed it to me and expected it to remain?" It can work... but it requires a bit more discipline than the developers I was working with had as a baseline (for that matter, a decade and a half later at a different job with a lower baseline and AI code - the idea of that terrifies me). It's a "powerful" language, but I think it has too much power. I like groovy for much the same reason that I liked perl and ruby (to an extent) - but it too is too powerful. It's great for writing scripts where it's a file or two or three... but if the "what does it do" gets too large to keep in my mind at once then it requires more discipline. I like to think that I have that discipline when working solo in groovy (and people will tell me I don't need to be that explicit in the objects... creating a class file rather than just shoving…

This is such a great thread, I'm excited to begin reading quite a few of the linked blogs (such as this one: https://acoup.blog/). These ones are some of my favorites: - www.wall.org/~aron/blog/ (physics, theology, history, philosophy) - http://xahlee.info/ (math, emacs, keyboards, etc.) - https://matt.might.net/articles/ (academy, compsci, etc.) - https://www.joelonsoftware.com/ (programming, companies, etc.) - https://danluu.com/ (technical topics) - Mailing list in https://practicaltypography.com/ - http://paulgraham.com/ - https://math.ucr.edu/home/baez/ (math, physics) - https://www.gwern.net/index (interesting articles) - https://slatestarcodex.com/ and https://astralcodexten.substack.com/ (science, psychiatry, philosophy, rationality, etc.) - http://steve-yegge.blogspot.com/ (programming) - https://creativegood.com/blog/ (UX, and more) - https://daringfireball.net/ (Apple) - https://backreaction.blogspot.com/ (physics) - https://thelastpsychiatrist.com/ - https://historyforatheists.com/ (historical myths) - http://funcall.blogspot.com/ (programming, compsci) - https://blog.fawny.org/ (accessibility, design) - https://blog.jessfraz.com/ (technology) - https://use-the-index-luke.com/blog (databases) - https://weekendfisher.blogspot.com/ (God, love) I can list some of my favorite articles from one of these blogs if anyone is interested.

> A common refrain is that Emacs is an operating system (OS). This isn’t true, but what invites comparison to an OS is its ability to orchestrate applications and utilities above the OS kernel level. Only because Lisp Machines, or variations thereof didn't took off in the mainstream. "Symbolics Lisp Machine demo" https://www.youtube.com/watch?v=o4-YnLpLgtk "Emacs and Lisp" https://funcall.blogspot.com/2025/04/emacs-and-lisp.html While Emacs was forked by Lucid as XEmacs to make one of the very first ideas of LSP, nowadays most features have been integrated back into Emacs https://dreamsongs.com/Cadillac.html "Lucid Energize Demo" https://www.youtube.com/watch?v=pQQTScuApWk

Joe Marshall had a couple of posts about... No: https://funcall.blogspot.com/2025/05/vibe-coding-common-lisp-through-b…

One man's ongoing journey coaxing an LLM to write Common Lisp code. Bonus "AI generated" poem by Stanislaw Lem, and a five-paragraph story actually generated by LLM: "The Unspeakable Syntax: A Tale of Lispian Horror." [3] Suprisingly entertaining. Posts so far: [1] https://funcall.blogspot.com/2025/03/vibe-coding-in-common-lisp.html [2] https://funcall.blogspot.com/2025/03/vibe-coding-in-common-lisp-contin… [3] https://funcall.blogspot.com/2025/03/ai-silliness.html [4] https://funcall.blogspot.com/2025/03/vibed-into-non-functioning.html

A couple of years ago I finally started to understand the Waters series facility [1], which was offered as an alternative to Loop. It's a bit finicky, and the error messages are often mystifying, but I have come to quite like it for some more complicated looping situations. The thing that finally made it accessible to me was a blog post by Joe Marshall, Series tips and tricks [2] Ironically enough, once my use of it advanced enough, I found myself writing producing forms which are just a restricted form of Loop invocation - Series turns out to compile down to Loop. It's just that I (and others, apparently) find Series expressions more pleasant to deal with than Loop expressions. [1] https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node347.html#SECTION003… [2] http://funcall.blogspot.com/2022/07/series-tips-and-tricks.html

Either that, or in the (rather limited) machine language the processor supports. But there is no push to solve this in a particular way. Here is an article about the Lisp Machine's garbage collection: http://funcall.blogspot.com/2009/05/before-i-got-distracted-by-tail.ht…

Non-mobile link: http://funcall.blogspot.com/2021/04/early-lisp-part-ii-apply-redux.htm…

This continues after this blog post - https://funcall.blogspot.com/2009/03/not-lisp-again.html - discussed yesterday - https://news.ycombinator.com/item?id=26297040

Wow, you're daft. Everything is, ultimately, getting turned into machine code. Not even Lisp Machines could get away from this fundamental fact: http://funcall.blogspot.com/2009/04/some-lisp-machine-minutia.html > Bogus objects — properly tagged words with invalid addresses that pointed at uninitialized memory or into the middle of object of a different type — which would cause the GC to corrupt memory would be left in registers or on the stack. These sort of problems were everywhere in the microcode. Go build your cabin in the woods now.

Blogspam. Copy of circa 2002 article, mirrored at: http://antigreen.org/vadim/ProgLanguageComparison/lisp-cmp-with-cpp-ja… (via "Daemerrung" here: http://funcall.blogspot.com/2010/05/c-vs-lisp.html)

My concern is that "practicality" is often just a code word for "resembles Java or whatever else I was comfortable with so I can continue on doing what I've always done before." (With the result that the student learns less than if they were required to do something truly different.) Reminds me of this post that came up on HN not too long ago: http://funcall.blogspot.com/2009/03/not-lisp-again.html

I'm pretty sure the title is tongue in cheek, and would be more accurately rendered as "I hated lisp when I first had to learn it", considering e.g. the name of the blog, and posts like these with considerable lispy content. http://funcall.blogspot.com/2009/01/day-4-part-1.html I hate explaining a joke as much as anyone but it seems that it's gone over some heads.

And indeed, in Scheme (the language that originally made tail recursion famous) you can get stack traces from loops too! Well, at least in one Scheme implementation, MIT Scheme. The MIT Scheme debugger has a notion of "reductions and subproblems" [1], which basically correspond to tail calls and non-tail calls. You can step "backwards" to the previous reduction, or "upwards" to the previous subproblem. In terms of other programming languages, that corresponds to going back to the previous loop iteration, or going up to the previous call frame. Behind the scenes, this is implemented using a "ring-buffer or ring-buffers" [2], which stores the values of local variables for, e.g., the last 10 iterations through a loop. So if you step back further than that you will lose history and jump back to the start of the function call. (The second link goes to the same blog as OP, I guess he has been writing a lot on this topic!) [1] https://www.gnu.org/software/mit-scheme/documentation/stable/mit-schem… [2] http://funcall.blogspot.com/2009/05/you-knew-id-say-something-part-iv.…

Do you need to be "good at math" in the typical sense? Certainly not. Learning away certain mathematical concepts, however, helps. To answer your question more precisely, I'll ask you a question: do you code in any high level language (Python, Ruby, Perl, PHP)? If so, chances are you're using 'associative arrays', 'dictionaries' or 'hashes'. How do they work under the cover? What is special and unique about them (A: hash tables and hashing functions). Now, can you use the concept that's used by the hash-table primitives in your language, to sort an array of size N in a time proportion to N? What are you giving up to gain that speed advantage, how can you offset that by giving up slight speed advantage? Now if someone is studying the same mathematical topics without having already programmed they won't have the same appreciation and attentiveness. To them "hash function" don't immediately click with programming techniques right away. Essentially my advice is start coding anyway, so the relevant topics in maths will "just click". This is also a very different kind of math: it's largely discrete and even the continuous portions of it are elegant. This isn't sitting for hours and doing symbol manipulation or number crunching. You don't need to know what continuous and discrete mean: just pick up a discrete mathematics textbook and see how far you can work through it. Attempt calculus, if only thing, just because the first elegant example SICP provides deals with a tiny…