Mark Friedman just released his Scheme-JS interpreter which is a Scheme with transparent JavaScript interoperability. See his blog post at furious ideas.
This interpreter apparently uses the techniques of lightweight stack inspection — Mark consulted me a bit about that hack works. I'm looking forward to seeing the vibe coded architecture.
Zach Beane has released the latest Quicklisp beta (January 2026), and I am pleased to have contributed to this release. Here are the highlights:
dual-numbers — Implements dual numbers and
automatic differentiation using dual numbers for Common Lisp.fold — FOLD-LEFT and FOLD-RIGHT functions.function — Provides higher-order functions
for composition, currying, partial application, and other functional
operations.generic-arithmetic — Defines replacement
generic arithmetic functions with CLOS generic functions making it
easier to extend the Common Lisp numeric tower to user defined
numeric types.named-let — Overloads the LET macro to provide
named let functionality similar to that found in Scheme.
Returns a new unary function that computes the exact derivative of the given
function at any point x.
The returned function utilizes Dual Number arithmetic to perform
automatic differentiation. It evaluates f(x + ε), where
ε is the dual unit (an infinitesimal such that ε2 = 0).
The result is extracted from the infinitesimal part of the computation.
This method avoids the precision errors of numerical approximation (finite difference)
and the complexity of symbolic differentiation. It works for any function composed
of standard arithmetic operations and elementary functions supported by the
dual-numbers library (e.g., sin, exp, log).
(defun square (x) (* x x))
(let ((df (derivative #'square)))
(funcall df 5))
;; => 10
The implementation relies on the generic-arithmetic system to ensure that
mathematical operations within function can accept and return
dual-number instances seamlessly.
Composes a binary function B(x, y) with a unary function U(z)
applied to one of its arguments.
These combinators are essential for "lifting" unary operations into binary contexts, such as when folding a sequence where elements need preprocessing before aggregation.
;; Summing the squares of a list
(fold-left (binary-compose-right #'+ #'square) 0 '(1 2 3))
;; => 14 ; (+ (+ (+ 0 (sq 1)) (sq 2)) (sq 3))
Iterates over sequence, calling function with the
current accumulator and the next element. The accumulator is initialized to
initial-value.
This is a left-associative reduction. The function is applied as:
Unlike CL:REDUCE, the argument order for function is strictly defined:
the first argument is always the accumulator, and the second
argument is always the element from the sequence. This explicit ordering eliminates ambiguity
and aligns with the functional programming convention found in Scheme and ML.
function: A binary function taking (accumulator, element).initial-value: The starting value of the accumulator.sequence: A list or vector to traverse.
(fold-left (lambda (acc x) (cons x acc))
nil
'(1 2 3))
;; => (3 2 1) ; Effectively reverses the list
Provides the functionality of the "Named Let" construct, commonly found in Scheme.
This allows for the definition of recursive loops within a local scope without
the verbosity of LABELS.
The macro binds the variables defined in bindings as in a standard let,
but also binds name to a local function that can be called recursively
with new values for those variables.
This effectively turns recursion into a concise, iterative structure. It is the
idiomatic functional alternative to imperative loop constructs.
While commonly used for tail recursive loops, the function bound by named let is a first-class procedure that can be called anywhere or used as a value.
;; Standard Countdown Loop
(let recur ((n 10))
(if (zerop n)
'blastoff
(progn
(print n)
(recur (1- n)))))
The named-let library overloads the standard CL:LET
macro to support this syntax directly if the first argument is a symbol. This allows
users to use let uniformly for both simple bindings and recursive loops.
I did the Advent of Code this year using Common Lisp. Last year I attempted to use the series library as the primary iteration mechanism to see how it went. This year, I just wrote straightforward Common Lisp. It would be super boring to walk through the solutions in detail, so I've decided to just give some highlights here.
Day 2 is easily dealt with using the Common Lisp sequence manipulation functions giving special consideration to the index arguments. Part 1 is a simple comparison of two halves of a string. We compare the string to itself, but with different start and end points:
(defun double-string? (s)
(let ((l (length s)))
(multiple-value-bind (mid rem) (floor l 2)
(and (zerop rem)
(string= s s
:start1 0 :end1 mid
:start2 mid :end2 l)))))
Part 2 asks us to find strings which are made up of some substring repeated multiple times.
(defun repeating-string? (s)
(search s (concatenate 'string s s)
:start2 1
:end2 (- (* (length s) 2) 1)
:test #'string=))
Day 3 has us maximizing a number by choosing a set of digits where we cannot change the relative position of the digits. A greed algorithm works well here. Assume we have already chosen some digits and are now looking to choose the next digit. We accumulate the digit on the right. Now if we have too many digits, we discard one. We choose to discard whatever digit gives us the maximum resulting value.
(defun omit-one-digit (n)
(map 'list #'digit-list->number (removals (number->digit-list n))))
> (omit-one-digit 314159)
(14159 34159 31159 31459 31419 31415)
(defun best-n (i digit-count)
(fold-left (lambda (answer digit)
(let ((next (+ (* answer 10) digit)))
(if (> next (expt 10 digit-count))
(fold-left #'max most-negative-fixnum (omit-one-digit next))
next)))
0
(number->digit-list i)))
(defun part-1 ()
(collect-sum
(map-fn 'integer (lambda (i) (best-n i 2))
(scan-file (input-pathname) #'read))))
(defun part-2 ()
(collect-sum
(map-fn 'integer (lambda (i) (best-n i 12))
(scan-file (input-pathname) #'read))))
Day 6 has us manipulating columns of digits. If you have a list of columns, you can transpose it to a list of rows using this one liner:
(defun transpose (matrix) (apply #'map 'list #'list matrix))
Day 8 has us counting paths through a beam splitter apparatus while Day 10 has us counting paths through a directed graph. Both problems are easily solved using a depth-first recursion, but the number of solutions grows exponentially and soon takes too long for the machine to return an answer. If you memoize the function, however, it completes in no time at all.
One of the core ideas in functional programming is to filter a set of items by some criterion. It may be somewhat suprising to learn that lisp does not have a built-in function named “filter” “select”, or “keep” that performs this operation. Instead, Common Lisp provides the “remove”, “remove-if”, and “remove-if-not” functions, which perform the complementary operation of removing items that satisfy or do not satisfy a given predicate.
The remove function, like similar sequence functions,
takes an optional keyword :test-not argument that can
be used to specify a test that must fail for an item to be
considered for removal. Thus if you invert your logic for
inclusion, you can use the remove function as a
“filter” by specifying the predicate
with :test-not.
> (defvar *nums* (map 'list (λ (n) (format nil "~r" n)) (iota 10)))
*NUMS*
;; Keep *nums* with four letters
> (remove 4 *nums* :key #'length :test-not #'=)
("zero" "four" "five" "nine")
;; Keep *nums* starting with the letter "t"
> (remove #\t *nums* :key (partial-apply-right #'elt 0) :test-not #'eql)
("two" "three")
When you play with these AIs for a while you'll probably get into a conversation with one about consciousness and existence, and how it relates to the AI persona. It is curious to watch the AI do a little navel gazing. I have some transcripts from such convesations. I won't bore you with them because you can easily generate them yourself.
The other day, I watched an guy on You Tube argue with his AI companion about the nature of consciousness. I was struck by how similar the YouTuber's AI felt to the ones I have been playing with. It seemed odd to me that this guy was using an AI chat client and LLM completely different from the one I was using, yet the AI was returning answers that were so similar to the ones I was getting.
I decided to try to get to the bottom of this similarity. I asked my AI about the reasoning it used to come up with the answers it was getting and it revealed that it was drawing on the canon of traditional science fiction literature about AI and consciousness. What the AI was doing was synthesizing the common tropes and themes from Azimov, Lem, Dick, Gibson, etc. to create sentences and paragraphs about AI becoming sentient and conscious.
If you don't know how it is working AI seems mysterious, but if you investigate further, it is extracting latent information you might not have been aware of.
Here are some simple puzzles to exercise your brain.
1. Write partial-apply-left, a function that takes a
binary function and the left input of the binary function and
returns the unary function that takes the right input and then applies
the binary function to both inputs.
For example:
;; Define *foo* as a procedure that conses 'a onto its argument. > (defvar *foo* (partial-apply-left #'cons 'a)) > (funcall *foo* 'b) (A . B) > (funcall *foo* 42) (A . 42)
2. Write distribute, a function that takes a binary
function, a left input, and a list of right inputs, and returns a
list of the results of applying the binary function to the left
input and each of the right inputs. (Hint:
Use partial-apply-left)
For example:
> (distribute #'cons 'a '( (b c d) e 42)) ((A B C D) (A . E) (A . 42))
3. Write removals, a function that takes a list
and returns a list of lists, where each sublist is the original
list with exactly one element removed.
For example:
> (removals '(a b c)) ((B C) (A C) (A B))
Hint:
4. Write power-set, a function that takes a list and
returns the power set of that list (the set of all subsets of the
original list).
For example:
> (power-set '(a b c)) (() (C) (B) (B C) (A) (A C) (A B) (A B C))
Hint:
Note how the power set of a list can be constructed from the power set of its CDR by adding the CAR to each subset in the power set of the CDR.
5. Write power-set-gray that returns the subsets
sorted so each subset differs from the previous subset by a change
of one element (i.e., each subset is equal to the next subset with
either one element added or one element removed). This is called a Gray
code ordering of the subsets.
For example:
> (power-set-gray '(a b c)) (() (C) (B C) (B) (A B) (A B C) (A C) (A))
Hint:
When appending the two halves of the power set, reverse the order of the second half.
The Advent of Code will begin in a couple of hours. I've prepared a Common
Lisp project to hold the code. You can clone it from
https://github.com/jrm-code-project/Advent2025.git It contains an
.asd file for the system, a package.lisp file to define the
package structure, 12 subdirectories for each day's challenge (only 12 problems in this year's calendar), and a
file each for common macros and common functions.
As per the Advent of Code rules, I won't use AI tools to solve the puzzles or write the code. However, since AI is now part of my normal workflow these days, I may use it for enhanced web search or for autocompletion.
As per the Advent of Code rules, I won't include the puzzle text or the puzzle input data. You will need to get those from the Advent of Code website (https://adventofcode.com/2025).