[Planner Dev] Resource leveling

[Daniele Levorato <daniele levorato infocamere it>]

Hi All!
I'm Daniele and I'm a newbie in Planner, but I've used other planning
tools and I know the concepts...
First of all I'm really interested in Planner... since it was called
"MrProject" some time ago...
I want to share with you my opinion about an interesting feature,
essential for a good planning tool, in my opinion. I know, it's a long
mail so I would really appreciate if you are so patient to read it and
tell me what you think...

Sorry if you find some points obvious, and perhaps some of them have
already been spotlighted in the past, I'm sure, but I've just joined the
mail-list, I don't know about previous discussions and this is my first
mail (be kind please :-) )
... so, let's go (p.s. sorry for my English too)

Today I've started using Planner seriously at work and I found really
interesting the last added "Resource Usage" view since now you can
monitor resource over-load and try to correct them.
So I started creating my project WBS and introducing dependencies
between tasks obtaining the Gantt. However this is the simple part...
now I have to assign resources to various tasks.
The problem is: how do I level all resources properly?
It's important to level resources or Planner will never give me a
correct time table and so a project-end forecast (and I really need
it!).
I know that Planner can't do automatic leveling, but it would be usefull
to have a way to level resources, even manually... 
... I'll try to explain...
Imagine two parallel task say both of 5 work days....

task 1    ---|=|=|=|=|=|--- Bob [100]
task 2    ---|=|=|=|=|=|--- Bob [100]

If "Bob" was assigned to both it would have 200% of work time which is
not acceptable. In this circumstances I (the PM) can say that Bob can
first do the first task and then the second, if I don't care about task
completion date and I believe that Bob can't do these two task at the
same time...

task 1    ---|=|=|=|=|=|--- Bob [100]
task 2    -------------|=|=|=|=|=|--- Bob [100]

But in this way I will introduce an improper "task 2" predecessor: there
should be no dependency between the two tasks. The link is introduced
not due to a logical dependency but to be able to level resources and
this is not good. If assignments change (let say that Tim enter the team
and is assigned to task 2) I'll have to remember that there's no link
between task 1 and 2 so now they can be done in parallel. Perhaps if
Planner let you declare that the dependency is due to a resource
leveling (Bob leveling) then it would be possible for Planner to
automatically remove it when Bob is no longer used in task 1. 

task 1    ---|=|=|=|=|=|--- Bob [100]
task 2    ---|=|=|=|=|=|--- Tim [100]

Another possibility is to change the percentage of Bob's work in the two
tasks: say 50%. So in both cases Bob will be allocated "only" 100% and
Planner will give me the correct project time-schedule.

task 1    ---|=|=|=|=|=|=|=|=|=|=|--- Bob [50]
task 2    ---|=|=|=|=|=|=|=|=|=|=|--- Bob [50]

But in this way (well even in the other situation) the tasks are
"stretched" and another "overload" with a third task could occur...
doing all these considerations "manually" is hard...
However even if Planner is not able realize a plan strategy by it's own,
I can manage the situation (and in my opinion no algorithm can be
provided for that, only the PM should do manually such decision).

But this is a lucky situation! Imagine instead task 1 with 8 days and
task 2 with 5 days:

task 1    ---|=|=|=|=|=|=|=|=|--- Bob [100]
task 2    ---|=|=|=|=|=|--------- Bob [100]

Now adding the "dirty" dependency is again possible (but not desirable
in many situation, the gantt becomes unreadable) while it is not
convenient to decrease the percentage of work, for example:

task 1    ---|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|=|--- Bob [50]
task 2    ---|=|=|=|=|=|=|=|=|=|=|--------------- Bob [50]

Bob is not over-loaded but he won't work at his best since the
percentages are:

Bob Work  ---|     100%          |    50%    |---

While, in the real world it should be:

task 1    ---|=|=|=|=|=|=|=|=|=|=|=|=|=|----- Bob [50|100]
Bob Work 1---|     50%           | 100%|-----
task 2    ---|=|=|=|=|=|=|=|=|=|=|----------- Bob [50]
Bob Work 2---|     50%           |-----------
Bob Work  ---|     100%          | 100%|---

In fact, working at 50%, task 2 would be finished after 10 days (5 work
days), meanwhile task 2 have been worked at 50% too for 10 days. Since
again they are 5 work days (and task 2 requires a total of 8 works
days), 3 days remain to be performed. Since Bob now can work at 100%
(task 2 is finished) in 3 days Bob will finish even task 1.
This is the correct, optimized time/resource scheduling.
Note that, correctly, from the work viewpoint it's the same of
performing first task 1 and then task 2 (work like energy should be
constant) so 13 days in total, but from single-task-end viewpoint the
two end dates are different.
This solution is acceptable and fits reality (in my opinion) but Planner
don't let you "split" a task in two work-session to define separately
the percentage.
In my opinion this "split" should be implemented (like in MS Project for
example) since will let the user a fine-grained way to allocate
resources and so manage the situation.

>From an algorithm viewpoint an "automatic leveling" would also be
possible.
Simply imagine that Planner wants to level Bob (the user asks Planner to
level Bob using a percentage strategy)... So Planner iterates from
projects start date and step over day by day. For each day it analyzes
how many task have been assigned to Bob (ex. 2) then it divide Bob work
capability (100) by the number of task (100/2) calculating the
percentage of work on each task for that day (50%). Even the "priority"
can be considered to realize an asymmetric work percentage split. At
this point Planner consider the day after and its Bob's tasks (again 2)
repeating the same operation. After every elaborated day the work time
for each task is tracked (ex. after the 2nd day Bob should have worked 1
day on task 1 and one on task 2). When all the work for a task has been
considered the task is finished and its end date is known (ex. after the
10th day Bob has been involved in 5 days work on task 2 so all task 2
have been considered... the 11th day there's only task 1 and 100/1 =
100% so Bob will work 100% on task 2 for that period).

You will notice that it works, conceptually...
Perhaps Planner should implement this algorithm targeted on a Resource
(or considering more at once).

Concluding, from a user viewpoint it should be possible to:

1) re-arrange task introducing a "special dependency" (say t2 depends on
t1) linked to a resource, so that "t2 depends on t1" as long as t1 is
assigned to a certain resource (say Bob). This would allow to introduce
"non-logical" dependencies, used to level resources, that are clearly
visible in a special way in the Gannt (to not confuse them with the
"logical" ones) and are automatically dropped when the resource
assignment is no longer applicable (ex. Bob is no longer assigned to
t1).

2) User select one or more resources and one or more (or all) tasks and
applies the "percentage" leveling. The percentage of working capability
of the resource is split on daily-basis, based on task priority and
using a maximum split amount (for ex. Planner knows from Bob
Resource-Information that it can't do more than 3 task in parallel for a
certain day) so all less-priority "exceeding" tasks will be shifted
using the previous method ("non-logical" dependencies) while the others
will be "stretched" using split work percentage.

Well... what do you think about that? would it be difficult to implement
it? but above all would it be useful? In my opinion it's very useful...
even the point 1) alone would be at least useful in certain
circumstances, but the 2) would give more "added value" to resource
planning in Planner.

In Fact in real practice I've faced several circumstances like this:

time   ---------X---Y---------
t1     ---|=|=|=|=|=|=|=|=|--- Bob
t2     ---------|=|=|--------- Bob

Where t2 starts on X-day (due to some deps.) and costs 2 days, and both
have to be performed by Bob.
I can't shift t2 before t1 (due to dependencies) nor t2 after t1 since
imagine that t2 is linked to a chain of tasks in the critical path.
What happens in the real world is that Bob will start t1 and in the
x-day will work on t2, suspending t1, or will work both on t1 and t2, it
depends on Y-day (can be postponed? or is critical? the PM knows) so we
can say that it depends on "priority". So if the priority is the same,
using algorithm 2 we'll have:

time   ---------X-------Y-------------
t1     ---|=|=|=|=|=|=|=|=|=|=|------- Bob
work 1 ---| 100%|   50% | 100%|-------
t2     ---------|=|=|=|=|------------- Bob
work 2 ---------|   50% |-------------
WORK   ---|        100%       |------- Bob

While if t2 priority is much more that t1 priority we can even obtain:

time   ---------X---Y-----------------
t1     ---|=|=|=|---|=|=|=|=|=|--- Bob
work 1 ---| 100 | 0 |   100   |-------
t2     ---------|=|=|------------- Bob
work 2 ---------|100|-------------
WORK   ---|        100%       |------- Bob

And so t1 is split (suspended) to work on t1 in the middle, to respect
its priority and preserve the critical path... in fact Y-day is the same
as in base-line!
I think that this would be great!!! It's not the solution to all
"resources leveling problems" but still works in many circumstances.

Thanks for you attention, and sorry if I've been too long
	Daniele


                                    
________________________________________________________________________
D a n i e l e  L e v o r a t o
InfoCamere S.c.p.A
049/82888681
System Engineer
Direzione Registro Imprese 
Team Middleware