How can I prevent switching constantly from one task to another?

Question

I want to try Evidence-Based Scheduling so I've broken everything into small tasks. This process was interesting since I've detected some tasks that wasn't immediately evident and forced me to design the damn thing.

I've noticed that as I'm working on a given task, I'm sometimes switching to another task for a couple of minutes. I'm starting to think that my tasks may be too small (some are less than an hour) and/or too closely related to each other.

So, is there a way that I can prevent this constant switching between tasks?

EDIT Here's a example :

1. Create Home Page
    1.1 Load content from database
    1.2 Build the layout
    1.3 Create a custom widget

So create home page is a task that I've broken down into smaller tasks. Now, if I start working on loading the content from the database, I'll probably stop before finishing the task, since I have no place to put the data. So I'll switch to building the layout. Again, I will not be able to complete this task because I need to create the widget that will go in the page. So technically, I should've started with creating the widget, then the layout, then loading the content. But sometimes, it's not that clear.

Answer 1

Disclaimer: This is purely my opinion, and what works for me may not work for others.

---

1. I've noticed that as I'm working on a given task, I'm sometimes switching to another task for a couple of minutes.

2. I'm starting to think that my tasks may be too small (some are less than an hour) and/or too closely related to each other.

These two sentences point to one thing, which may (or may not) be your problem. You are dividing your tasks too much. By too much, I mean that tasks should be divided in a way that you are able to work on a single task without any needless switching, and starting the tasks in proper order.

For example, consider this: As part of your project, you have to get the contents of some remote file and parse them. Now if you have envisioned two different tasks for it and you are working first on the parsing part, you will not be able to do so until and you know what format the file would be in, and what you need from it etc. I would normally keep this as a single task, but if you would make two tasks of it, approach them in the order. It is a vague example, but I hope you get the point.

Maybe you need to focus on a single task at a time. When you have divided some project into different parts, and made sure (i.e. checked to the best of your ability) that these are correct, then (I think) you should just work on one task at a time, and shift the big picture to the background. That is what we have task scheduling of any kind for.

You know, any or all scheduling/task management that we do is not perfect. Especially so if we have just started doing it. With time you will get better with it. (And I hope the same for myself :p)

Answer 2

I believe your switching from one task to another can cause because of any of following reasons.

1. First you have not identified the dependency between the tasks.
2. You cannot visualize the tasks (in to-do list)

I believe it is better to have a way to visualize the tasks of your to-do list. Try using KANBAN board (Electronic or just a white board)

Main concept behind KANBAN is to limit the work in progress.

I hope a KANBAN board with four columns as shown below will help you:

1. To Do    
2. In Progress  
3. Blocked  
4. Done

To Do

You can have all the tasks in your to-do list here.

In Progress

Decide which task you are going to start and put it here and start working on it.

You have to limit Number of tasks in this column (May be one at a time) and stick only to have decided number of tasks in this column at any given time.

Therefore you will be working only on one task at a time

Blocked

If you are blocked due to some other dependent task or any requirement clarifications just put the task here and continue with some other task.

Finish the second task and if the BLOCKED task is sorted out then you can continue with previous task again and complete.

Done

When you are done with any task in the list, put it in this column.

This way you don’t have to switch between tasks constantly. You will be switching between tasks only when one task is BLOCKED or DONE. 

This way you can visualize your work and your progress on that.

Note:

Prioritizing your tasks will help you to decide the order of the tasks that you have to pick.

When your task is block just remember to put a note why the task is blocked. (It will help you to track them when you have more than one tasks in this column)

Answer 3

I've broken everything into small tasks

Divide and conquer approach is useful, but could be harmful as in your case. My personal approach is to divide and conquer may be a technique for design but design does not end there. You need to create components where each component contains highly dependent artifacts. These components are not necessarily OO components, instead they are Project Management components where each can be assigned to a group of 1 to 3 people.

All components would share some artifacts such as a database design, so such dependencies need to be sorted out upfront. By following similar approach one can focus on producing a given deliverable without having to jump very frequently across tasks.

Your remark

I'm starting to think that my tasks may be too small

Is very valid. You project implementation plan should assign tasks in such a way that allows you work sequentially within a given assignment from start to end and in parallel from a team view.

EDIT: After the following example was provided...

1. Create Home Page

   1.1 Load content from database

   1.2 Build the layout

   1.3 Create a custom widget

The sequence of the tasks should be (of course this is an example only) - I have added some extra tasks to clarify my point.

1. Create Home Page

   1.1 Build the layout (this is the design step)

   1.1.1 Confirm user acceptance

   1.2 Create the custom widget

   1.2.1 Test custom widget

   1.3 Write code to load data from database and display it

   1.3.1 Test the page load

Now, you can go sequentially in the tasks provided that each high level task is fully completed before you proceed with the next.

Answer 4

I might be completely wrong, but maybe you are "hanging in the air" too long, working on quite abstract code, and you don't know if it really works. It's hard to say what to do without knowing the details, but if my assumption is correct, these things come in mind to get you "back to the ground":

• write tests
• write spike solutions
• write some example code

Answer 5

Have you tried the Pomodoro approach? The idea is to help you keep 100% focused on a single task at a time.

Answer 6

For me, tracing a plan has been more helpful than dividing in tasks. Maybe because plans are more general than task divisions.

Real example:

Create Blog-engine:

1. Research
2. Design Database
3. Program basic PHP interface to the database

4. Generate some basic blog ( something browsable )

   Here I would spend some time iterating 2,3,4

5. Make the blog look pretty

Answer 7

Rather than too small, I would argue that the tasks may be too big (ie, high-level). If they were smaller and more specific, than the workflow jams would be easier to see. For example, if you had a step 1.1.c that read "update widget to call database wrapper", you'd be writing that out and realize "Widget? What widget? Oops, I'll need to create that before I can plug it into the database."