I was able to finish reading all of “The Genius of Lisp“ by @cdegroot and the whole book was as good as the free preview (chapter 8). I was able to speed-read through the detailed explanations of concepts I already knew, like tail recursion, garbage collection, the Y-combinator, Currying functions, and so on. But there were parts where I slowed down and read carefully, like the section on the Universal Turing Machine, and some of the details of the IBM-704 system architecture. Also the story of how the first Lisp implementation was created when one of McCarthy’s grad students implemented an M-Expression calculator, this was described in slightly more detail than what I recall McCarthy himself explaining in his 1960 paper — that or I had just forgotten those parts of the story.

The tone of this book reminds me a lot of popular physics books like Stephen Hawking’s “A Brief History of Time,” which was aimed more at general audiences than professionals. That said, there is a lot to enjoy about this book for professionals like myself as well. There are many good stories about the principals designers of Lisp throughout. The sections on the commercialization of Lisp for the first AI boom of the 1970s and it’s subsequent “AI winter,” were very interesting to read. And if you are a teacher, you might like how some of the concepts in the book are explained.

And I would definitely recommend this very strongly to 3rd-year high school students, or 1st and 2nd year college students, who are more genuinely curious about how computers work and want to know more than just how to make the next billion dollar app.

The next #LispyGopherClimate show with @screwlisp I look forward to talking about this book some more.

#tech #software #Lisp #ProgrammingLanguages #SchemeLang #Scheme #Clojure #Emacs #EmacsLisp #RetroComputing #LispyGopherClimateShow

I've not really posted anything on my #blog for a while, and one of the reasons was that every time I tried to, I ended up having to work on catching up on a bunch of #hugo changes before the blog would build because inevitable on one of my four "main" machines, the blog wouldn't build due to some backward-incompatible changes.

Any recommendation for a static site generator that takes backward compatibility a bit more seriously? I've used #Jekyll in the past but I haven't looked into the state of that ecosystem for years.

My strong preference would be for a static site generator written in #clojure, #ClojureScript, #CommonLisp or #emacslisp. Preferably one that integrates well with #isso for comments.

Not interested in a more "dynamic" system like Ghost - I moved away from WordPress quite a while ago to reduce the amount of maintenance and attack surface, and I don't want to go back.

Question for Emacs wizards. I found a strange thing which I could not understand after reading the documentation (https://www.gnu.org/software/emacs/manual/html_node/emacs/Initial-Options.html) and even after reading the startup files, shipped with my Emacs 30.2.

If I use the -q option — Emacs will add site-lisp directories to the load-path. But with -Q option — there are no site-lisp catalogs in the load-path. Why is this happens? 

Note: the option --no-site-lisp is not used in the both examples. So, as I understood after reading the https://www.gnu.org/software/emacs/manual/html_node/eintr/Site_002dwide-Init.html, even with --no-site-file (or -Q) the site-lisp catalogs should be added to the load-path in the both cases 

#Emacs #EmacsLisp #elisp #AskFedi

This might be a question for the mailing list instead, but I’m trying to implement buffer-local variables in my #EmacsLisp interpreter, but in my test programs, there seem to be no functional difference between the “toplevel default” and the “default” value of a variable at all. When reading the documentation, it says this:

A variable can be let-bound to a value. This makes its global value shadowed by the binding; default-value will then return the value from that binding, not the global value, and set-default will be prevented from setting the global value (it will change the let-bound value instead). The following two functions allow referencing the global value even if it’s shadowed by a let-binding.

But the documentation seems to be wrong, but maybe I am missing something? Here is my test program:

When you look at the output of the program, (default-value 'x) returns the same value as (default-toplevel-value 'x) regardless of whether it is inside of a let binding, and regardless of lexical or dynamic binding mode. Here is the above program’s output:

#tech #software #Emacs

I decided to merge my #Scheme react-like declarative GUI framework (schemacs ui), even though the back-end isn’t completely bug-free yet. (It is still an experimental software project, so the main branch is the development branch).

Though it is written in pure #R7RS “small” Scheme, the only GUI back-end currently available is for Guile users who go to the trouble to install Guile-GI all on their own.

If Guile-GI is installed, put on your safety goggles and run this command in the Guile REPL:

I haven’t tried getting it to work in a Guix shell for almost a year now, but my last attempt did not go well (it crashed while initializing Gtk). To anyone who wants to try the GUI, I am sorry to inconvenience you, but I’m afraid I just have to ask you to please install Guile-GI yourself using the old-fashioned ./configure && make && make install method. If anyone happens to be able to get it to work in a Guix shell, please let me know, or open a PR on the Codeberg Git repository.

The only examples for how to use (schemacs ui) are in the test suite and the Schemacs Debugger. The only documentation so far are the comments in the source code, though I did try to be very thorough with comments.

The “Debugui” debugger works, but only has one single feature: the eval-expression command, which is bound to M-: (Alt-Colon). This command works the same as in #Emacs but you enter a Scheme language command instead. The #EmacsLisp interpreter is not yet connected to the GUI.

Now that this is merged, I am going to work on a few tasks in the Emacs Lisp interpreter that have been pending for more than a few weeks now. Then, back to creating new features in the GUI toward the goal of making it a useful program editor. And also, of course, writing some more documentation.

#tech #software #R7RS #SchemeLang

I have been banging my head against #Gtk3 for the past 3 weeks and all progress has pretty much come to a stand-still. No matter how simple and straight-forward my GUI is, Gtk makes it simply impossible to get the layout correct. I am now convinced that programming my own layout algorithm from scratch and using the GtkLayout container (which lets you place widgets at arbitrary X,Y coordinates) is the only way to proceed at this point. It is soooo frustrating.

The #Gtk documentation is good, but not at all good enough. The people on the Gnome Discourse have been very kind and helpful, and I truly appreciate the engagement I have had there, but ultimately I am still not able to solve my problems.

I have decided I need find some way to keep making progress without postponing the release of the work I have done so far for an indeterminate length of time. So rather than work out all the bugs in this version before merging it to the main Git branch, what I will do instead is have the main program launch a debugger window. The debugger window will have all layout calculated in advance, and all widgets will be declared once and only once throughout the lifetime of the application to avoid the reference counting issues. Obviously the debugger GUI will be very rigid, but you will at least be able to edit files and run commands in a REPL within this debugger.

Then maybe I can merge the code I have written to the main Git branch, and people will at least be able to use it through the debugger. Maybe also I could use this debugger to help with writing my layout algorithm. Also, I need to get back to the Emacs Lisp interpreter, I haven’t worked on it in almost two months now.

#tech #software #Lisp #Emacs #EmacsLisp #Scheme #SchemeLang #R7RS

NEW BLOG POST: Custom sorting of mu4e headers

I love mu4e for dealing with email under Emacs: with a little Emacs Lisp you can make it do email how you want to do email.

https://jamesendreshowell.com/2026-01-08-custom-sorting-of-mu4e-headers.html

#emacs #mu4e #emacslisp