I have multiple things going on always at the same time (lecturing, freelancing, open-source projects…). Managing so many types of work becomes daunting quite easily. I’ve always felt unconfortable with the feeling of time-wasting that comes with it. One solution, sometimes the best one, is to focus on one project and finish it, then go for the next one. But this isn’t always possible. So I devised a strategy to handle multiple simultaneous tasks, for when it becomes unavoidable and too complex to handle without a method.
First, lets give a generic name to encompass the concept of projects, jobs, tasks and responsibilities. I’ll call them threads, a computer engineering metaphor, in absence of a better word (you might suggest a better one, English is not my first language).
My methodology consist on 1) classifying threads by a particular logic and 2) running them through an algorithm.
1. Thread classification
The first step is to classify the threads. This three types work well for me, and they describe the kind of treatment regarding time that they require.
- Fixed-time work: this includes part-time work, activities that you do weekly in a predictable way, like lectures, or even any training that you are taking seriously.
- Time-chunks work: this refers to work that requires chunks of time that you need to allocate as a pack, but don’t necessarily need to be placed at predictable times or repeated over time. For instance, I include in this group any freelancing gigs, billed by the hour or by project. You need to work a certain amount of hours, but you can choose when to do it.
- Task-driven work: work that is divisible or consists of well-defined tasks of reasonable size, never lasting more than half my average daily working time, and produce meaningful progress. Task-driven work refers also to administrative tasks and support tasks. Here is where I place my open-source projects and personal learning, since they aren’t constrained by external factors.
Then comes the algorithm. You can build different algorithms from these three types of threads, but this is how I do it:
- Fixed-time work runs in its allocated time no matter what, and any other threads simply get pushed away. If there are any prioritary tasks or chunks of time affected, they get the next available time. This is a real-time critical process.
- Then I allocate X contiguous hours of time-chunks-based work, which generally involves freelancing or projects with deadlines. They have a high cost of context switching. These are system threads.
- Then I start working on my tasks, using a list with an estimation of task size (I use Pivotal Tracker for this). They fill the rest of the time. I can shuffle them to better acommodate any disruption in the system. These is like a thread pool of threads taking jobs as they come, and can be preempted.
Following these three steps I manage to know in advance how to deal with each kind of thread, so I don’t waste time re-organizing the whole schedule. That is a big deal.
I’ll keep refining the method and post updates here. Do you have any suggestions?