My Simple Note Taking System
2023-06-05This article explains my current note taking setup within emacs.
Motivation
Maybe you know that. You're so concerned about getting your note system right at the very first place that you avoid taking notes at all. There are uncountable directions getting notes 'right' and 'just working for me'. Over the years I settled with a rather simple system that I'm using in the analog world as well as in the digital one. I'll shortly describe the rational about my choices and will also present my different approaches over the years.
From digital to analog and back
My very first note taking approach was
using deft. It is an
emacs mode which can be used for quickly browsing your notes. It gets
inspired by the notational
velocity for storing and retrieving notes. I was a long time user
of
deft
, and that mode was fitting my needs in a great way because taking
notes was a breathe. You just open the mode which brought up a list of
your notes sorted by date or title. As soon as you started typing the
list gets narrowed down to a possible match. If no match was found
deft
creates a new file with the input as file name and title. However
over time I missed an important feature - namely time stamping. Within
my analog (low-tech) notebook I'm usually starting with a date and a
title. For example.
2023-12-01 My super awesome title
It was not easy to achieve that similar approach with deft
. My
workaround back in these days was to use an ISO date as part of the
input field that gets then used as file name.
202312010923 My super awesome title
It was working but it puts to much thinking in front of capturing the actual content of a note. At that time I also tried org-journal which was also great and 'just worked for me'. But inserting a title was not an straight forward task. I ended up with files having file names and titles like
20120612-journal.org
Searching and grepping through these files was anyhow possible with
deft
, so I used that over several years.
After that, the big zettelkasten
and second
brain
movement started to be the holy grail of note
taking. But, for me, that was putting more complexity on top of my
rather simple approach of taking notes. Nevertheless the lesson I
learned by using logseq was to get
your tags right. At that time I also started using a common
place
book for all my notes. I highly appreciated the
simplicity of pen and paper. No boot-up, low battery or broken
software to fix first. Just open your notebook and write, color and
mark as you like. For me, it is still the most distraction free
writing experience. Instead of carrying around a digital device for
spontaneous note taking, you can just pick up any sheet of paper or
notebook to get started - very low barrier for taking notes. But what
about hyper-linking?
Although there exists analog forms of linking notes together in a physical notebook, these are by no means on par with their digital counterparts. Linking, searching and categorizing that is where computer are really shining as long as the data is in a 'understandable' form. Which brings us back to the initial problem. How do I get my notes 'right'?
Where there is plain text, there is a solution
By rewriting my static site generator using basic UNIX tools I
uncovered a simple truth about files. It doesn't count so much in
which format your files are as long as it is plain text there is a tool
to transform your input content in whatever output you
need. Transforming meta data about your blog posts can be done with an
awk
script. You need more, using pandoc
could be an option. When you
write your notes today in the form of:
title: My title
date: 2023-12-01
tags: tag1 tag2
And you decide in 20 years I need it now in some kind of json
format.
{
"title": "My title",
"date": "2043-12-01",
"tags": [ "tag1", "tag2" ]
}
The transition is possible. From the same source of meta data I was able to generate index pages, rss feeds and summaries by using not more then three UNIX tools.
The Emacs way of life
I'm by far not the only one continuously thinking about getting better
in taking notes. Prot and others are working
on denote to
simplify note-taking for emacs where they put the file-naming scheme
in focus. Personally, however, I'm following a more emacs built-in
approach but definitely get inspired by their idea of using an
additional id
for their notes. Reading
about jao's
simple note taking system shows that he is thinking in a similar
way. His note taking approach is based on a set of lisp functions
customized for his demand. For me, as a mediocre emacs lisp coder,
introducing more code beside emacs built-in mechanism could be
problematic in a maintenance and long run perspective. So I was
adapting his approach as much as possible to fit my need.
I'm using emacs org-mode capture feature with a custom function
target. The main part is done within
dak-org-note-create-with-title--fn
, a prompted title is
transformed in an url slug
and is used as file name at
the same time. The remaining capture part in
dak-org-note--template
is used to insert date and tags with completion
from my agenda files.
(defun dak-org-note--template (k)
`(,k "Plain Note." plain
(function dak-org-note-create-with-title--fn)
,(concat "#+DATE: %<%Y-%m-%d>\n"
"#+FILETAGS: %^G\n"
"\n%?")))
(defun dak-org-note-create-with-title--fn ()
"Function using for visiting a file and insert a title."
(let ((title (read-string "Title: ")))
(when (not (string-empty-p title))
(let* ((slug (replace-regexp-in-string " " "-" (downcase title)))
(path (expand-file-name (concat slug ".org") dak-notes-directory)))
(set-buffer (org-capture-target-buffer path))
;; moves point forward
(insert "#+TITLE: " title "\n")))))
(with-eval-after-load 'org-capture
(add-to-list 'org-capture-templates (dak-org-note--template "n")))
Moreover, for finding my notes I heavily rely on grep
mode. There is
currently no back-link or linking strategy in place. For getting an
overall picture of my notes I'm using logseq
. Thus I just need to
ensure to follow some advice from how to use tags.
(defun deft ()
"quickly grepping my notes"
(interactive)
(require 'grep)
(let* ((regexp (grep-read-regexp))
(files "*.org")
(dir (expand-file-name dak-notes-directory))
(command (concat "grep -nH " "\""regexp"\"" " " dir files)))
(grep command)))
Summary
Taking notes should be as effortless as possible. My approach here is
to keep it as simple as possible and distraction free. The focus is
clear on capturing my notes as fast as possible (ie. capturing is key)
not on tweaking my note taking system to get it right. Inspired by
using an analog common place
book, there are only two or
three meta information a note needs to be placed in a
context. Capturing these information can literally be done with any
tool (I'm using emacs) that can be used with plain text. Changing
notes back and forth between different markup languages is no issue
then. Just keep it consistent to be able to find your valuable
thoughts again. What you're waiting for, go and get starting taking
notes.