A suggestion for a format or a standard for interchange (tools for thought)

Tools for thought interchange format?

Two fictional apps are used to explain these concepts. They are both graph editors, but with different use cases intended.

  • Outliner (yellow windows)

    • supports
    • plain text view and edit
    • arranging things in a hierarchical outline mode
    • view images
    • plain text annotation
  • Spatial mapper (green windows)

    • supports
    • arranging things on a coordinate system (X, Y, Z)
    • editing plain text
    • view images

It would be great if we could come up with a plain text, editable by anything format that could be universal for tools for thought. I don’t however think that’s possible, especially as soon as the requirements go anywhere beyond simple, monolingual texts.

Might there be quite a simple solution to the problem?

We want the format to be able to be read by many different tools and environments. But these different environments will hopefully be as different as the people who make the tools, maybe as the people using them.

We’re used to storing files hierarchically on a disk in a normal file system. When we need them somewhere else we copy or link then into our documents.

For the format to work on a universal level it needs to be sufficiently abstract to cover any current or future use cases.

What is the core unit?

Tools like roam and logseq have decided on using a ‘block’ as the smallest unit. This is conceptually fine, and a ‘page’ or ‘document’ in their software is a nested list of blocks. Perfect for working in outline mode.

Depending on the type of knowledge work that I do, or want to do, I have different needs for how I want to structure the content.

I might want to have the same ‘blocks’ but arrange them spacially as cards, and not in an outlined list.

This will allow me to move them around in a different way and see new connections.

Although text is a central element in many creative processes, I often use photos, vector graphics, video clips or hand drawn sketches (sometimes also other things like a contact or a PDF etc) to help elaborate ideas or make sense of things for myself.

What is the smallest, universal unit that can cover these and future content types? Schema.org’s base unit (or schema) is a Thing. All other schemas are based off of this thing. For now, let’s stick with Thing as our smallest unit. A ‘block’ could be a special kind of thing with its own properties.

The tool I use would be able to figure out whether that particular Thing can be read and edited based on the schemas the tool supports. See quick look in MacOS.

A single Thing on its own is not that valuable to us, so we need a way to connect multiple Things together.

  • graph
  • presentation
  • content (nodes/things)

I’m not set on the names presentation or content for now, but they should suffice in explaining the concepts of the format.

A Thing could be floating around on its own, but become more valuable as soon as it links to a graph. Graphs can exist on many levels, but in our case the graph is another way of thinking about documents.

A Thing belongs to a graph.

Illustration of a graph with several things connected to it.

Is the graph itself also a type of Thing?

Now we have all our things connected to our current graph, we can access all the things from any one Thing. Thus is great, but it is fairly unstructured, and making sense of the order or position of the things in relation to one another would be at the programmers will. This doesn’t really for for our sensemaking needs.

In comes the presentation. A presentation could be a special kind of thing. At first, I can open my graph in my favourite outline editor. And I’m presented with a graphical overview of the graph which looks something similar to our example above, but inside the Outliner app.

Wireframe of the Outliner app showing our graph, arranged by the computer. Nodes could be named A, B, C etc

If we wanted to arrange our things, we create a new Outline, now I’ve got a nice editable outline.

Wireframe showing outline on the left, and graph view on the right, now with an additional presentation node connecting to all the things

Our graph now has a special new presentation node. Our newly created outline.

If we wanted, we could create several outlines inside our graph, giving us more ways to present or view the same content.

Now, it’s time to look at my graph in a different way, I open it in the Spatial mapper app.

Here, I’m also presented with a graph, and the app might tell me that there is a presentation here (our outline), but it doesn’t support editing that schema. I can still link my outline to other things and move it around because at its core, the Outline is just another Thing. Inherently linkable.

I’m feeling astronautical and I want to start laying things out in a space. I create a new ‘2d space’ type of presentation in my app and I drop all my nodes onto this spatial canvas and start moving them around.

I’ve now created a whole other view for the same underlying data without doing any harm to the outline from the other app. As a matter of fact, I can move the outline around on my board much in the same way I can with my text or image nodes. Win!

If I edit any of my text nodes, they automatically update in my outline as well.

This is a rich format.

For simple ‘document’ graphs like our example here, it might be sufficient keeping the files in groups of files (turtle?) on disk.

But as soon as we start linking between graphs, and into things inside other graphs we might want to use a graph database to store and query our data, at least the links between them.

Are there any light weight open source, embeddable graph databases that could work with a format like this?

And what is the format? Is it a zip file? Is it a folder? Where does it live? On local filesystem? On ipfs?