Project planning, old school

Ukulele to be.

I ran into a mental block while I was building the first ukulele and in response, broke out a pet theory about project planning that I think is worth expanding on.

The Basic premise is that you have a list of things to do, but that’s very two dimensional, and not great for reordering things. The real problem is that almost all things you have to do are probably blocked by some other thing. The real trick is to filter all the things you have to do to find all the things that are not actually blocked by anything.

The normal process is to make a project board for the thing you want to achieve. Then make the simple list of things that you need to do to achieve that goal. The problem I run into a lot is I shorthand some of the steps when I think of them. Then, when I get to that thing, that one step becomes overwhelming and the whole process falls off the rails. The solution is to have hierarchical to-do lists. Every time you run into a problem spot, you convert that single thing into a list of smaller, digestible steps. The important part is not to fold those new things into the original list. One of the additional plusses to this is that it helps identify things that you can do in parallel. Every time the process tree branches, you can skip around the process a bit. The important part of the process is to be able to identify the true todo list of things that you actually can do. Essentially you are trying to make a list of all the furthest leafs of the process “tree”.

To perform this process as I suggest it, you need a stack of small index cards and pushpins or a stack of post-its, and a large pin board. Magnets on a metal board would be ideal for rearranging things, but probably prohibitively expensive. I recommend using the index cards and push-pins as it is much easier to add strings or rubber bands to make the connections that tie the whole project together. Homosote is a paper product I use for other things, and it comes in 4’x8′ sheets that takes pushpins and paint very well. If you insist on doing this in the land of software, mind mapping software does a pretty good job of arranging the tree. For that matter, so does project management software, but we’re going for the big simple process here. but if you insist, you can think of this whole things as building a Gantt chart from the bottom up… or rather from the end, backwards. The screenshots here were done with Scapple from the makers of Scrivener. Pretty much any mind node or mind mapping software should be able to do it, but the really important thing is to be able to focus on the fringes of the graph, not the trunks.

It’s best to start with a simple overview of the project in question. In the case of the ukulele project that breaks down to:

  1. make body
  2. make neck
  3. attach the neck to the body
  4. finish it (stain or paint it)
  5. string it
  6. play it

But even a cursory look at that list will show that there’s a lot missing there. Do I have all the tools, do I have the materials, are there any other steps between assembly and stringing that should be in there? But at least we can start to lay it out on the board. The following assumes you read left to right, or at least conceive of the passage of time that way. feel free to adapt as you desire.

The Goal

Write the goal on one index card, in this case, “Play it” is the end goal here.

The Steps

Obviously, before you can play a ukulele it has to have strings. before that, you have to have mounted a bridge for the strings to attach to, before that you need to attach the neck to the body, before that you have to have a body and a neck to attach to each other. Given that order of things, you should be able to assemble a fairly simple list, like the following.

a simple list of steps.
a sadly idealized view of the steps required.

There is, obviously, a lot missing here. first off, you can’t mount a bridge that doesn’t exist, but the important thing to realize here is that there are only two nodes with no upstream branches, which means your Todo list is not the whole set of items, but only those two nodes, “make body” and “make neck”… if we add the “make bridge” node, there will be three unblocked nodes. like so:

forgot something…

Now, can you just sit down and ‘make a ukulele body’? probably not. if you’ve done it enough times, it may eventually become second nature, but still there are identifiable steps that this can be broken down to. Same for the neck, (and for that matter the bridge, (or I suppose ‘saddle’ or ‘saddle assembly’ might be more a accurate name)) So the next step would be to figure out what you have to do to create those subassemblies.

almost there

Now you have a map of all the major steps involved in making the ukulele, all you have to do is decide which of these steps you’re going to do first and that’s fairly simple, you limit the list to only those cards/items that have no upstream connections. I’ve highlighted those nodes in red here:

only concentrate on these, you see nothing else…

Now, when every you finish one of the available tasks, you cross it off and highlight the next step down the trail.

woo-hoo!

If, at any point, you run into a single task that you realize has an actual blocking dependency, you simply add nodes to the right that block it and those new things are the new todo list, and that particular node falls off of it until you finish those dependencies.

The most important part of this whole process is learning how to ignore the bulk of the graph most of the time. you should only see the unobstructed nodes. If a node becomes obstructed, replace it with the obstructions and ignore it until you have x-ed out those obstructions. The advantage of looking at a project like this, breaking it down to this level, means that you can do any of the exposed nodes in any order. because there is no step or process that is blocking you from any one of those things. In a way, the objective is to chart out the project ‘tree’ far enough that the only things you can actually set to do are all low hanging fruit.

The additional feature of building out a project structure like this is that if it is for a manufactured item, (which in this case it is) you can find the points in the graph where you can parallelize the process. In this last rendition of the graph, you can see I’ve highlighted some of the nodes in green. each one of those is an independent process. You could, for example just do the “make body” section of the process over and over until you have a bunch of them.

now we’re cooking…

I find that the biggest hurdle in getting moving in any project is simply getting stuck at one point in the process where there is more to do than you thought there was, and you get overwhelmed. If you look back through this very site, you can find a bunch of instances where a project has gone off the rails, sometimes for years, because I got mind locked by the enormity of the process in front of me. Working out this process is indeed one of the things I’m using to procrastinate from some of the larger projects I have going. (cough, boat, cough) … I have a pretty good idea of how to turn this into a software project, but as it is, I have too many things going on as it is. and I like the idea of a “BIG BOARD” but then I think I’m becoming more and more antiquated as I get older. On the other hand, really large projects may require more wall than I’m willing to sacrifice to hanging things that are not art. 😉

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s