My actual kitten experience

| link | Last. 20251226T074940674Z |

Kitten overhaul. Before I was just using Kitten as a praeternaturally featureful markdown-based static site generator. As of today, I am playing with my kitten on its home turf. This article just describes my initial feelings from that. Materially instead of just writing words in nominal markdown as they occur to me, I am clearly creating pieces of data which my kitten digests to provide you the experience you are enjoying. This turns out to be a lot more formal. We are basically going to sample me writing this article. I will mainly bring it together in my conclusions.

But first a common lisp FIPA SL modified ISO8601 date timestamper

| link | Last. 20251226T080241645Z |

If you were following this revamp closely so far, you will have seen a bunch of placeholder times. In fact, I am using FIPA SL’s time extension to ISO8601 time. The current one just right now in particular being

20251226T082013585Z

for

2025 December 26 8:20am, 13 seconds, 585 milliseconds Zulu time = UTC = GMT.

FIPA SL specifies the time zone suffix of Z for UTC, which is to be prefered. If there is no time zone suffix, times are understood to be local times (do you know where the sender of the local time is… if not you know more now.). My ANSI common lisp to generate this string is

(let ((* (multiple-value-list
	  (decode-universal-time 
	   (get-universal-time) 0))))
  (format nil "~@{~?~}"
	  "~10,4,'0r" (list (sixth *))
	  "~10,2,'0r" (list (fifth *))
	  "~10,2,'0r" (list (fourth *))
	  "~a" (list #\T)
	  "~10,2,'0r" (list (third *))
	  "~10,2,'0r" (list (second *))
	  "~10,2,'0r" (list (first *))
	  "~10,3,'0r" 
	  (list (rem (get-internal-real-time)
		     internal-time-units-per-second))
	  "~a" (list #\Z)))

This result is directly buildable like this in ANSI common lisp, though getting the milliseconds and inserting a T in the middle stop it from being too clean. I guess one makes sacrifices for a standard. I chose to shadow the repl’s asterisk, since I initially wrote this in terms of lisp’s special repl variables. In my opinion, the FIPA SL extension to ISO8601 provides a nice clear target for everyone to slightly unhappily agree to use.

FIPA SL further specifies that if the time is signed, it is a relative time (in which case it would not have a time zone). So

-00100000T000000001

is ten-years-and-one-millisecond-into-the-past and

+00000000T001000000

is “in ten minutes”. Adhereing to this time standard avoids the calendar notification file format import incompatibility that no-one I have ever met is satisfied with.

Writing the previous two sections of this article

| link | Last. 20251226T083908323Z |

Well, we better look at this literally (I am not trying to update what is in Section3.fragment.md for *print-circle* reasons).

I am really using at least five windows to the limit all the time in order to write this. This amount of work is showing me that there is all sorts of structure and information here that I normally informally disregard (and later, do not have available to interface back into my previous work). I guess I have there

1. The index (i.e. kitten place)
2. Data.fragment.js (my json data-companion file)
3. The particular section I am writing’s markdown file
4. An embeddable common lisp repl

and

• librewolf web browser pointing at the kitten on localhost

There are more emacs buffers but those are the main ones for me right now.

index.page.js for this path=folder is where the kitten per se is happening. Despite the filetype page.js exporting a kitten.html, in my opinion the file is clearly an xml file for a kitten ontology. Imagine those import statements were <import ..> something.

The main space hog right now is how many lines those <H> heading complexes take up since I verbosely specify them. In some sense it is unnecessary, but I kind of want that explicit xml structure available somewhere at least and it is currently here. I think data hiding is mostly misused so I am afraid of adding a bunch of infrastructure to obfuscate the details of those heading structures being passed in their parameters. (Aside for Aral if you are reading this: it seems like I can use relative paths but not absolute paths as I write this?).

import SiteLayout from '../../Site.layout.js'

import H from '../../md/H.fragment.md'

import Section1 from './md/Section1.fragment.md'
import Section2 from './md/Section2.fragment.md'
import Section3 from './md/Section3.fragment.md'

import Data from './db/Data.fragment.js'

export default () => kitten.html`
<${SiteLayout}>
  <content for='HEAD'>
    <link rel='icon' href='/favicon.ico'>
  </content>

<article>

<${H}>
<content for='text'>${Data.section1.H.text}</content>
<content for='link'>${Data.section1.H.link}</content>
<content for='date'>${Data.section1.H.date}</content>
<content for='level'>${Data.section1.H.level}</content>
</>

<${Section1}></>

<${H}>
<content for='text'>${Data.section2.H.text}</content>
<content for='link'>${Data.section2.H.link}</content>
<content for='date'>${Data.section2.H.date}</content>
<content for='level'>${Data.section2.H.level}</content>
</>

<${Section2}></>

<${H}>
<content for='text'>${Data.section3.H.text}</content>
<content for='link'>${Data.section3.H.link}</content>
<content for='date'>${Data.section3.H.date}</content>
<content for='level'>${Data.section3.H.level}</content>
</>

<img src=./imgs/action-screenshot-kitten.png>

<img src=./imgs/librewolf-kitten-screenshot.png>

<${Section3}></>

</article>
</>
`

The json data fragment

| link | Last. 20251226T092840681Z |

As well as taking up all those lines of XML in the kitten index, that data json (javascript object notation, a megapopular web standard) is the most easily and obviously accessible data on what is in my page. Having this explicitly at hand is new to me here so I am not quite sure what its implications are.

export default
{
    section1: { H: { text: 'My actual kitten experience',
		     link: './#my-actual-kitten-experience',
		     date: '20251226T074940674Z',
		     level: 1 }},
    section2: { H: { text: 'But first a common lisp FIPA SL modified ISO8601 date timestamper',
		     link: './#but-first-a-common-lisp-FIPA-SL-modified-ISO8601-date-timestamper',
		     date: '20251226T080241645Z',
		     level: 2}},
    section3: { H: { text: 'Writing the previous two sections of this article',
		     link: './#Writing-the-previous-two-sections-of-this-article',
		     date: '20251226T083908323Z',
		     level: 2}},
        section4: { H: { text: 'The json data fragment',
		     link: './#the-json-data-fragment',
		     date: '20251226T092840681Z',
		     level: 2}}
}

I guess this JSON like the xml structures are very automatable / dynamically generatable once I get more used to them being there.

Conclusions

| link | Last. 20251226T093431124Z |

As I said, the newly discovered difficult formal work of putting this article together compared to my previous usual informal use of markdown strongly implies to me that this article is more accessible… in some way. That work must be ending up somewhere.

Hopefully this smallweb article has something in it of value to Aral, hints to drop to me about useage or otherwise. I feel a bit coy about having radically avoided javascript components / javascript / html in favour of xml-looking kitten markdown fragments and the json data fragment, which is not coding in javascript per se either. I think the fact that kitten is not like javascript and html but is a basically xml construction that already maps onto them is very powerful.

I was going to talk about Sandewall’s Madman here, which I guess will be the view from my common lisp Leonardo System Knowledge Representation Framework of these kitten constructions, but this is a fairly minor detail from the kitten’s perspective: Kitten being a robust xml thing, it is easy to map some similarly formal s-expressions previously aimed at html onto.

In terms of useage of data, I would hope that I can open my markdown fragments, maybe entire kitten into a modern successor to Kent Pitman’s Cross Referenced Editing Facility (you watch the show, right) where trajectories through dense and rambling free-ranging technical explanations were discovered for answering questions / generating code in that experts space from their dialogue. This being interesting in the modern situation because the trajectories through expert dialog are explainable in the way that deep learning’s numeric weights by definition can never be.

Alright, it is bed time for me. Good night! I hope you discovered kitten.