Some 2025 thankyous and the big 2026 lisp plan

| link | Last. 20251230T021923522Z |

I am thinking about 2025 as a year of data points, whereas 2026 will be a year of data edges.

2025 began, iirc, with live interviews with Larry Masinter (Grump in lambda), and Corwin Brust, many more live guests including yduJ, everyone around https://lambda.moo.mud.org , Olum (Tuft’s Astrophysics modern common lisp Supercomputing), someodd, LambdaCalculus, Karl Voit, Kasper Galkowski, vidak, Karsten Johansson, Vassil Nikolov, Shizamura, jns, catK, Aral Balkan, Dave Lane, jeremy_list, Scott Zimmermann, lots of people, and the increasing involvement from https://tilde.town/~ramin_hal9001/ and https://nhplace.com/kent/ .

In particular this year we have had sequences of live audio and video presentations / discussions with Kent Pitman especially around the common lisp condition system, and Kent’s Cross Referenced Editing Facility as well as his release of his essay, Whither Original Thought? on the show.

Aside from speaking guests, we had the live MOOers including https://mdhughes.tech , Slak, Perry, jlamothe (proprieter of paradise sushi), spidercat, yib was around a few times (possibly incidentally), brontargkh, jasmaz of sdf’s vintage computalk, ratxue always, Doug Merritt, gothpony, g0th, catk, ggxx, schroeder (not to be confused with Alex Schroeder who is more itinerantly around) and too many more to name.

Mastodons as well, JMBR, Sacha, Amen Zwa Esq., HairyLarry, Damaru, Busta_Bells, Fugue State Audio, Chimera, “programming channel”, MBstream, curtosis, Pat, Prahou, 1A, jackdaniel, notptr, remilia, Paolo Amoroso, ams, lispm, weekend_editor, awkravchuk, and many too many more to mention.

gophers: if you know, you know.

My own programming features of the year were getting my fork of Erik Sandewall’s Leonardo System running robustly on clisp current, as seen in my running of his decision trees (IDA masters course labs c. 2010), and having slime + emacs-server replace Sandewall’s allegroserve based server for the software individuals at both the software-individual and multiple agents inside each software-individual levels. Towards the end of 2025 I also started working with Aral’s Kitten more deeply.

As I said, 2025 is a huge point cloud of primary lisp knowledge which is otherwise lost or missing except for our show. Though perhaps the real knowledge was the friendships we made along the way.

Trading itchio knowledgebase archives of common lisp conditions the full 2026 plan and also kittens

| link | Last. 20251230T022210163Z |

2026 is going to be for adding edges to our corpus of 2025. Here I am laying out a detailed prescription of hows and whys (according to me). My rule for myself is that I am not going to introduce any new points to the corpus myself in 2026, and solely create edges between the data. Then I would like to move up several points in Mashey’s small-is-beautiful Bell labs success scale:

Not even I use it
I use it
My close friends use it
My somewhat distant friends use it
We are inundated by strangers

The scheme I am prescribing here it going to be new for me as well, so I am graduating to “I use it” at the beginning of next year, and we will see from there!

Lateral transfer of knowledge is observed to be extremely difficult. Git and package management are not successfully solving this problem. This motivates my 2026 methodology.

Write common lisp condition fragments, i.e.
- new named ANSI CL conditions
- new common lisp functions with-restarts (in the condition sense)
- new common lisp handlers to attach to named conditions
These are stored in lispdef entities in a knowledgebase
- In the Leonardo System, entities are in entityfiles are in knowledgebases are in agents are in software-individuals
tar archives of one knowledgebase in one of your agents in one of your software-individuals at one point in time are published on itch.io
On the other end, you download itch.io knowledgebase archives into an agent in one of your software-individuals
Your software-individual generates a lisp code artifact directly being a concatenation of conditions, functions with-restarts, and condition handlers.
Your creation of 5. is your program as such which is itself a knowledgebase, an archive of which you would distribute on itch.io.
Tangentially the software-individual containing your agents has its own kitten as its body. Originally, this concept was Sandewall’s Madman knowledgebase, but this bitrotted (it was too tightly coupled to what the web was like 15-20 years ago). However Sandewall’s Biological Software concept of a software-individual with a society-of-mind of internal agents, having knowledgebases of and about its limbs/functionality, needs something like a biological notion of a body, though as Sandewall noted, obviously not a literal human one. He used dynamic document generation (madman). I am going to introduce a kitten-based one, madkitten.

This is the whole scheme. I am going to try this for a year, and hopefully you join me (moving me up Mashey’s scale to “joined by close friends” or even “joined by not-so-close friends” (before we are all inundated-by-strangers).

You do not make knowledgebase directories directly rather the leonardo system makes one persistent, dynamically updated directory for knowledgebases inside an individual’s agents, which are human-readable (much more human-readable than XML or s-expressions). We cannot publish agents on itch.io because agents are essentially chunks of brain matter, which are a part of a functioning brain. On the otherhand, knowledgebases - fragments of programs used by chunks of brain matter agents, are already by their nature nice archivable and shareable folders.

When individuals’ agents are communicating with eachother, e.g. in FIPA standard interagent communication, they are generally exchanging single properties of single entities at a time because this is the only sane thing to do in logical calculus terms. However, this works between two agents because they are functioning unattended, and quite quickly. For humans involved, the human will download and untar an entire new knowledgebase (i.e. Leonardo generated directory structure) into an agent to digest at a time.

Choosing itch.io

Viz itch.io - Their content policy identifies AI-based mass content as bannable spam but it is not entirely banned as long as it is accurately flagged which is a little weak, but at least a gesture in the anti-slop direction. Sez them, they support open and independent game development by freely hosting games and game fragments free and long-term.

Itch.io is an indie game marketplace which accepts payments for you on your behalf and handles payment processors with a default of pay-what-you-will, suggested $2. In 2026, I will experimentally try and lean into this two-dollars-or-free model. One thing is that it creates a visible difference between free, open software development and begging. Many people are in contexts where begging for help is completely appropriate, but I honestly do not think that software development or wikipedia for that matter should be indistinguishable from the plight of people in Gaza right now for example.

Itch.io’s profit model is that marketplace sellers pay-what-they-will from purchases of their game / software content to sponsor itch.io itself. This is not very evil as companies go.

Note that I am not suggesting that lisp programmers’ work is worth $2 / program. This is like getting one cup of coffee once in passing. The person who is just getting a cup of coffee someone else was already making does not pay to staff the cafe, or to build the cafe. On the other hand, if you want someone to build (and publicly release!) a particular condition / handler / function for your particular case, that would be hundreds of dollars per part of a day of work as normal: if you wanted them to maintain it, that would be a monthly retainer on top of the payment for any particular work. (Sorry that I am just outlining software business as usual). But for one cup of coffee in passing you only buy the cup of coffee in passing. However I will also note that you might prefer to buy a cup of coffee for two dollars rather than just opportunistically drinking unattended cups you find on uncleared lunch tables. At the same time, I think everyone can agree to unconditionally make and give coffee to people who say they cannot afford it.

Focus on the Common lisp condition system

The common lisp condition system is a piece of lisp thoughtleadership (this is the common term, not just my embellishment) that was adopted into lisp companies but not later copied into later languages as a paradigm yet. It has clear advantages (see Kent’s presentation of it for python devs), which I think are well understood to reflect Bell Labs’ John Mashey’s Small-Is-Beautiful talks, of which we are meant to get him as a guest early 2026.

Common lisp’s condition system clearly separates programming into three decoupled (dethrupled?) reuseable parts:

Definition of new conditions
Lisp functions (programs) with-restarts…(signal condition) (i.e. to restart locally from after conditions are signalled).
Writing handlers i.e. that connect a signalled condition to a local restart via a small lisp program.

Kent calls these handlers half-programs. They have the novelty of being written and attached externally/separately in time to the program that will use them, but in the program’s execution are run locally, allowing handlers to eventually choose to restart the program locally when appropriate. This is a very big deal. (If you are a non-programmer, this is an incredibly desireable unicorn. If a problem happens inside your house, you are not forced to leave your house before considering the problem. For example you could use a fire extinguisher on a small fire locally, rather than on principle only ever leaving the house and calling a firetruck to eventually arrive. Other languages just do the leave-the-house-to-burn / call-firetruck thing.).

Emacs eev

The Leonardo system uses emacs’ emacs-server for my software-individuals which are each common lisp slime repls. This is intended to be a low level detail from your perspective. I have to use some kind of server and process communication strategy: Emacs has the best available advanced infrastructure.

Interface-wise, I am using Eduardo’s eev mode for my Leonardo software-individuals (i.e. autonomously operating containers for agents). eev takes a sort of anti-data-hiding approach to ease of use. Its find- functions for example generate disposable documents filled with things you probably would like to do, customised to your particular needs, often needing a single button or a safe repeated button tap at the generated code you have visually identified as what-you-were-going-for.

Furthermore, eev’s eepitch machinery for pitching lines of code at potentially interactive-shell emacs buffers is extremely powerful. I co-opted it for my leonardo system to use on the principle that a machine intelligence is intelligent if its useages are common to powerful human useages.

Some conclusions

| link | Last. 20251230T022226803Z |

I have outlined for a year of interconnecting together after a prolific year of basically populating a new primary data corpus. My outlined goals are lofty, but it is for an entire year, and all the software previously exists (my working port of Sandewall’s Leonardo System, and its emacs-server / slime / eev integrations in the last year [] (in 2025)). Kent/ANSI CL’s condition system is in its 30s (40s if you count 80s antecedents).

If we compare my plan for 2026 to 2025, in 2025 in terms of Mashey’s Bell-labs-success-scale, my screwlisp.small-web.org went from did-not-exist (not even I knew about it) to consistently inundated-with-strangers (as well as friends), the lispy gopher climate’s listenership is comfortably in even-distant-friends-listen-live. So to plan for an itch.io knowledge -of-lisp-conditions exchange community to grow similarly

(Not existing yet, still in 2025)
Just me (start of 2026)
Lispy gopher climate people both downloading and publishing (early 2026)
Allied indie software and games community (remember when lispgames had hundreds of people?) (mid 2026)
We-get-inundated-by-strangers (end of 2026)

Wrongly equating these to a log scale, we will obviously hit 3-4, and 5 seems possible while also basically just doing what we were doing anyway.

Ideally the ball gets rolling or something else happens on the voluntaryist $2 itch.io front similar to faircamp etc bonkwave indie musicians so that being on the correct side of history does not just mean starving to death / having your warm corpse eaten by right-wing trillionaire investment funds (or for those with university tenure, watching this happen around you while management try and get you to abandon your office voluntarily).

Kitten = Sandewall’s Madman combines Aral’s Ted Nelson -ian dynamic, reciprocal independent kitten smallweb with the somewhat agreed upon notions that complex autonomous cognitive systems need bodies analogous to biological bodies, though obviously and actually specifically not literal human ones. (In fact, computer needs are too different for human language communication being used between computers to ever make sense as has published by Sandewall, for example - computer/human/computer communication being an edge case).

Sandewall’s leonardo system / knowledgebase archives for knowledge exchange is my difficult ask / super revolutionary. But like coordinatedly adopting the small-is-beautiful common lisp condition system style (a safe victory), weilding the gateway to all marvels of secret alien technology is the lisp community way. If you will forgive my tone, the main counterplay make-a-buck scammy big businesses seem to have made and be making is to pay university management to require that their teachers lie to children about recent computing history (i.e. about what the state of art is and was).

Oh, my itchio : (Watch in the new year) https://lispy-gopher-show.itch.io/leonardo-calculus which is for knowledgebase archive releases, writing will of course be here on https://screwlisp.small-web.org (and the show mastodon is https://gamerplus.org/@screwlisp ).

My thanks to PurpleJillybeans was implicit.

Also, lohang (and what’s up, been a while)

And Dock Sharpsign TaoTeJoan Sharpsign bonkwave

And Eric Ireland

And S.R. Weaver 2026 itch.io !

Wrog is on the Mastodon and is the developer/maintainer of lambdaMOO (https://en.wikipedia.org/wiki/LambdaMOO)

I also forgot Alex Shendi who was on the new Sunday-morning-in-Europe peertube live. I have not watched their 39c3 knights who say nil lisp assembly yet but have great expectations.

And the superdimensional fortress’s publius

And Gonzalo Nemmi (When are you coming on the show, Gonzalo?) (I guess after I install dragonfly bsd. I am getting a new computer for it next month I promise).

Admittedly they did not ask to be included here but Camellia Tea House are a friendly mutual on the mastodon who post a lot of otherworldly seasonal festival and traditional photos at their rural Tea House in Japan.

And the slightly spooky Bit Rot Bob.

And iiogama (everything is sine is a great name). Sharpsign protoculture

And Limebar

Clavicle

Audric

And Stug of FLUX “Whatever songs stug feels like playing together”

And Artyom Bologov whom I have been meant to have on the Sunday-morning-in-Europe peertube live but it will need to happen in 2026! Nyxt will be my main browser one day.

And thank-you to log for clarifying the differences between libre, gratis and res derelictae.

And slak for fixing lambdaMOO’s work/life balance

Also Northernlights for Praise then Darkness before the Tuesday-night-in-the-Americas Lispy Gopher Climate.

And former mayor of IT Cowboy Who?

and Geoff Wozniak

and kellenoffdagrid