My Simple Note Taking System


This article explains my current note taking setup within emacs.


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

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"

(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"
  (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)))


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.