• If we consider a spiral arc circling towards 0 over time, and a circle about 0 having some diameter epsilon and name the circle victory, in my view (and my setting of epsilon) that perimeter has been crossed by the leonardo system complex I have been working on. Let us try a time example in which I will indicate what the victory I sense is as a movement towards its introduction. See the conclusions.

Considering the fipa modified ISO-8601 timestamp common lisp function again:

(defun fipa-8601-from-ut+0
    (&optional (stream t) (ut (get-universal-time)) &aux (tz +0))
  (let ((decoded (multiple-value-list
		  (decode-universal-time ut tz))))
    (format stream "~@{~?~}"
	    "~10,4,'0r" (list (sixth decoded))
	    "~10,2,'0r" (list (fifth decoded))
	    "~10,2,'0r" (list (fourth decoded))
	    "~a" (list #\T)
	    "~10,2,'0r" (list (third decoded))
	    "~10,2,'0r" (list (second decoded))
	    "~10,2,'0r" (list (first decoded))
	    "~10,3,'0r" 
	    (list (rem (truncate (get-internal-real-time) 1000)
		       (truncate internal-time-units-per-second 1000)))
	    "~a" (list #\Z))))

e.g.

CL-USER> (defun fipa-8601-from-ut+0
    (&optional (stream t) (ut (get-universal-time)) &aux (tz +0))
  (let ((decoded (multiple-value-list
		  (decode-universal-time ut tz))))
    (format stream "~@{~?~}"
	    "~10,4,'0r" (list (sixth decoded))
	    "~10,2,'0r" (list (fifth decoded))
	    "~10,2,'0r" (list (fourth decoded))
	    "~a" (list #\T)
	    "~10,2,'0r" (list (third decoded))
	    "~10,2,'0r" (list (second decoded))
	    "~10,2,'0r" (list (first decoded))
	    "~10,3,'0r" 
	    (list (rem (truncate (get-internal-real-time) 1000)
		       (truncate internal-time-units-per-second 1000)))
	    "~a" (list #\Z))))
WARNING: redefining COMMON-LISP-USER::FIPA-8601-FROM-UT+0 in DEFUN
FIPA-8601-FROM-UT+0
CL-USER> (fipa-8601-from-ut+0)
20260126T221926568Z
NIL
CL-USER> (fipa-8601-from-ut+0 nil)
"20260126T221934417Z"
CL-USER>

and just considering this one function for the moment.

Leonardo software individual having knowledge of that

Explicitly here, though it will be Edrx’s find-leo-links in emacs later

shell

git clone https://codeberg.org/screwlisp/pawn-75.git
mkdir -p ~/leocommunity
cp -r pawn-75/Pawn-75 ~/leocommunity/Clover

pick your own name instead of Clover. I have been using flower names as a mnemonic.

and in emacs lisp (with slime and clisp and asdf installed)

• (setq inferior-lisp-program "clisp -E ISO-8859-1 -modern")
• (slime)
• (setq eepitch-buffer-name "*slime-repl clisp*")

and eepitching to start the individual

(require "asdf")
(uiop:chdir "~/leocommunity/Clover/demus/Process/main/")
(load "../../../remus/Startup/cl/acleo.leos")
(cle)

AND we are in / Clover is running

crek screwlisp-time-kb
loadk screwlisp-time-kb
setk screwlisp-time-kb
crefil fipa-time
loadk fipa-time
put fipa-from-ut type lispdef
addmember (get fipa-time contents) fipa-from-ut
writefil fipa-time

Hence ~/leocommunity/Clover/demus/Screwlisp-time/fipa-time.leo - one option is to just put it in lisp-mode and write/paste the lispdef in.

---------------------------------------------------------
-- fipa-time

[: type entityfile]
[: latest-written "2026-01-26/23:56.+12"]
[: contents <fipa-time fipa-from-ut>]
[: changed-since-archived t]
[: nullvalued {has-purpose has-author requires mustload removed-entities leos-extension has-profile overlay-on overlay-types overlay-own leos-use dont-display sections local-ents purpose author latest-archived-entity latest-rearchived}]

---------------------------------------------------------
-- fipa-from-ut

[: type lispdef]
[: latest-rearchived nil]

(defun fipa-8601-from-ut+0
	(&optional (stream t) (ut (get-universal-time))
		   &aux (tz +0))
  (let ((decoded (multiple-value-list
		  (decode-universal-time ut tz))))
    (format stream "~@{~?~}"
	    "~10,4,'0r" (list (sixth decoded))
	    "~10,2,'0r" (list (fifth decoded))
	    "~10,2,'0r" (list (fourth decoded))
	    "~a" (list #\T)
	    "~10,2,'0r" (list (third decoded))
	    "~10,2,'0r" (list (second decoded))
	    "~10,2,'0r" (list (first decoded))
	    "~10,3,'0r" 
	    (list (rem (truncate (get-internal-real-time) 1000)
		       (truncate internal-time-units-per-second 1000)))
	    "~a" (list #\Z))))

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

and save. eepitching again

loadk fipa-time
. (progn (fipa-8601-from-ut+0) (terpri))
(get fipa-from-ut leo-definition)

ses.041) . (progn (fipa-8601-from-ut+0) (terpri))
20260126T231706541Z
nil

ses.042) (get fipa-from-ut leo-definition)
  => 
[§ (defun fipa-8601-from-ut+0
	(&optional (stream t) (ut (get-universal-time))
		   &aux (tz +0))
  (let ((decoded (multiple-value-list
		  (decode-universal-time ut tz))))
    (format stream "~@{~?~}"
	    "~10,4,'0r" (list (sixth decoded))
	    "~10,2,'0r" (list (fifth decoded))
	    "~10,2,'0r" (list (fourth decoded))
	    "~a" (list #\T)
	    "~10,2,'0r" (list (third decoded))
	    "~10,2,'0r" (list (second decoded))
	    "~10,2,'0r" (list (first decoded))
	    "~10,3,'0r" 
	    (list (rem (truncate (get-internal-real-time) 1000)
		       (truncate internal-time-units-per-second 1000)))
	    "~a" (list #\Z))))§]

adding an action for dumping a lispdef into a generated lisp file quickly

put dumpdef type lispdef
addmember (get fipa-time contents) dumpdef
writefil fipa-time

Definition in fipa-time.leo:

---------------------------------------------------------
-- dumpdef

[: type lispdef]
[: latest-rearchived nil]

(leodef nil appendef (file sym)
	(with-open-file (out
			 file
			 :direction :output
			 :if-does-not-exist :create
			 :if-exists :append)
	  (princ (get sym 'leo-definition) out)))

ooooooooooooooooooooooooooooooooooooooooooooooooooooooooo

and back to eepitching:

EDIT: you can find the file fipa-time.leo here (I left the defaults “no”=“free”).

loadk fipa-time
appendef ~/buz.lisp fipa-from-ut

hence ~/buz.lisp:

(defun fipa-8601-from-ut+0
	(&optional (stream t) (ut (get-universal-time))
		   &aux (tz +0))
  (let ((decoded (multiple-value-list
		  (decode-universal-time ut tz))))
    (format stream "~@{~?~}"
	    "~10,4,'0r" (list (sixth decoded))
	    "~10,2,'0r" (list (fifth decoded))
	    "~10,2,'0r" (list (fourth decoded))
	    "~a" (list #\T)
	    "~10,2,'0r" (list (third decoded))
	    "~10,2,'0r" (list (second decoded))
	    "~10,2,'0r" (list (first decoded))
	    "~10,3,'0r" 
	    (list (rem (truncate (get-internal-real-time) 1000)
		       (truncate internal-time-units-per-second 1000)))
	    "~a" (list #\Z))))

as expected.

Conclusions

Admittedly, this is a simple leonardo system demo similar to the current readme.

In particular, we have seen here building an entityfile using the leonardo system, and using the entityfile to generate parts of an external lisp file.

I am settling on single entityfiles for lisp tool distribution on itch.io since it is an academically well-published formally rigorous plain single source file and the downloaded individual entityfile may be loaded at least like this:

crefil alien-file

replace e.g. ~/leocommunity/Clover/demus/Screwlisp-time/alien-file.leo with the Downloaded alien-file.leo file and

loadk alien-file
writefil alien-file
loadk alien-file

Now since I have homed distribution inside of the lisp good-old-fashioned-ai leonardo system, package management as such is exposed to and replaced by mechanical reasoning tools leonardo both comes with and is designed as a platform for creating. For example the example constraint satisfaction solver included lets us rigorously choose and generate lisp boilerplate from distributed leo files (work in progress). This level of rigor and power provided by the leonardo system and with leo files homed on itch.io seems a better alternative in many cases to javascript’s npm notoriously virus-filled community package management style.

So we have seen a lisp fragment, included it as an entity in a leonardo system entityfile, distributed the entity, received the entity, generated a lisp source file ~/buz.lisp from the leo entity, and thought about constraint satisfaction or other new or old sophisticated choosing of distributed / original entities, of which there is a well-known voluntaryist freegan-ish payment processor handler in itch.io.

We are spanning a complete system that I allege we already have. So let us venture into the dangerously expansive horizon of what then to do with the lisp.

For one, run-time couple signals and local restarts via dynamically bound handlers as we looked at recently making use of ansi common lisp’s condition system which includes a developer-oriented interactive restart system i.e. choosing between reports.

Also developer and interactive development-side, we have included the common lisp interface manager 2.0 spec for turning lisp objects as such directly into dynamic rich presentations utilizing gestures and graphics.

As we have seen around itch.io, a vast majority of not-currently-a-lisp-wizards effectively only visit websites. I have chosen kitten for this, where you write slotted markdown files, and the files become xml elements you construct with. Kitten xml is bridged from lisp using xhtmlambda.

You can of course write a great variety of different programs with lisp and I am not restricting that, but these are the bits I have focused on assembling together, which are basically currently-seaworthy if a bit currently-unassembled.

From my perspective midgame has clearly transitioned into an early endgame. Assuming I do not lose something big in the endgame and need to make up in points somehow, my choice of life as to how to program is done for good now.

EDIT: you can find the file fipa-time.leo here (I left the defaults “no”=“free”). Could be more ergonomic.

About the victory and leonardo

Leonardo software individual having knowledge of that

Conclusions