If you're like me, you have more than one hard-drive full of random stuff: notes, PDF files, Epub files, ZIP and TAR files, GIT repositories of (mostly incomplete) projects, and so on and so forth. Also, if you're like me, these projects devolve into a bunch of different areas: my professional life, my artistic and creative life, my open-source footprint, my personal life like my kids and my wife, the infrastructure of my life like the current projects in home maintenance, and in my case an imperial buttload of recipes.
My Rust has gotten rusty, so to speak, so I've decided to try and write something to help me manage it. This post is mostly me rambling about what I'm going to write, gods help us all, and how I want to manage writing it.
Basically, I want a knowledge base. That's it. That's the simplest thing possible. In fact, pretty much what I want is some kind of Roam clone, but one with extra superpowers.
I'm going to use a term that doesn't exist in the real world: "egotonin." Egotonin is a mythical substance that gets used when you're exerting willpower; it is the thing that is depleted in the concept of ego depletion.
So lets talk about Knowledge Bases.
These two "ideas" are the basics of any knowledge base (KB). You dump notes into the KB, and magically, somehow, they arrange themselves into something meaningful and useful. The "magic" comes in the form of metadata, which literally means "data about data." In this case, we mean data on the note that links it to other notes. That metadata is then arranged in a way that, later, helps the user find specific notes.
Niklas Luhmann created the modern Zettlekasten Method, a note-taking system that involved the humble 3x5 card, which he tagged with a string ofsymbols that placed it in his knowledge base. He was an academic who wrote important papers on psychology and sociology, and when he wanted to write about a topic, he would take out a card with the central idea *and the cards surrounding it* and organize them into a whole, which would the almost immediately be his rough draft. He called this process "effortless productivity." He just collected ideas and notes and quotes and references, and when they hit critical mass, he produced an important work.
Noguchi Yukio is a professional economist who, like Luhmann, writes papers within his discipline. Yukio's note-taking method is slightly different; he has a shelf full of plastic folders, each with a topic name and a founding date. As he works, he puts notes into the folders, and when one is "big enough," he takes it out, arranges the notes, and writes a paper. What's noteable about his method is that whenever he adds a note, he moves that folder all the way to the left position. Folders that have migrated all the way to the right are about subjects that he no longer has in mind, and on a monthly bases he assess and archives them. Folders in the middle are "reference" for whatever he's working on at that moment, as long as he's adding nothing new to them.
Along with these two methods, there is the classic One True Hierarchy method beloved of tools like Evernote, in which everything can be opened and closed in a cascade of indented topics, subtopics, sub-subtopics, and so forth. And there's the "Card Catalog" method, in which notes are added and several different organizational schemes exist side-by-side. Those organizational schemes are the metadata.
There are many different areas in which I write: software, documentation, fiction (mostly science fiction & fantasy), and the basic commentary & punditry that seems to be so much a part of being on the Internet. I used to write an advice column and sometimes I wonder if there's anything there to go back to that's not already covered under Reddit's "Am I The Asshole?" thread.
Any system in isolation starts out empty. For any given note system, the idea is that you make notes and dump them into a box. In cases like Evernote or Supernote or so forth, the metadata comes from two places: you put the note into a metadata slot, or you annotate the note with metadata.
You "put" the data into a metadata slot by creating a new note in an already existing hierarchy. You have your catalog open, you create a new slot in it, and you start typing. This involves a bit of mousing, usually. It also means that you're targeting a specific hierarchy, and sometimes you have to go find it. That process by itself takes some time and burns some of that egotonin.
You "annotate" the data by adding to the note something that places the note into the collection. Roam uses [[This annotation]], and others might use hashtags like #this, and so forth. The idea, whatever it is, is that you're building a taxonomy that you can use to look stuff up.
There are, however, other details that may (or more emphatically, do) mean something. The date is one that emphatically does means something; we're often more interested in what we looked at recently than what's in the far past, as the Noguchi method emphasizes. If our note system is multi-device, which device we used is a bit of metadata that may mean something. If we're using a desktop, which project is currently live (Were you last editing a document? Working in a git repository?) may also be a meaningful bit of metadata. If we're using a device with GPS, where we stood when the note was made may also be an important bit of metadata. And if we're using a device with bluetooth, nearby important people may also be a useful bit of information.
- Note: The fundamental object of all of these systems. Notes can
have these subtypes:
- Text note: The most common kind
- Audio note: The second most common kind
- Link note: The note links to something outside the system.
- http/https link: The note links to a resource somewhere on the web
- local link: the note links to a resource accessible to the note taker
- Child notes: The note contains more notes in a tree-like (hierarchical) structure.
- Box: Different collections of notes go into different boxes. Noguchi's folders, Luhman's note boxes, Tiago Forte's Building a Second Brain: Areas, and even the ancient David Allen's Getting Things Done: Roles, all emphasize the need to segment out knowledge collection into specific arena of attention. I am leaning heavily toward the Zettlekasten method myself, so "Box" feels like the right term here.
- System: Noguchi has a shelf, Allen has a notebook, and Luhman has a table, in which the boxes, folders, or projects as a whole live.
- Tags: Zettlekasten, Roam, Evernote, and other systems emphasize the use of tags as a way to organize your data.
What's significant about Zettlekasten is that every note can, by itself, represent the start of a new category, and by creating new tagging "roots," can create whole new trees of inquiry. Roam and Obsidian handle this by saying "Every new tag is a new box," and when you visit that tag, you can see notes that are explicitly contained in that box, but you can also see every note that points to that box. In this way, those systems create webs of interlocking knowledge.
First, it's important to note that all of these systems take Markdown as their primary source for the note. Advanced versions of these integrate MathJax, which allows for the display of mathematics and other forms of scientific notation. As far as I know, all applications support Unicode.
Roam says that every tag, every tag, is a box, which Roam calls "pages," which is a fine metaphor. When you create a tag, you're creating a page that notes can go into. And when you look into that page, you can see every tag that references that page. This makes organizing notes incredibly powerful. You can automatically see how ideas organically relate to other ideas.
Roam does not provide more than one swimlane, unlike Ginko, which does. It would be intriguing to see if that sort of scheme can be applied to a future application.
Roam also has the idea that the day you made a note is one of the most important things about it. The default view on any given day is just that day's date. You are free to move, copy, reference or embed notes between pages. A "referenced" note can be seen on "referring" pages, but can only be edited on its "parent" page. An "embedded" note can be seen on all pages on which it is embedded, and can be edited from any page on which it can be seen.
Roam's structure is twofold: A tree of notes, and a page which anchors a collection of notes.
Ginko provides a hierarchical layout for a single project. You start with an outline, and over time fill in the sections under the outline until you have a complete document. It provides as many swimlanes of content, for main topics, subtopics, and content, as you want; in one demo, an academic student described how she had a root column, an outline column, a second level of outline, a third level of outline, a fourth level with citations associated with the outline at that stage, a column of her rough draft, and a column into which she would write her final draft.
Ginko's structure is singular: A tree of notes. Everything else is presentation. The only "special" quality Ginko brings to the table is that some notes contain tags that point to notes deeper (further to the right) in the system hierarchy.
Ginko starts with a single swimlane in the middle of the page, and as you add swimlanes it automargins them until it can no longer hold them in the middle, at which point it switches to a horizontal scrolling method for accessing deeper parts.
Ginko has a branches-and-repos notion of notes, which it uses for collaborative note management. This is called the "git-like" interface.
Remnote is a note-taking application similar to both Roam or Evernote. What Remnote brings to the table is an idiom: Remnote has a special setting so that it can be used as a spaced repetition system, or SRS, similar to Anki or Supermemo.
Remnote makes creating flash cards for its SRS with an incredibly simple convention: A pair of colons in the first column separates the "top" of the note from the bottom, creating the front and back of the card.
Quiver is for programmers. It has syntax highlighting, and when you organize your notes using a Ginko-like layout, you can generate your program automagically in a tangle/web/weave sort of way, which is... kinda cool, actually.
Linkfish is a note-taking tool that centers on links to remote content. It's major superpower is that it routinely reviews the links and marks some as unavailable if the content starts failing. This is different from Notion, which sucks up the content and stores it locally.
Journal 2.0 has a single level of notes-per-page, but it uses a Masonry or EGJS Grid-like engine to layout its content. It's pretty, but I believe it's utility is marginal, as a two-tiered organization system is not one geared toward deep thinking.
Clover has the concept of "pages" as Roam, RemNote, and other note-taking apps do, but it has a fascinating "twist." Most applications have a singular presentation, the tree, the metaphor taken from that familiar computer tool, the File Manager: Roam and Obsidian have pages and notes, Quiver has projects and snippets, Remnote has areas and cards, Ginko has projects and outlines.
Clover has a tree-like display for its pages, but it also has an alternative, spatial arrangement, where one can arrange their notes as cards on an infinite canvas, and can drag and drop those cards close to one another, bunch them together and drag them as a group, and arrange some cards "over" other cards, creating a visual, 2&1/2-D relationship among the ideas on the cards. It supports Zoom-in/Zoom-out so that different groupings can clearly be seen.
This is an incredibly powerful metaphor. Human minds are spatially oriented, and being able to drag and drop ideas around and put them "close" to one another, is a great way to spark new ideas.
Nototo has a memory palace metaphor; it's spatial by default, and you lay things out in a "sea" of "islands," where each island is an Area or Project (in the "Building a Second Brain") sense, but it seems like notes are just "dumped" on the islands, and it doesn't feel very intuitive to me.
Let's deal with one major insight: every single note-taking application is secretly a content management system cut down to size. That's it. CMS's are notoriously easy to write, and notoriously difficult to maintain. By cutting the CMS down to a single purpose, we constrain the size of the project.
More importantly, observing that a note-taking application is a miniature content management system, we can immediately learn two things: First, headless note-taking systems should be the norm. Secondly, Luhman's Zettlekasten and Ginko's organizational scheme are component content management systems in that each note is a small part of a greater work, as Luhman observed that when he takes his notes out and arranges them, if he has enough of them they form a rough draft all on their own.
The elements of our CMS are:
- Notes: Notes are at the heart of every note-taking system, of course. The more (seemingly) free-hand the note-taking can be, the better.
- Trees: Every note-taking and note-writing tool has a tree-like organizational scheme. They start with a root, and notes are added.
- Roots: As I indicated, every tree has a root. Some systems, such as Ginko, have only one root, whereas others, like Roam, have trees of notes.
- Graphs: Most people would call this the "web," but programmers call it a graph: a collection of nodes. Roam and Obsidian are the most prominent "graph-based" systems in which notes in one tree can be linked to other trees easily. Roam automatically creates "back-links" as well, which is considered its "killer feature."
- Content and Presentation: Many of these systems are locked to a single presentation. Roam is most notorious for this, as it currently has only a web-based presentation that doesn't work well on phones.
- Zero, One, or Many: This is a programmer's rule of thumb; it means "Don't write code to handle two or three things. If you can handle multiples, handle an infinite number." To that end, things like Journal 2.0, which is a two-tiered system, don't make much sense to me.
- Spatial organization is just another kind of metadata, associated with a page. It's a fantastic presentation methodology, but that's really all it is.
So, what can we take away from all this hemming and hawing about note taking applications?
I don't have many plans beyond the basics. Here's what I know has to be in the first draft:
- Notes: Notes shall be taken in Markdown. A standard Markdown parser shall be used, and its behavior with respect to different kinds of annotations will be carefully examined to make it easy to add syntax for custom features. Notes shall have the ability to nest: that is, notes will be able to contain sub-notes, creating the tree-like structure.
- Trees: Notes shall belong to trees, but only one note shall be the tree's "root"; all other notes shall belong to sub-trees. We will use a mature relational engine to enforce consistency.
- Graphs: When a note is stored, all references within it shall also be stored, separately, to make looking up neighbors and neighbors-of-neighbors easy and efficient.
- Separation of Content and Presentation: This is critical. This application shall live in a server that provides the content on-demand. This will allow multiple forms of presentantion to be the default way of interacting with the content: writing a Roam-based front-end, a Ginko-based front-end, or a Clover-based front-end should require absolutely no additional work on the back-end. To this end, a stable API must be provided.
- Attentional Organization: Notes and pages shall be annotated with details like: date of creation, date of last modification, and date of last viewing. This allows for a Noguchi-like "archiving" as some pages and notes slowly fade into the background, but should never be lost.
- Trees & Pages Only: The first generation of notes will be a Roam-like clone only.