Abstract nonsense continued

24 Feb 2016

Ian Bogost, in his book “Alien Phenomenology”, looks at Tobias Kuhn’s “Ontograph Framework” (among many other things).

(I think Ian Bogost was first interested in the word “Ontography”, and then googled it, and found Tobias Kuhn’s work interesting and relevant.)

Specifically, Kuhn ontographs are these diagrams, which consist of two parts, a part called the legend associating words with glyphs, ad a part called the mini world, containing instances of glyphs from the diagram. The legend is something like Plato’s world of forms, containing idealized (by which we mean, stripped of particularities) entities that correspond to classes of particulars in the mundane world.

Ontograph example

I am interested in ontographs as toy examples of the abstract nonsense I previously posted about.

The real documents that we’re trying to characterize as consisting of descriptions, definitions, and examples - math textbooks, computer programs, and so on, are often substantially complex, abstract, or important. The ontograph above is not complex, nor abstract, nor important. That makes it excellent as a toy example.

Let’s try to create a silly (a.k.a. toy, trivial) example of a document pinning down the network of ideas in the ontograph above. There might be be three paragraphs (description, definition, and examples) for each glyph/word pair within the legend, and possibly an additional three paragraphs for each instance of a glyph in the mini world. Alternatively, we might choose to use fewer than three techniques to convey some of these ideas. Additionally (and orthogonally) we might, instead of considering glyph instances to be ideas, we might consider the entirety of the mini world a single idea to be conveyed.

Let’s choose (for the sake of time) to merely gesture at a particular combination of those choices:

If we make an identification of “a description of” with “a paragraph comment”, and identify “Form” with “class”, this starts to look very much like a medium-sized piece of code.

    // A person is [...] <--- description
    class Person {
        [...] <--- definition
    };
    // A Man is [...] <--- description
    class Man : public Person {
        [...] <--- definition
    };
    // A Woman is [...] <--- description
    class Woman : public Person {
        [...] <--- definition
    };
    // A Picture is [...] <--- description
    class Picture {
        [...] <--- definition
    };
    // A Present is [...] <--- description
    class Present {
        [...] <--- definition
    };
    // Sees is [...] <--- description
    class Sees {
        [...] <--- definition
    };
    // A Buys is [...] <--- description
    class Buys {
        [...] <--- definition
    };
    // This application [...] <--- description
    int main(int argc, char* argv) { <--- definition
        Man tom;
        Man john
        Woman mary;
        Woman lara;
        Picture top_right_picture;
        Picture bottom_left_picture;
        Present top_left_present;
        Present bottom_right_present;
        Sees s1(&mary, &mary);
        Sees s2(&tom, &mary);
        Sees s3(&mary, &lara);
        Sees s4(&tom, &lara);
        Sees s5(&lara, &tom);
        Sees s6(&john, &tom);
        Sees s7(&john, &lara);
        Buys b1(&mary, &top_right_picture);
        Buys b2(&tom, &top_left_present);
        Buys b3(&john, &bottom_left_picture);
        Buys b4(&john, &bottom_right_present);
        [...]
    }

Like many pieces of software, this one does not have any unit tests or examples.