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
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
• • •
Missing some Tweet in this thread? You can try to
force a refresh
hmm, it’s not that a self is everything in a holistic sense, but a self is an “index” for everything
the Proustian smell of a childhood cookie is an example: the smell activates a certain self (or “selfoid”) which then launches a mood and outlook that encompasses the whole lifeworld
selves are like perspectives, like cameras with idiosyncratic filters and focusing tendencies, like origins that the world is organized around