I've been kicking around the notion of a "code exegesis" for a little while, which is the attempt to take some software project (in the simplest case a single file) and to "back-comment" it, that is, explain the author's intent and strategies in the development of the code, as well as possible, and also to focus on different aspects of it in a series of separate articles (or chapters if the whole work is considered a book).
This is an exegesis as classically understood - detailed commentary on the ideas and history behind a given work,
often scripture but also e.g. Homer. I call this "interpretive exegesis" to distinguish it from literate programming,
which is essentially the same thing except that it independently *generates* the code, so I call it "generative exegesis".
With me so far?
All the publishing I want to do at this point is code-based. So far I had considered doing a Markdown-enabled Perl weaver
that is essentially Jekyll in Perl, so I called it Heckle. It was entirely vapor, fortunately - because I'm renaming
it "Exegete" instead. I'm going to use exegesis as the basis for all my publishing, because I'm going to be quoting
from things all the time anyway. The same document organization tools could be used for anything, not just exegesis,
but honestly, it's still a great name.
There are a couple more ideas here.
First is the realization that the same explanatory exegetical structure would be doubly appropriate for binaries,
for disassembly and reverse-engineering. Here, instead of a dynamic picture like a conventional disassembly tool (which can be seen as a kind of explorer/browser), we'd explicitly be supporting the
writing of articles about a given binary structure, but overall the same principles as IDA or Radare would apply: the
identification of small extents that express a given set of actions and ideas.
And then there's the notion of a "derivative work" - a kind of hybrid of interpretation and generation which transforms
the original into a new work with changes. This is not going to be a very normal mode for most purposes, because it's
not the same as normal maintenance, which is typically done in a more evolutionary fashion. This is definitely intended
for those punctuational cases like porting, or reimplementation of archeological finds from the 70's or something.
A good term for this would be a "transformational exegesis".
And of course it would be perfect for patching binaries or similar reverse-engineering tasks.
So that's kind of where my thinking is at. Since all this involves the writing of text, probably extensive text, that includes references to and quotations of code objects, it's pretty much ideal for the kind of tech writing I want to do anyway.