I’ve often been told that as a PhD student, “95% of your job is knowing how to frame the problem.” I believe that this same intuition applies when choosing software solutions, specifically, you should be spending the majority of your time thinking about the problem you are trying to tackle, not the tools you will do it.

I am not very good at following my own advice. Over the years, I’ve used a lot of tools, and often am looking for problems to solve with the tools. But note taking is different. I have used almost all of the major note-taking software (Onenote, Google Docs, Typora, Simplenote, nvALT), and text editors (Emacs, Vim, Atom, Visual Code, Sublime) and I still see value in trying new things. Taking notes is just so darn important. I’ve learned 3 important lessons from these tools:

  1. No particular environment or program is best for any one person (Some people don’t like rich graphical interfaces - other people are wrong.)
  2. It is important to take notes in plain text
  3. Learning curve should not be the only measure of utility.

In this article, I will be breaking down past and current Notetaking systems, but I will try and concentrate on the problem which each system solves, rather than the tool itself. Remember that the tools themselves are just means to an end.

Write in Plain Text

The first note taking platform I used (other than pen and paper) was OneNote and it served me well. It is incredibly powerful, and if you are a GUI oriented person - I suggest you probably need not read further. However, over time I grew weary. Exporting the files to another format (e.g. blog post, PDF file) was difficult, embedding code snippets within the documents (with highlighting) was impossible, and the format was simply too rigid. This led me to start writing all my content in Plain Text.

It is critical that you learn the importance of writing your notes in plain text - even if you choose for another option. Plain text is the practice of writing your work with just plain text (think .txt.). Why you ask? Plain text is computer readable making it incredibly portable, powerful and quick. You can convert plain-text documents to almost any format with Pandoc. You can edit plain text documents on virtually every computer built in the past forty odd years and it’s unlikely it will ever depreciate in the future. The other major benefit is speed. I don’t want to be waiting for loading times to quickly get a note into place. This is what motivated me to use plain text.

The Problem here is I needed a quick and easy method to write Markdown notes my aim was to have:

  • A single managed note system with minimal system requirements for writing or searching.
  • Able to sync the note system across any operating system.
  • Easily maintain this note system (i.e. automated).

Syncing notes across machines with plain text is incredibly easy and I have never had a single issue with Dropbox. Moreover, it means there are many editing options available, including for Android/iOS.

Basic Editing Tools

For basic writing in plain text, before my Emacs days, I had a variety of beautiful applications that work out of the box.

  • Typora should be your first port of call. Its beautiful minimalist design tucks away an array of awesome features. I feel like a bit of a Hemingway.
  • Remarkable lives up to its name
  • Texts is only for Mac and Windows. It does alright.
  • Atom a hackable code editor for the 21st century.
  • iAwriter for Android

The Notational Velocity Method

Notational Velocity is a method of rapid note taking in which you can search for notes, create notes, or edit notes all with the same keystroke. I enjoy their self declared mission statement “It is an attempt to loosen the mental blockages to recording information and to scrape away the tartar of convention that handicaps its retrieval. The solution is by nature nonconformist.”

This concept has been implicated in software for various operating systems and editors. For windows, you have Notation and ResophNotes (Inactive). For MacOS, nvALT is your best bet. Linux users may need to stick with nvPy, but Zim looks cool, conceptually.

Later last year I was experimenting with the Atom editor and my first NV version was the Atom package nvatom. Nvatom features the single interface for creating, searching and finding your notes from a single keypress. For example, F5 brings up your entry window, and as you type in a phrase (e.g., git), nvalt returns a list of all files with git in the filename or the body. If the file doesn’t exist nvatom will create a new file with search term. Therefore you can instantly create new notes or open old ones.

More recently, I have replaced this entirely with the Emacs package deft and still use it almost everyday. I will touch on Emacs some more in a bit. For now, let’s keep concentrated on the problem at hand: writing notes.

Deft in Emacs searching for the word PhD Form. Interestingly, contained in a draft of this blog post itself on the fourth result. Emacs can load this entire list in milliseconds.

To give you an idea of how I like to label all my plain text notes, see the output of my ls | head -n 10 in my notes directory. Notice that key words are seperated by a space. I find spaces between “tags” a more useful, natural and readible than alternatives for notes. I generally called notes keywords that I knew I could mash in later to find what I was looking for.

2017 Annual Form PHD.md
Feb 07 idea git.md
Feb todo.md
PHD Form Details.md
PMH webdesign notes.md
blog post shrell script.md

I rarely will interact with notes in here for long durations of time. It is like a cache of ideas I sent to be filtered in specific projects. I just need to know remember they are here (fun fact, sometimes I find things in my notes I forgot I wrote - like whole chapters).

One problem with my naming system was that it was too convoluted to mash in the tags when I had seconds to get an idea out. In a meeting I would find notes poorly tagged, and even getting repetitious filenames. To solve this, I tried to label all my notes with a date 2017February01 phd exp3.md. This quickly got tedious, so I thought I would start to make a quick local shell script that more or less does the same job. The following script is pretty easy to set up in your own environment (works on zsh).

If this file is added to your system path: when you call nn in terminal, you create a new note with current date and a random word from the dictionary (thanks perl). I find this useful as the words serve as nice mnemonics. The noteatom function tries to open an existing note based on an inputted file name. ns and nsdir search for notes.

#!/bin/bash

EXT=".md"
NOTESDIR=~/Google\ Drive/notes
MDEDITOR=atom

function nn {
  FILE=$1
  if [ -f "$NOTESDIR/$FILE" ]
   then
     open -a $MDEDITOR "$NOTESDIR/$FILE"
  fi

  if [ -z "$FILE" ]
   then
    WORD=`perl -e 'open IN, "</usr/share/dict/words";rand($.) < 1 && ($n=$_) while <IN>;print $n'`
    DATE=`date "+%y-%b%d"`
    FILENAME=$DATE$WORD$EXT
    touch "$NOTESDIR/$FILENAME" && open -a Macdown "$NOTESDIR/$FILENAME"
  else
    FILENAME=$1'.md'
    touch "$NOTESDIR/$FILENAME" && open -a Macdown "$NOTESDIR/$FILENAME"
  fi
}

noteatom() {
  atom "$NOTESDIR"/"$*".md
}

nsdir() {
  ls -c "$NOTESDIR" | grep "$*"
}

ns() {
  grep -ri "$*" "$NOTESDIR"/*
}

This script really never got a lot of daily usage, and it kind of sucks. About a month or two after I wrote it, I started using deft in Emacs. However, this script is interesting to me for two reasons. Firstly, it is my first attempt at putting together my own formal note system. Secondly, it is what gave me taste for command line note taking - I wanted to scrap Atom.

The Editor Wars

Editor war is the common name for the rivalry between users of the Emacs and vi (Vim) text editors. The rivalry has become a lasting part of hacker culture and the free software community..

I really liked how Connor McDaniel uses Vim. However, I never really got into Vim for all my notes. I found it difficult to implement a clean solution, and it still wasn’t solving the key problem. I didn’t want just another tool. Remember, my problem at this stage isn’t a lack of cool tools it’s that I can’t organize my notes. The Notational Velocity system worked great for simple jobs, but I was yearning for more structure in my notes.

Tags can only filter my notes so well, and I was finding myself spending a lot of time cleaning up and aggregating notes. My friend introduced me to Orgmode in Emacs and I haven’t looked back. I will cover this in more detail in a future post.

John Kitchin has some excellent videos on using Emacs Orgmode. I think his Introduction to Orgmode is particularly excellent.

The highlights of Orgmode writing for me were: - A focus on single long length documents - Can instantly export to any format - Has FULL complex table support - Keybindings to quickly capture ideas (just google Org capture templates). For example, ctrl-c C t prompts you to input details for a todo item and then can store that in a specific location. - I could add and track todo items, deadlines and wishlists - Plain text, but offers unparalleled powerful customization.

A screenshot of a very simple orgmode document. Note the todo tags, which are interactively toggled with shift and the arrow keys. These are saved into an agenda which is accessible from anywhere in Emacs with a single keybinding.

The main limitations of Emacs was the learning curve. To become fully productive in the environment takes some time.

Conclusions

I will update this post like a living object over time. If you are interested in expanding your note taking power - I suggest finding an Notational Velocity system. If you are currently using something like Onenote, I suggest taking a look into how you can convert your system to a plain text one. It’s hard to ever go back.