#itchio #programming style #devlog #conditionHandling #commonLisp #reliability #softwareEngineering
Finally pretty happy with my "programming ls" example. This is a good programming with conditions first blush, I think.
Programming with signals and restarts that a run-time handler-bind hooks into gives a program, such as my %%ls here, *forward compatibility* not just *backwards compatibility* - which I explore as a property of ansi common lisp itself.
Thoughts!
https://screwlisp.small-web.org/conditions/partial-gopher-client/
#commonLisp #conditionHandling implemented as a #gopher protocol using #emacs #slime as the client.
This is even better than it sounds.
The condition handling system (nonfatal generalization of exception handling using lisp's local restarts/continuations) is unexplored and seen as opaque.
Using this tiny but esoteric example the available non-lexical computed restarts of an interactive condition are simply /browsable/.
Coincidentally, I assume, Abhijit Rao posted on LinkedIn earlier today a very interesting blurb, reporting on his use of this condition handling structure in conjunction with LLMs.
(Works for me in an incognito window, but you may not be able to see past the first comment if you don't have a LinkedIn account.)
https://www.linkedin.com/posts/quasiabhi_commonlisp-lisp-agents-activity-7425847332560293888-fYf9
The blurb references this more detailed account of the work, which I haven't been through in detail yet:
https://quasilabs.in/blog/2026/02/07/conditions-restarts-and-the-agent-that-chooses/
#CommonLisp #Lisp #ConditionHandling #Errors #Restarts #Continuations #ErrorHandling #ConditionHandling #LLM #LLMs #AI #Modularity #QuasiLabs #Reflection #Introspection #MetaProgramming
In 1988 The Common Lisp Condition System was formally introduced by the X3J13 committee, responsible for the ANSI standard. It was a radical idea: The code that /detects/ an error should not decide how to /recover/ from it. Instead, the signaler establishes named recovery options—restarts—and lets a handler higher up the stack choose which one to invoke. The decision belongs to whoever has the broader context. This was ahead of its time. For 35+ years, the "broader context" was either a human in the debugger or a programmer who knew at compile time which restart to pick. Both worked fine. Then LLMs showed up. An agent monitoring a data pipeline encounters a validation error. Three restarts available. No hardcoded strategy. The agent needs to reason about system goals, weigh tradeoffs, adapt to context it wasn't explicitly programmed for. The architecture was already right. What was missing: semantic context for the handler. Restarts come with names and descriptions. Agents need to know what the system is /trying to achieve/. What failed and why. What each recovery option costs. Why these specific restarts exist in the first place. When you add structured intent metadata—goals, failure modes, design rationale—the agent can map recovery options to system objectives. Same restarts. Profoundly different decision-making surface. I built Telos to capture this. It makes the why behind code queryable at runtime. Combined with conditions and restarts, you get agent-legible error recovery. The condition/restart protocol already separates mechanism from policy. It supports multiple recovery options without the signaler knowing which will be chosen. It allows the handler to be arbitrarily far—in code, in time, in understanding—from the signaler. It's an architecture perfect for agentic systems. And, yes, Common Lisp has an ANSI standard. Blog post with full working CSV validator example: https://lnkd.in/dSbuDK6J #commonlisp #lisp #agents #llm #programming #code #quasilabs
screwlisp
Kent Pitman