Wednesday, May 14, 2014

More on recursion and work breakdown, or, how do you get to the dog store to get more poop bags if you run out of poop bags?

tl;dr:I've been experimenting with Pivotal Tracker as I work on rebuilding my personal website, but it doesn't handle recursive work breakdown well enough and I'm going to move on to the next task tracking tool. 

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
    - Get the most recent backup is
    - Figure out how to preserve all of the old URLs
    - etc 

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 bwait a minute...
So obviously one risk of this approach is that you can get trapped in a loop and never get up.  Or you can wander off and never come close to dealing with the original task.

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.
I have a lot of options.

Trello says that it's "infinitely flexible" so I guess I'll try that next.

No comments :

Post a Comment