This section will catalogue the resources that I have created, that contribute substantively to the protocol artifact. Many of these are things I have already completed or at least started on. I plan to demarcate the works that are entirely new as of this project.


The software here is the engine itself and other software—useful in its own right—that I needed to write to realize it. The main implementation language is Ruby, chosen because it is a general-purpose, dynamically-typed, object-oriented, interpreted language (where the interpreter is not mediated by a VM like Java), that at the time I started working on this, had third-party functionality that competing languages (specifically Python and JavaScript) did not (and don't, to the best of my knowledge).

Thue Content Swiss-Army Knife

This library began life in as a breadboard for good ideas about Web content. This is going to be the reference implementation of our engine.

RDF-KV implementation
The kind of tool this engine is meant to support is dominated by ordinary CRUD operations, which are represented in terms of changes to a graph. I designed the RDF-KV protocol to make it maximally easy to express these operations using ordinary HTML forms. This way it's possible to create working prototypes that can write as well as read, with thew fewest possible moving parts (i.e., JavaScript).
UUID-NCName implementation
Durable addressing—a success criterion of this project—extends to document fragments as well as entire resources returned as an HTTP response. To help with this, I designed the UUID-NCName representation so that I could make UUIDs fit into the grammar space of XML IDs, with the side effect that they are lexically shorter.
A Lazy XML builder, with certain desirable characteristics
The initial markup generation is done using XHTML because it has certain properties HTML (which is otherwise isomorphic) lacks. The rule is don't write XML unless you can generate it, and don't generate it without a lazy builder. This lazy builder in particular does something that other lazy markup generators do not, which is use plain declarative data structures (which are typically editable programmatically) versus closures (which are typically not).
A content-addressable store, with certain etc.
I wrote a lightweight, locally-attached content-addressable store for the specific purpose of implementing an interface to RFC 6920, the URI scheme standard for cryptographic identifiers.

This is a prototype I wrote in Perl, in the back half of , initially to test the RDF-KV protocol. I needed a relatively self-contained, feature-complete vocabulary to make a graph-based Web application out of, so as an expedient I chose the IBIS vocabulary I had written . While not only useful in its own right, it was an excellent proof of concept that served as a laboratory for developing many valuable techniques. Nevertheless, the software itself is constitutionally limited in its capabilities, and will ultimately be replaced by what I am currently calling the Swiss Army Knife.


These are data vocabularies I have written that are of immediate use in the engine. I have written them in a way that is simultaneously human- and machine-readable (I prefer the term computable or at least machine-actionable, since all digital data is trivially machine-readable). I plan to cover the method in the implementation guide.

Other Specifications

These are specs I have written that are germane to the project, but that are neither code nor data vocabularies.