Homepage Resume Book Recommendations Blog

Productive use of TODO lists (for programming)

I feel like I finally came to understand exactly how a TODO list should be used and why it boosts your productivity above any expectations. It's really very simple, but because it is so simple and obvious, it's often ignored: keep the TODO list next to your work, open at all times.

My 2 display layout with a TODO list on the right.

This one habit will make you very productive. To understand why it's important and what are the implications, we first need to understand what is the true purpose of using a TODO list.

Some people mistakenly believe that we need TODO lists to organize ourselves - that's false. Written words cannot magically make you organized, just like a constitution of a country proclaiming freedom and other perks does not magically make those things materialize. Another reason to use TODO lists many people cite is laziness: somehow TODO lists are supposed to keep us motivated and push us to do things. My experience is that it's also false. Finally, there's this idea that TODO lists are useful because they don't let us forget things - naturally, like any written word, it keeps our intentions documented. This last one may seem reasonable, but the true purpose of TODO lists is actually the opposite: they help us forget. Or, in other words, they let us get things off our mind to free our minds for other things.

That's why I keep my TODO list open at all times during my work. When I write code, many ideas that are not directly related to the piece of code I'm working on, may come to mind. Not directly related, but still relevant. And I need to take care of them too. This feeling is familiar to almost all programmers: you're working on a feature, then you realize that in order to implement it, you also need this fixed and that patched, which might also affect another part of the program. How do you take care of that and not lose focus? You can probably keep it in your head for a while, but that occupies your RAM and you lose part of your focus. And, incidentally, that's probably why people may once in a while smash two unrelated git commits together into one. Don't do that - instead use your TODO list. It takes about 10 seconds to write a short TODO list item and then you can come back to your problem at hand without losing focus and with the peace of mind that you will certainly take care of it later.

Another huge benefit of this habit is that I almost forgot when was the last time I had a writers block: a situation when you just stare at your screen thinking where to start and what exactly you should do today. This problem is all too common because our brains work in different modes: strategic and tactical. You may know what to do in general, but it's damn too hard to switch from that mode into thinking about the first step you need to take. The best bet here is to fill your TODO list with tactical tasks while you're in a tactical mode. Then later, using that TODO list you will help your brain switch from strategic mode into the tactical mode in no time. I try not to put abstract tasks like "Think about foo design" on the list: that's something my brain will remember to do by itself. But things like "write documentation for feature X" are on my todo list.

The final technique I consider very important is nesting. The TODO list that I use is called Workflowy (I'm not affiliated, but I can't recommend it enough!) and it supports nesting items, which turns your TODO list into a huge tree structure. I love that because that's very close to how my brain works - while working on a library feature called:

  • Foo feature
I might quickly realise that this task requires me to do the following:
  • Foo feature
    • lib code
    • unit tests
    • try it out in the app code
    • write docs
Now I don't have to remember to do all that. More importantly, I don't have to do it in that order. I may defer writing docs until I feel like writing docs. In Workflowy, I can even tag items with #docs, so that I can later come back to all the #docs tasks and write the documentation for 10 features at once.

I don't know whether it all resembles any of the popular TODO list techniques, but after asking around I think TODO lists are certainly underused by programmers and for programming. They make you extremely productive and let your brain focus on solving problems instead of remembering which problems it needs to solve.

If you have any other tips regarding TODO lists that you found raise productivity, I'd really appreciate hearing about them.