Thread by @meekaale

whoa I just got this weird but fascinating idea to use Lisp itself as an issue tracker and work journal

the first part there is a set of dummy no-op macros that enable me to write the chronicle in this format

the chronicle now is "code" that doesn't actually do anything... yet

this is the essential Lisp principle: "code is data, data is code"

any Lisp syntax is a valid component of a chronicle entry

this means I can easily embed snippets of test code that I'm working on, and evaluate them interactively with a keystroke

which also means I can imagine using it as a "testing framework"

like I might have a chronicle entry type called "test" which is then evaluated for verification every time I compile the system

like writing system test cases in your Roam's Daily Notes, rather than as a systematically organized test suite

I'm also going to use it as a todo list

so today I can insert a todo, perhaps with references to certain functions, perhaps even with an embedded test case

and tomorrow I can mark that todo's identifier as done

it becomes really interesting when you realize that not only can the chronicle reference symbols in the system and its dependencies

but the system can also reference symbols from the chronicle

think block references in Roam

so instead of just free-form text comments inside a function, you can have a syntactic annotation that references a certain todo or other note in the chronicle

this is something @doriantaylor talks about, how code can only express intentions as comments: not anymore!

earlier this year I was thinking of similar things and started making something by way of integrating a software system with an actual Roam graph

I was playing with having Roam block identifiers within structured annotations in my Elixir system

so I would have a Roam graph as a repository for specifications, conceptual definitions, explanations, questions, etc

so I could have a concept page in Roam hyperlinked right into the system's source code, annotating a module with a block identifier

https://twitter.com/meekaale/status/1397803164720640004

but this simple Lisp thing feels like a much easier and nicer way of accomplishing the same vision

and I can stay inside Emacs all the time

with Lisp in Emacs I already have "find all references to this symbol" and stuff like that

ahh this is better, avoiding strings in favor of nested lists of symbols, as John McCarthy intended

I like writing like this without punctuation other than parentheses

and now I really get the Roam thing: each symbol is an actual object in the system

see how this is like a fake programming language with undefined semantics

but with a vast affordance for improvising little linguistic structures

that can later be interpreted in various different ways

Common Lisp's system of symbols and packages is actually surprisingly perfect for this

the symbols you see here are objects but they exist inside a specific package so they don't conflict with existing usages in the system or even with language keywords

for example symbols like IF, RETURN, and LET exist inside the COMMON-LISP package which is typically but not necessarily imported into one's own packages

if you don't import it, you have to say COMMON-LISP:IF instead of just IF, or alias it to LISP:IF

this is perfect for me

it's like namespaces in Roam but built into a sophisticated, powerful, and infinitely expressive programming language

Roam itself is also written in a Lisp-like language, Clojure, but it's not really integrated with the programming system

a little bit of common structure is emerging

it’s like Aristotle looking for the structural patterns in rational discourse and discovering the abstract syllogism

this also resonates with the meta-pattern of Christopher Alexander's "A Pattern Language" where the patterns have this syllogistic structure of: context, problem, sketch, research, conclusion, links

of course now I want to view this chronicle on the e-ink screen itself

that will be a beautiful first self-reflexive use case for the whole thing

approaching dangerously Heideggerian levels of hermeneutic self-creation

oh hmm one very interesting thing about Lisp is that it's perfectly sensible to override previous definitions further down in a file

which makes you imagine simply writing the program inside the chronicle, redefining functions rather than changing them

if you then also have test cases embedded in the chronicle, imagine executing the whole chronicle

you'll be replaying the system's development as it modifies itself

the chronicle is like a series of database transactions and migrations

you can optimize this with pruning but essentially the way to start the system then will be to replay its history like in event sourcing

Common Lisp can save the current system state as an image, so that's already the perfect snapshotting system right there

I think this chronicle should not be rigidly append-only like a Git repository

it's rude to "rewrite history" in a Git repository because it fucks with the synchronization mechanism

but a chronicle is a narrative that gets reworked over time to tell a coherent story

as chroniclers of an evolving system, we may want to revise history to remove confusing or embarrassing detours

but then again we may want to leave them in as cautionary tales

anyway Git keeps us honest

a tribe of hackers from the Babylon of Unix, on exodus towards a land of ink and money, carefully constructing their software tabernacle with all manners of workmanship