jmglov's blog
A blog about stuff but also things.
A blog about stuff but also things.
In the spirit of doing the most important thing first, I started my "workday" (I'm on vacation for one more week, but I have non-recreational things that I want to do, which I define as "work" relative to the other stuff I'm doing) by creating a Github repo for this writing project I'm working on with Ray. I've typically used Google Docs for this sort of thing in the past, so I'm interested to see how a git-based model will work.
What I'd like to talk about today, however, is how I decided that creating a repo was the most important thing I wanted to do today. Let's start by stipulating a few things:
Given these constraints, how do I decide how to prioritise these things?
Remember, we're not talking here about how to do the things or even in which order to do the things (though I've established my position on the order: do the most important thing first), but just to decide the relative priority of these things.
Most of the time, we tend to take a rather haphazard approach to prioritising things, at least in an individual context. Software teams usually have a somewhat more formal method, though I would argue that these formal methods are often just a haphazard approach in disguise. 😉 In this post, I'm explicitly focusing solely on prioritising tasks that have no external dependencies (meaning that you can't be blocked by waiting for something outside of your control to happen before you can make progress on the task) and where you have total freedom to decide on the priority.
Let's look at a few different frameworks for approaching this, using the following list of tasks as an example:
One of the easiest to understand frameworks is the so-called Eisenhower Matrix (also known as the Urgent-Important Matrix). The idea is that any given task can be either important or not, and either urgent or not, so you can draw a matrix with four quadrants like so:
The Eisenhower Matrix is designed to combat the "mere urgency effect", which, according to the paper which named the phenomenon (written by Meng Zhu, an associate professor of marketing at the Johns Hopkins business school):
can lead people to work on an unimportant chore instead of a more essential one. They do so, not because they have a logical reason—such as judging the task easier to complete, wanting an immediate reward, or planning to get the chore done before moving on to the more important job—but simply because they feel they must beat an illusionary urgency (even when the task's duration is shorter than the deadline provided).
In order to use this method, the first thing I do is classify each of my tasks as important or not and urgent or not:
Putting that into the matrix, it looks like this:
And finally, I use the matrix to decide what to do with each task. According to the framework, I should do the tasks that are in the urgent and important quadrant, schedule the tasks that are in the important but not urgent quadrant, delegate the tasks that are in the urgent but not important quadrant, and ignore the tasks that are neither important nor urgent (these quadrants are usually labelled do, schedule, delegate, and delete, but I'm not using any fancy software to manage these tasks, so deletion doesn't really make sense, and the word "ignore" just gives me a feeling of superiority over these damned tasks which are not the boss of me!).
Based on this, I decided to create the Github repo (already done!) and write this blog post (in progress as I type this but done by the time you read it) before I turned my attention to any of the other stuff. I arbitrarily decided that I'd create the repo first because I figured it would take at most five minutes to do and fill me with a sense of accomplishment which would power my blogging.
According to the framework, I should schedule the tasks that are important but not urgent, so I'll decide to do them "later" (either after I finish the urgent and important stuff or tomorrow if I run out of time today). I should delegate the urgent but not important tasks, which in my case means asking my son to do them. Actually, emptying the dishwasher is already one of the chores that he's supposed to do in exchange for his monthly allowance, so if he does that, I can reload the dishwasher in five or 10 minutes. Score! I could try and make a deal with him for the vacuuming, but I'm not sure if he'll have time, so I might end up having to do that one myself.
Finally, the tasks that are not urgent and not important can be ignored. I know that the humidor task will eventually become urgent when the humidity drops below 65%, but that probably won't be for a few weeks, and I'll notice the needle entering the grey at some point, so I can rest comfortably. As for the looking into hellofresh, meh.
So the Eisenhower Matrix has resulted in a reasonable plan for the day. Let's take a look at one other framework before I run out of fuel and need to go eat lunch.
This is another 2x2 matrix, but instead of the quadrants being defined by importance and urgency, they're defined by impact and effort:
Let's do the impact / effort analysis on my task list:
Putting that into the matrix, it looks like this:
According to the framework, I should focus on high impact, low effort tasks ("quick wins") as much as I can; consider when / whether to do the high impact, high effort tasks ("major projects"); drop or delegate low impact, low effort tasks ("fill-ins") or work on them if and when you have time; and try to avoid low impact, high effort tasks ("thankless tasks"). If I took this approach, my day would look like this:
So my Eisenhower plan looks like this:
And my Action Priority Matrix (APM) plan looks like this:
These plans both point to creating the repo first and then writing the blog post, but then deviate a bit from there. Here's what action I should take on each task according to the two frameworks looks like:
These frameworks yield slightly different results, and in fact they are intended for slightly different contexts. According to the mondayblog, the Eisenhower matrix is most useful for daily tasks (yay!), decision-making, and activities with deadlines and the Action Priority Matrix is most useful for business operations, product features, and large initiatives (oops!).
The Eisenhower matrix yielded what I consider a pretty reasonable plan for the day, and one which I intend to implement. In fact, I've already done the first task, and almost finished the second. I'm going to eat lunch now, after which I'll suck it up and vacuum, and then if there's time left, I'll open the voting envelope and then possibly try to finish up the quickblog work. I'll happily ignore the other two tasks on the list, whatever they were. 😉
I was almost certainly misusing the Action Priority Matrix, but it's interesting that it pointed to the same two tasks to do first, and I learned about a new approach to prioritising that I hadn't heard of before. I actually found it when I was searching for another framework that my previous boss told me about, but which I only apparently bookmarked in my work account or Slack or something, and since I don't work there anymore, I can't access that, and can't really remember enough about the framework to guess at what it's called (it was something like writing down the stuff you have to do, the stuff you want to do, and ???).
Anyway, off to my peanut butter and jelly sandwich now, ktnxbye.