Here's what part of my task list for my new website looks like:
Rebuild personal website
- Select Tools
- Pick Language
- Long story short, it's Python
- Pick Platform - Django
- Long story short, it's Django
- Pick CMS
- Make a list of possible CMSes
- Look for easy ways to rank CMSes
- Try out all of the candidate CMSes on their demo sites
- Create a list of test tasks
- Try all test tasks on each candidate CMS demo
- Migrate everything from the old aufrecht.org
- Get the most recent backup is
- Figure out how to preserve all of the old URLs
I got django-cms working on a virtual server in the cloud and decided that picking the absolutely best Django CMS was not worth the time, so that simplified the "Pick CMS" task. Now I need to do some things like get the dev server working on Postgres instead of sqlite, set it up to run automatically on reboot, set up users and permissions, get all of my customizations into source control and rebuild dev from source control. I went to put that into Pivotal and couldn't decide if each of those was a story, or a task within a story, or what.
I want to experiment with deep tree tasks because that's how I tend to think about tasks. Before I can do this, I need to do that. Before I change 200 documents, I need to ...
- back them up
- See if there's an easy way to do search and replace in whatever tool I am using
- If not, see if there is a better tool I can get
- Get Microsoft Office to stop crashing every three minutes
- Get auto-save working every 2 minutes
- Eat something
- Cook something
- Clean the kitchen
- Empty the sink
- Empty the dishwasher
- Run the dishwasher
- Buy more dishwashing soap
- Go to the store
- Take the dog on a walk to the store
- Refill the poop bag holder
- Go to the pet store to buy more poop bags
- Take the dog on a walk to the pet food store
- Refill the poop b—wait a minute...
To deal with this, you can figure out how long each branch might take and do some cost-benefit thinking. Of course, that takes time, so you have to think about how much time to spend thinking about how much time to spend. And that goes off into its own infinite recursion, so some amount of guessing and satisficing is essential.
Assuming all that's sorted out, I'm interested in tracking and reporting on this recursive breakdown. If a task is estimated at "big" or "8 points" or "2 hrs", and then gets broken into three other tasks, some of which are broken out further, can you learn anything by comparing the original estimated time for the parent task with the total actual time of the child tasks? Should the sub-tasks be estimated independently?
So I guess my requirements for my task tracking tool now include:
- It stores an ordered list of my tasks
- I can break a task down into sub-tasks and retain their relation to the parent task.
- The tool integrates with Toggl, so that I can pick a task from the tool and then track my time with Toggl.