Code

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 still don't, to the best of my knowledge).

Thue Content Swiss-Army Knife

This library began life in 2018 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.

App::IBIS

This is a prototype I wrote in Perl, in the back half of October 2013, 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 a year prior. 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.

Vocabularies

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.

• The IBIS (bis) Ontology implements Horst Rittel's Issue-Based Information System framework for structured argumentation and design rationale.
• The Process Model Ontology extends the IBIS vocabulary with terms that enable the planning of, and computation over, projects and resources.
• The Content Inventory Ontology describes metadata germane to content strategists for planning and managing content—Web or otherwise, an example data schema for a domain-specific tool.
• The Interaction Design Ontology, another domain-specific vocabulary, describes the goals of archetypal users and the mediated processes they undertake to achieve them. (This vocabulary is considerably less mature than the others.)
• The Transformation Functions Ontology maps and describes the inputs, outputs, and partial and full applications of transformation functions, used internally by the engine.

Other Specifications

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

• The spec for the compact UUIDs used in fragment identifiers
• the RDF-KV protocol specification for embedding graph manipulation commands into ordinary HTML forms