The time is limited for every person. Per 1 hour the employee can do a limited amount of work which leads to a limited number of the produced value. And in most situations, the number of tasks is much bigger than available time.
That leads us to the idea that we need to have a plan and prioritisation for task flow: which tasks should be executed during a particular time frame and what should be the order for these tasks. This prioritisation should be based on the idea of optimizing business value outcome over the consumed time.
However, PM or developers are always struggling about giving priorities for the different tasks due to timeline limit, because it’s not always clear enough which task is more valuable and why. The simple table below should help to solve this problem:
Here, you can see the types of tasks and the groups of people which the resolution of this task is affected. On the crossing of rows and columns, you are seeing the number of points which represent this task.
I.e. if solving the technical bug will bring happiness for 1 person, it will give us 5 points, or if the new business-related solution was required for 1 team, its 30 points.
If you have a basic ETA in hours for the task, you can easily calculate the priority grade for the task, multiplying the number of hours by the number of points in the table:
I.e. if solving the technical bug will bring happiness for 1 person which will take 10 hours to resolve will give us the value of 1×10 = 10, and if the implementation for the new business-related solution for 1 team will take 0.5 hours, that will give 30 x 0.5 = 15 points, etc..
The resulting order is based on a basic principle: the task should be ordered by its points – the less is the number of points, the higher priority this task should get. The particular bond could be different, but as an example, this one can be used: for 0-49 is the top priority, 50-500 is the average priority, and > 500 points tasks will get the low priority
Business idea for this gradation is to speed up the value outcome per hour. As the bigger amount of people which are requiring the resolution for this task, and the lower effort it takes to resolve it – the bigger is the priority for the task.
For processing reference information using pandas
tables, in most cases, it is impossible to do without implementation of
elements hierarchy (groups, subgroups, sub-elements).
There are two approaches for implementation of
hierarchy in the tables: 1. Building n-tier indexes by means of pandas itself
(in newer versions) and 2. Building a text string, where a single string
composed of pointers to groups separated by a special character, specifies a
full path to the item. The following describes a third approach that takes a
bit from the first and second approaches, and has its weaknesses and strengths,
and in certain cases may be the only variant to be used:
1. Each element of the dictionary is assigned its own ID
code generated according to a pre-agreed format. This ID contains coordinates
of the element in the hierarchy.
2. The ID format looks like an integer in the form of
XXXYYYZZZ. With that, the lower level records (elements) take three junior
classes — ZZZ (000-999), subgroups take three medium classes — YYY
(000000-999000), top-level groups take three senior classes — XXX
Examples of interpretation:
an element with ID 10013098 has coordinates: element id — 098, subgroup id — 013, id — 010
an element with ID 100 has coordinates: element id — 100, subgroup id — 000, id — 000
an element with ID 9900000 has coordinates: element id — 000, subgroup id — 900, id — 009
3. At the same time, this approach means that one
should know in advance the maximum depth of the tree and fix the maximum number
of elements in the tree. Accordingly, the maximum depth is the number of
classes and the maximum number of elements – the number of orders in the group.
Thus, the composition and codes size ratio may vary (may
be XYZ, XXYYZZ, XXXXYYYYZZZZ, … etc.), but the format should be uniform and
to be chosen once, during tree markup
Thus, this approach is applicable only in the case when
the hierarchy is not rebuilt dynamically online, but there is some time for relabeling.
With that, if ID assignment to the elements and groups
is implemented in the specified logics, further tree navigation and selection
of items will be performed as quickly as possible, because only the basic
low-level filters and basic integer arithmetics are used, without slow
searching for values in the substring and re-indexations.
1. To select all elements in the group, for an incoming
group ID it is sufficient to select all elements with IDs from XXXYYY000 to
Example (for the XXYYZZ format):
For group 20500, IDs of all child elements will be in
the range between 20500 and 20599
For group 130000, IDs of all child elements will be in
the range between 130000 and 130099
2. To select all low-level subcategories by the ID of
the top level group, just select all elements with ID from XXX000000 to
XXX9999999, with the additional condition that the ID is evenly divisible by
the group size, i.e. 1000 (this is a definite sign of a group)
Examples (for the XXYYZZ format):
For group 20000, IDs of all child subgroups will be in
the range between 20000 and 29900 (group size = 100)
3. Select all the elements in the top-level hierarchy
for all child subgroups, but without subgroups themselves: XXX000000 –
XXX999999 by subtracting the ID which are evenly divisible by the group size
Example (for the XXYYZZ format):
For group 20000, IDs of all child elements of all
sub-groups without subgroups themselves will be in the range between 29999 and
29999 (group size = 100), excluding the elements with IDs 20000, 20100, 20200,
… , 29900