A couple of years ago, I was trying to improve my note taking abilities and did some research. I discovered the Zettelkasten method and read the book How to take smart notes by Sönke Ahrens which describes this approach invented by Niklas Luhmann, a German sociologist.
For a quick introduction to the method, I find this web site very well done. If you get interested in Zettelkasten, before jumping to the last shiny app or Emacs package, I think it's better to read Ahrens' book.
Anyway, in a few words, in Zettelkasten, you create notes with small bits of knowledge that are meant to be self contained. These notes may contain links to other notes with related content. The idea is that the knowledge is not organized hierarchically, but in a graph where notes point to other notes.
The Zettelkasten is a living thing where notes are regularly added and most importantly, the notes are frequently read and improved, either by reformulating the content, adding links to other notes, etc.
The Zettelkasten is meant to be personal, edited by a single person. It's like a second brain.
Niklas Luhmann did everything by hand and his Zettelkasten was made of paper cards. He had to invent a clever indexing method and used special structure notes to create tables of contents for different subjects. It is a pleasure to browse the original Zettels.
In order to implement a digital Zettelkasten, we only need a note taking application with the ability to create links between notes. A nice bonus is adding tags to the notes to simplify search and generation of sets of related notes.
There are lots of applications on the proprietary software market that support the creation and management of a Zettelkasten. There are also free software counterparts.
Emacs offers several alternatives in terms of packages:
- Neuron mode, which uses markdown;
- org-zettelkasten, which is a set of functions on top of org-mode;
- Zetteldeft, which uses deft;
- org-roam, based on org-mode and inspired by a commercial application.
There are probably others that I am not aware of. Org-roam seems to be the most popular one.
After reading Ahrens' book, I decided that I wanted to try the approach. I did not think want to choose one of the available Emacs packages for several reasons. The first one is that I did not understand why I needed anything else than plain org-mode. The second one was that I did not want to commit to any particular implementation before understanding how and if the approach would be useful for me.
How I do Zettelkasten
I have a big org-mode file called
zettels.org with to top-level headings, one for structure notes and another one for standard zettels. Each note is a second level heading with a title, possibly some org-mode tags, a property drawer and the note content.
The property drawer contains at least the
DATE_CREATED property with an inactive org-mode timestamp for the day and time when the note was created.
The structure notes are created by hand. That means that I create a heading, write the note and add the
DATE_CREATED property. I do not create many structure notes, so a manual workflow is OK.
For the standard zettels, I use org-capture. The capture template automatically inserts the
DATE_CREATED property, but also a
FROM property with an org-mode link to the place I was in Emacs when I run org-capture. This link can therefore point to another Zettel (for which an org-id will be created), any org-mode heading if I am in an org-mode file, but this can also be an e-mail in Gnus, a pdf document, an EPUB file, a web page, etc. This is possible because I do everything in Emacs. Storing where I was when I created the note gives interesting context.
I have 2 org-capture templates for Zettelkasten, one which does what I described above, and another one which is used for quotes. The latter will copy the marked region in the current buffer into a quote org-mode block.
So a typical captured zettel may look like this:
** The title of the note :tag1:tag2: :PROPERTIES: :DATE_CREATED: [2021-08-06 Fri 22:43] :FROM: [[nov:/home/garjola/Calibre Library/abook.epub::26:7069][EPUB file at /home/garjola/Calibre Library/abook.epub]] :END: My ideas on the subject. Etc. #+begin_quote Some text that was marked in the EPUB I was reading. #+end_quote - See also [[id:e2b5839d-d7ef-4151-8676-17dacd261e86][Another note linked with org-id.]]
This way, while I am reading interesting things, I can capture an idea with all its context. I will of course come later to this note to improve it.
This is done in my regular gardening sessions. During these sessions, I browse the Zettelkasten, read notes, add tags and links to other notes, rewrite things, etc.
For this tasks, I use a couple of functions. The first one jumps to a random Zettel, so I am sure that I regularly explore forgotten parts of the Zettelkasten. The second one finds back-links, that is notes having links that point to the current note. This is useful for a bi-directional browsing of the content.
My custom Zettelkasten setup
Capture templates for Zettelkasten
The first component of the setup is the capture templates. They look like this:
(setq org-capture-templates (append org-capture-templates (quote (("z" "Zettelkasten") ("zz" "Zettel" entry (file+headline "~/org/zettels.org" "Zettels") (function my/zettel-template) :empty-lines 1) ("zq" "Quote" entry (file+headline "~/org/zettels.org" "Zettels") (function my/zettel-quote-template) :empty-lines 1)))))
There are 2 templates, one for notes without quotes (called with
zz) and another for notes where I want to insert the marked region in the current buffer as a quote (called with
zq). Both templates insert the note in the
zettels.org file under the
Zettels heading. Instead of writing the template in this code, I prefer using a function to generate it. I find this more readable.
The 2 functions are here:
(defun my/zettel-template () "* %?\n:PROPERTIES:\n:DATE_CREATED: %U\n:FROM: %a\n:END:\n%i\n") (defun my/zettel-quote-template () "* %?\n:PROPERTIES:\n:DATE_CREATED: %U\n:FROM: %a\n:END:\n#+begin_quote\n%i\n#+end_quote")
They are straightforward. The cursor is placed in the heading (with the
%? org-expansion) so I can write the title. The property drawer will contain the time stamp and a link to the place Emacs was when org-capture was called. In the case of the quote, the marked region is copied inside the org-mode quote block.
And that's it!
Back-links to zettels
Back-links can be tricky. The package org-sidebar provides a function for that. But for some reason that I don't remember, I didn't like the way it worked (or more probably, my incompetence did not allow me to make it work). So I searched a bit and found a bit of elisp that does what I need.
(require 'org-ql) (require 'org-ql-view) (defun my/zettel-backlinks () (interactive) (let* ((id (org-entry-get (point) "ID")) (custom-id (org-entry-get (point) "CUSTOM_ID")) (query (cond ((and id custom-id) ;; This will be slow because it isn't optimized to a single regexp. :( (warn "Entry has both ID and CUSTOM_ID set; query will be slow") `(or (link :target ,(concat "id:" id)) (link :target ,(concat "id:" custom-id)))) ((or id custom-id) `(link :target ,(concat "id:" (or id custom-id)))) (t (error "Entry has no ID nor CUSTOM_ID property")))) (title (concat "Links to: " (org-get-heading t t))) (org-agenda-tag-filter nil)) (org-ql-search (quote ("~/org/zettels.org")) query :title title)))
It uses the wonderful org-ql package to search all org headings with a link matching the org-id of the current note. The search is limited to my
Jump to a random zettel
The last bit I needed for serendipity is jumping to a random note. For this, I use the org-randomnote package. This package uses the
org-randomnote-candidates variable to store the list of files that will be searched for random headings. It is initialized to the value of
org-agenda-files. I just wrote a couple of functions to temporary change the list of candidate files so that I can limit the random jump to my zettels file:
(defun my/random-note (candidates) "Jump to a random org heading in one of the `CANDIDATES` files" (let ((old-randomnote-candidates org-randomnote-candidates)) (setq org-randomnote-candidates candidates) (org-randomnote "zettels") (setq org-randomnote-candidates old-randomnote-candidates))) (defun my/random-zettel () "Jump to a random zettel" (interactive) (my/random-note '("~/org/zettels.org")))
Moving to org-roam (or maybe not)
My first Zettel dates back to December 30 2019. I've been using this system since then and I am very happy with it. A year ago, I started seeing a big buzz about org-roam and I looked into it. It seemed very nice, with functionalities that I don't have in my system and I started wondering whether I should use it. Since at that time I understood that there were some breaking changes planned for version 2, I decided to wait for org-roam v2 to be released and re-evaluate the situation.
In the meantime, my Zettelkasten has continued growing. Today, it contains 1345 zettels. After org-roam v2 was released, David Wilson at System Crafters did a series of videos showing the power of org-roam. As always, David's videos are of great help to get started and he has the rare ability of guiding the interested crafter so that he or she is able to customize thing as wanted.
I therefore installed org-roam and even wrote the code to migrate my Zettelkustom to org-roam. I was an interesting exercise that allowed me increase my knowledge of Emacs Lisp and get familiar with the
However, I am not sure that I want to do the migration. Although org-roam is very rich and has a large community of users, I have the feeling that it does to many things that I don't need. I guess that, if I was starting with org-mode, org-roam would be the good choice, but I have been using org-mode for personal organization (with GTD), note taking, writing scientific papers and reports, doing literate programming, and may more things.
And I have my personal preferences and habits that I will likely not change. For instance, for me, mixing project management and Zettelkasten does not make sense. I also don't need a special integration between Zettelkasten and my bibliographic database (org-ref and ivy-bibtex are all I need).
Therefore, by now, I'll stick to my 2 capture templates and 2 simple functions that I understand well.
I any case, all this shows the power of org-mode and its ecosystem.
When I was young, and vinyl records were not a cool thing but just the usual thing, I used to sit down and listen to music. Actually, I used to listen to albums, which is a forgotten concept that has been replaced by playlists. Anyway.
The fact of just listening to music and not doing anything else has been a luxury for years, but two years ago, I decided that I would sit down and listen again to music with full attention. Unfortunately, I don't have my vinyl collection anymore. All my music has been digitized and lives in the hard disk drive of my laptop. This has the great advantage of being available everywhere I go.
I of course use Emacs as my media player. And I use EMMS because it was the only solution available when I started and I like it. EMMS allows to browse the available music by album, artist, song, etc. So, when I want to listen to an album, I can just do
M-x emms-browse-by-album and choose one album. This is what the buffer with the albums looks like:
So for a couple of years I have had a weekly ritual, on Sunday afternoons, where I choose an album, put my comfortable headphones and listen to a full album, track by track, in the order they were defined by the artists. Then, I log the album to an org-mode file, so that I can keep track of what I listen.
The issue I have had is of course choosing what to listen to. One year in this new habit, I decided that I would choose the album randomly. So I started using
M-: to type
(random 1077)1, then
M-x goto-line with the result of the random choice.
Of course, after several weeks, this became tedious and I had to automate it. I also decided that I did not want to write the log entry by hand. This is what I came up with:
(defun my/emms-play-random-album () "Play a random album from the EMMS music database. Generate an org entry with album artist and listened date for my records." (interactive) (emms-browse-by-album) (let ((nlines (count-lines (point-min) (point-max)))) (goto-line (random nlines)) (emms-browser-add-tracks-and-play)) (let* ((album (alist-get 'info-album (emms-playlist-current-selected-track))) (artist (alist-get 'info-artist (emms-playlist-current-selected-track))) (org-entry (format "* %s\n:PROPERTIES:\n:ARTIST: %s\n:LISTEN_DATE: %s\n:END:\n" album artist (format-time-string "[%Y-%m-%d %a]")))) (kill-new org-entry) (message org-entry)))
The function is easy to understand. I start by opening the album browser. Then, I count the number of lines in the buffer, and jump to a random line. The call to
(emms-browser-add-tracks-and-play) just does what it says. This is just automating what I was doing by hand, but calls the same commands I was using.
I am more proud of what follows, which allows me to generate the bit of org-mode text that I need for my logs. Here, I get the name of the album and the artist of the track that just started playing using the appropriate EMMS internal function. Then I format the string with an org headline containing the album title and a property drawer with the artist and the date. It looks like this:
* Undercover :PROPERTIES: :ARTIST: Rolling Stones, The :LISTEN_DATE: [2021-09-26 Sun] :END:
I don't automatically put the entry in the log file, because sometimes I play a random album without wanting to log it. What I do here is put the entry in the kill ring so I can yank it in the appropriate place. And I also display it in the echo area.
This is yet another example of how powerful living in Emacs is. You can bridge packages that were not designed to work together (here EMMS and org-mode) to automate things. In other operating systems, if the apps are not from the same vendor and that they have not foreseen to use them together, you can't do that.
Another nice thing here is that the EMMS buffer (the album list here, but it is the same with the playlists, or any other buffer) is just text, so you can move around as in any other buffer (with
goto-line in this example).
Finally, being able to use any internal function or variable of a package (
emms-playlist-current-selected-track in my case) is very handy. As always, in Emacs, everything (the code, the documentation, etc.) is always available for the users to do whatever they need.
yes I have that many albums
E-mail is my preferred way of communication, even if some say that e-mail is doomed.
I read my e-mail with Gnus in Emacs. The IMAP back-end in Gnus can sometimes be slow over the network and therefore lock Emacs while fetching. Another drawback of IMAP is the need to be on-line to access the e-mails on the server. Finally, having a local copy of all my messages is important for e-mail provider independence.
This is why I use mbsync/isync to get my e-mail for several accounts. This can happen outside of Emacs by calling the
mbsync command which will use the appropriate configuration in
.mbsyncrc to do its thing. I could put this on a cron job, but I prefer to run the e-mail fetching at my pace. Since my interface to the computer is Emacs, I want to be able to use
mbsync from Emacs.
It shouldn't be difficult to write an Elisp function to call an external process running
mbsync, but Dimitri Fontaine put together mbsync.el which does this cleanly logging output to a dedicated buffer and warning if things go wrong when trying to connect to servers.
mbsync with the
-a flag, which means that all channels (that is the e-mail accounts configured in
.mbsyncrc) will be fetched. While this is a sane default, I sometimes want to fetch just one e-mail channel. The author of
mbsync.el had the nice idea of providing a customizable variable to store the flags:
(defcustom mbsync-args '("-a") "List of options to pass to the `mbsync' command." :group 'mbsync :type '(repeat string))
We can therefore exploit this to change the flags. I wrote the following function to call
mbsync for a particular channel:
(defun gd/mbsync-single-channel (channel-name) "Fetch e-mail with mbsync for a single channel" (interactive "smbsync channel: ") (message "Fetching mail for channel %s" channel-name) (let ((mbsync-args (list channel-name)) (mbsync-buffer-name (format "*mbsync %s*" channel-name))) (mbsync)))
The function takes a string containing the channel name and will use it as the flag to call
mbsync. I also change the name of the the buffer where
mbsync.el will write the logs (
mbsync-buffer-name is a variable defined in
mbsync.el). Binding the variables with
let leaves them as they were before calling the function.
This function can be called as an interactive command (with
M-x), but can also be used to define one function for each e-mail channel:
(defun gd/mbsync-proton () (interactive) (gd/mbsync-single-channel "proton")) (defun gd/mbsync-fastmail () (interactive) (gd/mbsync-single-channel "fastmail")) (defun gd/mbsync-gmx () (interactive) (gd/mbsync-single-channel "gmx")) (defun gd/mbsync-garjola () (interactive) (gd/mbsync-single-channel "garjola"))
I am not very happy with this approach, since there is lots of redundancy. Maybe I could use some macros to simplify this, but I am not proficient enough in Elisp yet.
With these functions, I can define a hydra which will provide a menu to select the e-mail channel to fetch.
(defhydra gd/hydra-mbsync (:timeout 4) "Fetch e-mail with mbsync" ("p" gd/mbsync-proton "proton") ("f" gd/mbsync-fastmail "fastmail") ("x" gd/mbsync-gmx "gmx") ("g" gd/mbsync-garjola "garjola")) (global-set-key (kbd "<f9> O") 'gd/hydra-mbsync/body)
Now, when I type
<f9> O, the following menu appears in the mini-buffer.
And I can select which channels to fetch. Yes, channels in plural, because this is a persistent menu which stays there for 4 seconds (the timeout parameter of the hydra) and I can select several of the channels.