I use David Allens Getting Things Done System (GTD) for quite some time now. This post documents my journey to a functional Getting Things Done system and my earlier and current implementation.
Getting Things Done (GTD) is a personal productivity system designed by David Allen. If you have never heard of it I recommend reading David Allen’s book or check out his GTD Website for a quick introduction.
The cornerstone of GTD is, among others, a trusted system where all tasks and appointments are stored. The idea is to get all tasks written down and out of the mind. This reduces the burden to track the tasks and remember them.
If multiple tasks belong together they are handled as a project. Each project has a clear vision and outcome. Projects are planned with David Allens natural project planning method where actions sorted as a series of small next action’s. For example this blog post had the following next action structure at the beginning:
Vision: Publish blog post describing my GTD system.
After that I added more and more tasks until the blog post was completed. It is important to define actionable next actions. If the project is structured this way, it can be opened and worked on straight away. It also reduces procrastination. Small actionable steps are less daunting than bigger tasks.
Tasks can have contexts such as @home, @work, or @computer. Contexts represent the circumstances that are necessary to complete the task. For example it is only possible to write the blog post when I am at the computer. The trusted system can then be filtered based on the context and hide tasks that are not relevant right now.
It requires some time to manage a trusted system. During peak times the system can get out of control and become cluttered. This is where the weekly review comes into play. During the weekly review, all projects are updated to the current state. Missing next actions are added and finished or discarded projects are archived.
I first heard of GTD in 2005 during my professional education as a computer technician. At the time I used a paper based system to track various work and school related tasks. The paper system worked quite well, but after going to the swiss military and rejoining the corporate world one year later I sort of forgot GTD.
In my new job I mainly relied on hand written notes, post-its, my e-mail inbox and my brain to remember tasks. After a couple of years I joined another company where we used a ticketing system to keep track of incidents changes and problems.
My reunion with GTD came two years later when I moved to the engineering team. My work was fragmented among different projects with different schedules and progress. Some times a project was on hold for weeks and then suddenly came back to life. This required me to switch back and forth between projects and keep track of the current state of each project, even if there was a huge time gap to the last time I worked on it. During that time, I reread David Allens Getting Things Done and used Onenote to track tasks. The OneNote system worked but I was never fully satisfied with it. After some time certain shortcomings became obvious and I started to work with my Emacs and Org Mode setup.
I do not remember all details of my paper based system. Basically I used one sheet of paper for each project and kept all those sheets inside a folder. When a project used more than one page I simply added more. It was something like:
To capture ideas on the go I used a small notebook in my back pocket. The Outlook Inbox was my second task list.
If I would start this today I would probably use something like the Bullet Journal.
My first real GTD implementation was based on OneNote and Outlook. These are the tools that are available in nearly every corporate computer and work out of the box. OneNote is also a cloud based service, meaning that the GTD system can be synced between work and private devices such as smartphones. This is important to me. Most of the time I do have ideas at odd times and want to capture them immediately.
My OneNote was structured the following way:
Besides OneNote I used Microsoft Outlook to track appointments and to reserve big chunks of time for project work in the calendar. I also use Outlook as a reference system for mail with the following folder structure:
Using both OneNote and the Outlook @Action folder as my trusted system is a feasible workaround for my workflow. On one hand it is cumbersome to use two programs on the other hand it makes no sense to copy tasks between programs.
Using this systems for over two years I discovered some shortcomings that led me to research other options. These are the shortcomings in no particular order:
Org Mode is an Emacs mode for note taking, todo lists and projects management. Furthermore it can be used as an outline or an authoring and publishing system. In fact I have written this blog post with Org mode. Org Mode files are plain text files with a .org extension.
Spacemacs simplifies my Emacs configuration. It is a community-driven Emacs distribution that bundles useful Emacs packages together. Emacs is an extensible editor. In fact the Emacs slogan is: “The Extensible, Customizable Self-Documenting Display Editor”. But with great power comes great responsibility. Spacemacs has useful defaults and greatly reduces the initial time to set up the environment.
If this sounds quite technical that’s because it is. Although Emacs and Org mode can be used by non-technical people, I would not recommend it. Instead go the OneNote and Outlook route if you are not interested in spending quite some time learning configuring your setup.
I use one main Org mode file, GTD.org and one archive file, GTDarchive.org. The GTD.org file has this structure:
work contains all work related tasks. However, most of my tasks are grouped as projects. private has the same structure as work. I am not quite satisfied with notes and lists. These sections are probably extracted to their own files in the near future but for now I look how it works.
For tasks I use the states TODO,
NEXT and DONE. All tasks are either in
the TODO or DONE state if they are finished. One task in each project
has the state NEXT. This is the task I should work on next when I open
the project. This allows me to generate a filtered view of my GTD.org
file with SPC m / NEXT to see tasks I can work on next.
One of the disadvantages of my earlier OneNote setup was the lack of task creation and closing dates. Some Elisp snippets handle this automatically now.
Org Mode Capture is a handy tool to create a new TODO item from any
open Emacs buffer. I use two shortcuts. C-c c w adds new
work tasks. C-c c p adds new personal tasks. Here
is my configuration for it.
One of the main benefits of Org Mode is the Agenda view. In its basic configuration, the Agenda shows tasks that are scheduled for today or have a deadline set for the near future. In addition, the agenda view allows you to configure your own view based on filters.
I use the following keyboard shortcuts to interact with the Agenda:
| Keyboard Shortcut | Description |
|---|---|
SPC m a a |
Open Agenda for today |
SPC m a n |
Open Agenda and show all TODO items in state NEXT |
SPC m a w |
Open Agenda and show all TODO items in state WAITING |
C-v l |
Shows all logged entries I worked on today. This works only inside the Agenda. |
The Org Mode Manual provides great documentation on how to configure your own Agenda views.
When I arrive at the office I open up Emacs and use
SPC m a a to open the Agenda view and see what items are
scheduled for today and what deadlines are coming up. I usually schedule
some more tasks for today with s on a task. These are the
tasks I would like to complete today. After that I work on the tasks
until I finish them or leave the office. If I do not finish all tasks
they will show up on the agenda the following day. On some days I run
out of scheduled tasks and open the agenda view for Next actions with
SPC m a n.
Of course I relied on a variety of online sources when creating this setup. This is a collection of those.
(setq org-todo-keywords
(quote ((sequence "TODO(t)" "NEXT(n)" "|" "DONE(d)")
(sequence "WAITING(w)" "HOLD(h)" "|" "CANCELLED(c)" "PHONE" "MEETING"))));; Allow automatically handing of created/expired meta data.
(require 'org-expiry)
;; Configure it a bit to my liking
(setq
; Name of property when an item is created
org-expiry-created-property-name "CREATED"
; Don't show everything in the agenda view
org-expiry-inactive-timestamps t
)
(defun mrb/insert-created-timestamp()
"Insert a CREATED property using org-expiry.el for TODO entries"
(org-expiry-insert-created)
(org-back-to-heading)
(org-end-of-line)
(insert " ")
)
;; Automatically add tags when state changes occur
(setq org-todo-state-tags-triggers
(quote (("CANCELLED" ("CANCELLED" . t))
("WAITING" ("WAITING" . t))
("HOLD" ("WAITING") ("HOLD" . t))
(done ("WAITING") ("HOLD"))
("TODO" ("WAITING") ("CANCELLED") ("HOLD"))
("NEXT" ("WAITING") ("CANCELLED") ("HOLD"))
("DONE" ("WAITING") ("CANCELLED") ("HOLD")))))(setq org-agenda-custom-commands
'(
("n" todo "NEXT")
("w" todo "WAITING")
("d" "Agenda + Next Actions" ((agenda) (todo "NEXT")))
)
);; Source: https://www.suenkler.info/docs/emacs-orgmode/
(setq org-capture-templates
'(
;; Create Todo under GTD.org -> Work -> Tasks
;; file+olp specifies to full path to fill the Template
("w" "Work TODO" entry (file+olp "~/Dropbox/orgmode/GTD.org" "Work" "Tasks")
"* TODO %? \n:PROPERTIES:\n:CREATED: %U\n:END:")
;; Create Todo under GTD.org -> Private -> Tasks
;; file+olp specifies to full path to fill the Template
("p" "Private TODO" entry (file+olp "~/Dropbox/orgmode/GTD.org" "Private" "Tasks")
"* TODO %? \n:PROPERTIES:\n:CREATED: %U\n:END:")
))