# The Upkeep List

The `Upkeep List` purpose is to hold recurrent (high and low frequency) tasks that need to be done at regular intervals but not at a fixed time and date.

Note

Routine (R) tasks are not kept on the Upkeep List event if they are recurrent. This exception aims at reducing noise and toil in the system.

Because they come back so often and are favored because of their simplicity and fast feedback, high frequency tasks can exhaust all the time and energy available per day, leaving some tasks to starve; they never get done or drift apart between performance to the point of incurring negative consequences.

The Upkeep List address this issue with a scheduling technique called aging where tasks are given priority based on time they have been waiting; their age.

Calculating the age of a task can be done in many ways. In this system the age of a task is calculated relative to its frequency. The frequency at which a task must be done is sometimes given, but most of the time it is estimated and adjusted to settle on the `natural frequency`; this is, the rate at which a task really needs to be done.

As mentioned in the section about task types, when a task needs to be done it is said to be `mature`. The time it takes to mature is the `period`. And the `frequency` of a task; this is, the rate at which it matures, can calculate as follows:

Given a task `t`.

``````frequency(t) = 1 / period(t)
``````

Having the frequency of `t`, the age is calculated as follow:

``````age(t) = (the amount since 't' was last done) * frequency(t)
``````

For short, the age is:

``````age(t) = (the amount since 't' was last done) / period
``````

The age of a task represents the number of cycles since it was done. The task is said to be `mature` when its age is equal or greater than one. When the age is greater than two, it is `overdue`. Ideally, each task should be done when their age is equal or greater than one, but less than two.

## The Algorithm

In the `Upkeep List` the tasks are kept ordered by age in descending order. As a task matures, it moves upward to the top of the list. Each time a task mature, it should be evaluated and its period adjusted before it is done and the last done date updated. Iterating over this procedure is the algorithm of the `Upkeep List`.

``````graph LR
START[Start] --> SELECT;
SELECT[Select mature task] --> TODO{It needs to be done?};
TODO -->|Yes| DOIT[Do it];
TODO -->|No| WAIT(Increase period);
TODO -->|Yes and is overdue| REDUCE(Reduce period);
REDUCE --> DOIT;
WAIT --> SORT;
DOIT --> UPDATE(Update last done date)
UPDATE --> SORT[Sort the list]
SORT --> SELECT;``````

The loop goes like this

2. Evaluate if the task realy need to be done.
3. Update the period of the task.
• If it does not need to be done:
1. increase the period
• If it does need to be done:
1. do not change the period
2. do it
3. update the last done date
• If it should have been done earlier:
1. reduce the period
2. do it
3. update the last done date
4. Sort the list.

## Implementation

The `Upkeep List` is easy to build and manage in a spreadsheet. Using a spreadsheet makes it easy to add, remove and search tasks. But most importantly it allows to use a formula to calculate the age of a task and sort them.

The simplest sreadsheet has four colums: `Done`, `Age`, `Period` and `Task`.

• `Done`: The date when the task was last done.
• `Age`: The formula to calculate the age (e.g.: `DAYS(TODAY(),\$Done)/\$Period`)
• `Period`: The number of days after which the task is repeated.
• `Task`: The description of the task to be done. When a task is done, we update the `Done` column by inserting the current date. In LibreOffice it is as simple as hitting `CTRL+;`. Then you can sort the task by age in descending order.