I checked out the Zettelkasten method, which appears to be German for
something about a box of (index) cards.
The website for the method appears to be a marketing site, almost. It's not
simply and plainly spelled out for you what the method really is, and it lacks
clear, real-world steps and examples to get the most out of the method. I dug a
little and finally found the gist of it, being:
* Write a note on a card for a single topic
* Give it a permanent ID
* Link to this note from other notes, via this ID
* Maintain links via a master link list
* Use the link lists to form associations between knowledge
* (Multiple link lists may be used to map your knowledge in different ways)
The grand goal is to have a well of knowledge that you can, eventually, begin to
interact with and explore the limits of your own *documented* knowledge, which I
think is an interesting distinction to make. One of the reasons we write notes
is to externalize information in a form we can recall later, to offset the
cognitive load of short-term memory. Then we only need to remember to come back
to our note(s) to be reminded of what we already know.
So as a habit and idea, it's nice. But when you think about it, this is exactly
how a wiki works, minus the "write once, link forever" aspect of Zettelkasten.
It's also how you would more or less add tags to data in a well-normalized
database. You would implement it using a lookup table, like "genre_lookup"
| id | title | | id | genre |
| 3 | Beep Boop | genre_lookup | 8 | Action |
+----+------------+ | 9 | Adventure |
| +------+------+ +----+-----------+
| | t_id | g_id | |
| +------+------+ |
'---------------------> | 3 | 8 | <-------'
| 3 | 9 |
This lookup table means 'Beep Boop' is Action/Adventure. (We should add Sci-Fi
too, but I digress. ;) If this were a Zettelkasten, it would be called "Game
Genres" and link games to their respective genres. It would just be in a less
verbose form, like:
game3 -> genre8, genre9
The exact field names aren't important, it's just an illustration. One could
have a convention for fields so you can fit more on one note. Something like
"capital G for game, lowercase g for genre" would be enough:
G3 -> g8, g9
Then if you really cared you'd look up g8 and g9 to find Action and Adventure. A
more pragmatic person would create a note that has the list of genres on it, and
update it (with permaIDs) as they go along in similar fashion. That way you only
look up one "note" to find all genres. Then our link card could be:
G3 -> 8, 9
Then the 'genre_table' note would have a simple numeric list of genre names.
This little mental exercise helped me conclude that Zettelkasten as a way of
approaching one's knowledge is interesting and maybe useful, but the tech is
more or less already implementable in traditional forms, like wikis, static
HTML, vim-wiki and org-mode, etc. Even Gophermaps can be "zettel". I think their
site could benefit from pragmatic, real-world examples of using this stuff and
a focus on how to apply the method to various media. There are apps for it, but
they all seem to have various warts, so it would be more wise to use extant
technology to try the method.
Zettelkasten strikes me as a mindset or an idea rather than a method, because
it's not clear how long a zettel should be, if they should be edited or changed
over time, if links can be deleted or modified as you refine the knowledge base,
etc. An effective method has answers for these finer points, presented in a form
that's digestable in a single webpage instead of a series of blog posts waxing
philosophical about a method that amounts to tagging cards.
Neat idea, but it talks itself up way too much. Just my two cents.