Here I will explain my way of keeping track of all the things I have to do in my life.
I want to have a system which
Quite obviously, it is text based, as pure text is the only format not requiring a special tool on computers. As I am a text nerd, and (except for some mind-mapping) not of a visual type, this actually fits me well.
Therefore, all is done with pure text files, or writing that does not depend on graphical markup or pictograms.
The basic element is the (task or "ToDo") list.
Each task list has a certain context, inspired by David Allen's Getting Things Done system, which however is too rigid for me.
In my job, I have the contexts Office, Lab, and Mobile/Mail. In private life, they are Home, Shopping, and Mobile/Mail/Phone.
They should be self-explanatory, except for the Mobile categories: they contain tasks I can do during commute, whenever I have a moment somewhere, and of course also while being at the office or at home (but then I normally do things from the other lists).
I use a certain syntax for the tasks, namely:
F MM free text
where F is a flag with the following meanings.
For tasks written in electronic form:
- for an open taks, which needs to be done;+ for a done task, which will soon be moved to the archive;* for a task which is in a waiting state (like delegated or a request
sent to somebody, but no answer received yetThese flags also have the meaning of "bullet list item" in Markdown, because I very much like Markdown format for everything text.
For tasks written in paper form:
- and + are the same as above;H for a task in a waiting state (hint: "on Hold") as above;T (actually the lower half of a +) for a task moved to another list,
i.e not yet done but no longer of interest in the current context
(hint: "Transferred")The MM after the initial flag is mostly only used for electronic form,
as it is a marker for the list itself (first letter) and a priority
roughly based on the "four quadrants" philosophy popularized
by Stephen Covey, which seems to having been initially described by
Eisenhower and therefore also is called "Eisenhower's Principle".
For example, an "L1" taks is an important and urgent task to be done in the Lab, or an "M3" task is an important but not (so) urgent one while on the go.
Tasks I write down on paper I sometimes mark with = instead of -,
if they are urgent and important; one can easily strike that through as
well, when it's done. In addition, tasks on paper rarely get moved from
one context to another, but rather rewritten, and so the additional list
marker would be rather useless.
Currently, I use electronic format for my professional tasks, and paper&pen for my private stuff, because in private life, I rarely have to sync between different places or tools. However, having had much better results with my system in my professional life, I am considering switching to electronics also for private stuff. But I love pen&paper, and so I'm still resisting...
At work, the different contexts are supplemented with two lists called
"medium term" and "long term". In GTD they would be called "Projects"
I suppose, and they hold stuff I do not care of for the current or
next week, but have to be kept in mind. On a weekly review, they may
be promoted to my "current list" with the different contexts separated
into different lists. About daily, all the "done tasks" (with +)
are moved to a "Done" list, which is emptied during the weekly review,
i.e moved away into the archive.
As I have my todo-list file tracked with the version control system Git, I simply empty the "Done" list after having committed the reviewed list, and so the archive is taken care of by the versioning control system. Of course I could simply save the todo-list file each week under a different name for archiving, but Git allows me to also easily synchronize my work among different machines (office PC, laptop, server at the informatics services, smartphone and tablet).
Each day (normally the evening before, but sometimes during morning commute), I put three of the most urgent tasks (that I want to finish that day) into my calendar while planning the day, and if I have a lot of stuff to do at the lab, they get onto a small piece of paper I can carry in my pocket, as this is easier than regularly checking the list on the smartphone or tablet.
My private/personal tasks I jot down in a small booklet which complements my (paper) calendar. Not much to be said here, except that I start a new page, when one is full of tasks, and when all are done, the whole page gets striked through.
In addition to the task/todo lists, of course I need a calendar. In contrast to the GTD philosophy, not only appointments with other people go in there, but also "appointments with myself", i.e time I want to block for important (even if not that urgent) tasks, to make sure they are taken care of.
My principal calendar is on paper, but to make sure I can also take new appointments if I forget it somewhere, and as a backup, I synchronize the paper calendar regularly (in general, weekly) to an electronic one, which is also a plain text file, version controlled with Git. This electronic calendar I make myself with some simple shell scripts that generate skeleton lists of weeks which when filled in look like
### February 2015
#### 2015, KW6: 2015-02-02..2015-02-08
- Mo (02-02)
- Di (02-03) early home, haircut!
- Mi (02-04) 11:30 attend presentation
- Do (02-05) maintenance day
- Fr (02-06)
- Sa (02-07) snow fun!
- So (02-08)
----------------------------------
#### 2015, KW7: 2015-02-09..2015-02-15
- Mo (02-09) 10:30 tech meeting
These lists are (roughly) Markdown formatted as well and indicate the week number, because that's often helpful for professional planning.
I am thinking about writing a script that would parse the calendar file and send me an email or other message, if something is planned the next day. However, so far I had good experiences with daily review of the calendar together with setting of a simple alarm clock if there is something important (appointment etc) in the next 24 hours.
Of course, this is only a snapshot of my current system. As everything alive and heavily used, constantly there are small modifications applied.
As a conclusion, the combination of Markdown, Git, some elements of GTD, and synchronized paper and electronic calendars, seems to be quite good for keeping me efficient and productive!