I recently took part in a discussion about using a Zettelkasten as an aid for programming and was asked to elaborate on my comments there.

A note on maturity

The current incarnation of my Zettelkasten is only a few months old and far from incorporates my old Zettels fully, yet. I know that with the maturity of any notes system or its infrastructure it "reveals" its actual form or maybe rather develops in a certain way, sometimes against one's own intentions and/or expectations - in other words: the system has agency. With that said, I have been using a Zettelkasten approach for many years now and am fairly confident, that the following remarks are not just guesses on what works for me and my Zettelkasten - your milage still may vary, of course. However, I still found it to be necessary to put a disclaimer here.

What I need from a Zettelkasten when coding

I recently had reasons to examine my usage of my Zettelkasten as it pertains to developing. I realised that there are patterns observable on when I stop programming and looking up information.

• I need to know how to do something
• I need to know how a specific thing is implemented in the given framework, programming language, etc.
• I need to know the definition of a pattern, concept, etc.

The process

When looking for information, I am somewhat time constrained - my job is to write code, good code that follows best practices, sure, but still: it's not research or writing the most comprehensive private documentation on how to write code and its underlying principles. Therefore the character of my searches is as follows:

1. Search your own Zettelkasten for what you're looking for. If the information is found and there are no important loose ends: Great! Stope here. Code on.
2. Try to acquire information until my interest has been satisfied, I am able to continue with the task at hand or my time is up (I am interrupted, I am supposed to do something else, etc.)
3. While and/or after the research phase is over, I try to note down the new information. The idea here is to make my current temporary understanding available later, by putting what is in my short-term memory into my Zettelkasten

You will note that process is not that different from working with other materials: You read with interest, take note and move on.

Considerations

Groupings - Abstract, concrete, How To's

I found it helpful to differentiate between three different groupings of notes:

1. abstract concepts - ideas, definitions, patterns, etc.
2. concrete implementations - APIs, documentation of functions and keywords, classes, etc.
3. HowTo's, concrete solutions and approaches

These categories mirror my needs (see above) when wearing the hat of a programmer. They also make clear that there is a difference between the concept (e. g. the data structure array) and its implementation (arrays in PHP and Javascript are very different).

Highlight what you're talking about

So in order to keep things separated (depending on the categories, see above) I make sure to make this visible in my note. Right now I use Backticks around the implementation. Here's an example:

Exceptions of Type Error are thrown for the error types E_ERROR and E_RECOVERABLE_ERROR

Note length and composability

I try to keep my notes short and composable. As for other Notes as well, the principle of atomicity holds true. A note should do one thing. Of course, what constitutes "doing one thing" is only roughly specified. But regardless, the goal should be composability. I find that as a developer I benefit from an already highly structured standard of documentation in my field, which can be a heuristic for my Zettels on the topic.

For example, I have created these Zettels when trying to understand the difference between an Exception and an Error in PHP:

1. PHP - Error Handling (Links to: 6, ...)
2. PHP - Throwable (Links to: 1, 3, 4, 5)
3. PHP - Exceptions (Links to: 1, 2, 4, 5)
4. PHP - Errors (...)
5. PHP - Difference Error vs. Exception
6. ... and some others

This approach works for more applied things, too. For example for various Git tasks, I have a bunch of notes that basically just hold the line to enter into the shell and maybe a link to a related command and to a "parent" or outline note. The important part here is that I try to build trees of notes.

Since the actual coding is done outside of the Zettelkasten, notes from this part of the note system tend to be much more conventional in style, meaning they mostly hold information, but aren't necessarily emergent in the same way as conventional knowledge notes might be (the more removed from the implementation the notes are the more they behave similarly, though). It's simply not helpful to abstract too much from a concrete code snippet to enhance composability, though.

But when talking about software architecture the drafting of how a system could look like is very similar to other knowledge work.

Tagging and Linking

I do not really handle tagging and linking differently from other parts of my system. Nonetheless, these are things I try to do:

For linking notes together or linking a freshly created note to already existing ones, I'm looking for a local fit. This means: Whatever the overall structure of my note system might be, the incoming and outgoing links are the context in which the note has meaning. E. g. if I'm talking about an Exception in PHP I might define it as opposed to a PHP Error and as a specific case of Throwable.

For tagging, my main target is a semantic anchor, wich means: Whatever the note is content-wise, it relates semantically (it articulates) to this tag (because I say so). So for example the Throwable note is tagged as PHP (or rather 00-meta.01-setup.04-dev.03-languages.01-php but I digress…). The note articulates an aspect of the PHP language and relates to it on this level. Looked at from the other side the meaning of this note comes from it being related to the PHP language which is expressed through this tag. The tag anchors and associates my notes in a different, probably more broad, way. There could be more tags. But I find that being economic about the tags I use is more beneficial.

Both linking and tagging are two different techniques to enhance the meaningfulness and emergent properties of the note. I'll probably talk about this more some other time.

Example - PHP - Error Handling

Because an example says more than a thousand words, here are some screenshots of some of the notes I have referred to above, warts and all. These are young notes that will get better with time. But even in this state they already helped me to differentiate quickly between two different kinds of Throwables PHP gives me. I apologise in advance, for my notes are in German:

20200324102302 - PHP - Errors

20200324102529 - PHP - Exceptions

20200324104152 - PHP - Unterschied Error vs. Exception

SCM - Git - Wie man ein Branch erstellt und dann gleich hinwechselt

EDIT (08.10.2020) - Please note: A Note As Regards To My Evernote Macros And The New Evernote Client Version 10

Similar to my tag autocomplete macro, this macro shows a search prompt from which links to other notes can be easily inserted/created as inline links. The macro actually consists of 2 Macros:

1. A note collector macro that retrieves and parses the notes from Evernote
2. A note selector macro that provides the functionality described above

Prerequisits

• Keyboard Maestro

Setup

1. Download the macros (see below)
2. Import the Macros to Keyboard Maestro
3. Configure a hot key trigger for the selector macro and (for example) a hotkey trigger for the collector macro (although other triggers would work, too) - I use 'ctrl' + 'alt' + 'cmd' + '+' and 'ctrl' + 'alt' + 'cmd' + 'shift' + '+', respectively
4. Run the collector macro (be patient: the first time might take a while…)
5. You're all set! Now just type your hot key trigger for the selector macro, search for a note, press return and the macro will do the rest.
6. Run the collector macro periodically to ensure that the newest notes are included. Subsequent runs should be fast, since we only collect new notes since the last run

How it looks

Download

Just download the file and drop it onto the Keyboard Maestro App Icon in the dock, or double click the file.

Evernote Note Autocomplete Macros (application/octet-stream, 14 KB)

Ein Unterschied der einen Unterschied macht. Aber auch das Ausbleiben der Information kann in Information umschlagen. Das wäre vielleicht genaues beobachten?

Dass Zettelkästen eventuell eine Renaissance durchmachen, ist interessant. Interessanter ist noch, dass es gefühlt mehr englischsprachige Artikulationen sind, die den Zettelkasten aufgreifen. Könnte auch sein, dass ich mir was einbilde, aber es liegt so oder so auf der Hand, dass eine so klar auszubuchstabierende Methode mit so klaren Vorzügen - gerade im digitalen Raum - irgendwann an Traktion gewinnen muss.

Anschließend an meinen Post wie ich Evernote als Zettelkasten benutze, gab es eine weitläufige Diskussion im Forum von zettelkasten.de.

Größtes Highlight für mich:

• es wird grundsätzlich in Frage gestellt, ob ein iteratives Vorgehen überhaupt Vorzüge hat ("add value any time you touch a note")

Kann nicht sagen, dass ich dem zustimme, zumal das Argument ist: "Wenn man keine hochqualitativen Zettel von Anfang an schreibt, dann kann das Endergebnis nicht gut sein." Das glaube ich gerade nicht. Die Medientechnik des Entwurfs ist nicht obsolet, nur weil man einen einzelnen Gedanken je Notiz zu fassen sucht.

Am Ende ist meine Herangehensweise auch nicht widerlegt worden. Aber interessant ist schon, wie die Diskussion sich auf meine eigene Notizenproduktion ausgewirkt hat. Nämlich habe ich noch einmal etwas gründlicher die Prinzipien eines klassischen Zettelkastens studiert und habe folgendes dabei festgestellt: Die klassischen "Ideenzettel" (also solche, die lediglich einen interessanten Gedanken fassen), sind lediglich eine Untermenge des Zettelkastens. Auch die dazugehörigen Themenzettel (für Outlines o. Ä.) und Verbindungszettel (für die Erklärung von Verbindungen zwischen wenig Offensichtlichem), usw. meine ich damit nicht, as gehört zum Instrumentarium der abstrakten Rekombinationsmaschine.

Aber als angestellter Programmierer dient mir der Zettelkasten auch als Wissenrepositorium und Arbeitswerkezug. Neben kurzen HowTo's und Checklisten, enthält der Zettelkasten auch Code-Beispiele, Arbeitsjournaleinträge (Was habe ich heute getan?), Meeting-Notizen, usw. All diesen Schnipseln ist gemein, dass sie einerseits nicht die ideelle Schärfe einer auf einen Punkt runtergefeilten Idee erreichen. Sie sind häufig länger. Sie erschließen sich häufig nicht selbstständig. Sie mögen sehr viel mehr zusammenkopiert sein, als man das für gewöhnlich in Zettelkästen fordert. Und doch ist dieser Zettelkastenschrott nicht egal, im Gegenteil. Nicht selten kann dieses Material - und zu diesem Material kommt dann noch das was ich in meiner Freizeit ansammle zu besseren Dingen veredelt werden, im Sinne einer Steigerung einer Qualität an einem Ding, stärker "verzettelt" werden. Man könnte auch sagen, "stärker Systematisiert".

Jedenfalls sind diese Schrottbezirke Netzfundstücken oder Buchlektüren nicht unähnlich, ähnlicher noch sind diese Notizen aber Unterstreichungen, Bookmarks oder RSS-Feeds und zwar in dem Sinne, dass sie als Technik der Weltkomplexitätsverringerung eine Vorauswahl an möglicherweise Interessantem (oder interessant Gewesenem) angesehen werden können:

References, highlights, pinboard, RSS; all these are outside of the Zettelkasten system but could be considered a part of the outside with reduced complexity for the Zettelkasten compared to the internet as a whole or for that matter the world outside of it.(Quelle: Living With A Zettelkasten)

Umgekehrt ist aber die Verbesserung der Qualität der eigenen Notizen in dieser Hinsicht sicher ebenfalls eine Aufgabe, nämlich: Die Erhöhung der Komplexität dessen was genuin Teil des Notizensystems ist. Und das wiederum kann ebenso graduell auch mit Notizen passieren, die keine Ideen, Konzepte oder im eigentlichen Sinne zu remixende Wissensstrukturen sind. So habe ich etwa festgestellt, dass etwas mehr Liebe beim Festhalten der Recherchen zu einer mir immer noch neuen Programmiersprache (PHP), oder der vielen kleinen HowTo's wie unsere Infrastruktur zu verwenden ist, die Serendipität des Systems erhöht.