Is there an ideal personal task planner? Develop a modular scheduler

Some time ago, as an active user of personal task planners, I discovered one significant drawback - despite their uncountable number, it is impossible to find the “one” that would satisfy you on all points.

No, this in itself is absolutely normal, as the program was developed by one or several developers who eventually came to their own understanding of “how the user will be better”. And besides, it is impossible in one program to fit everything that a spherical user in a vacuum could theoretically want. Or maybe?

Why 2 functions in 1 application are better than 1 function in 1 application

Let's drop for a moment all the limitations and imagine that the ideal scheduler exists: it fully meets your expectations in terms of the interface, provides all the functions you need and works on all your devices. What does this give us? A key feature of this application will be the ability to use the same data to ensure the operation of all functions of the application.

We will simulate a situation - there are two users who cannot live without drawing up a list of tasks and using the Pomdoro equipment. Both have the same needs - the only difference is what applications they use to meet them:

• User # 1 uses 2 popular applications: Todoist (to-do list) and Productivity Challenge Timer (Pomodoro)
• User # 2 uses our hypothetical “ideal” application.

A few words about how the user interacts with the program in both cases:

• User # 1: populates the Todoist task list, populates the list of projects in the Productivity Challenge Timer
• User # 2: fills out the task list inside his program

')

Based on the above illustration, you can identify some of the unpleasant moments that user # 1 will have to face, unlike user # 2:

• The need to manually synchronize the list of projects in both applications
• The inability to run Pomodoro cycles for the subtasks included in the project
• The lack of unified statistics on the implementation of tasks - it is stored in different applications

If this does not bother you, and you think that you can get by with several applications, then imagine what will happen if you need to provide the user with not two, but ten functions?

Solution to the problem

Well, one application in which there are all necessary functions is better, than several applications. But you can not develop a separate program for all combinations of functions! Everything turns out well, if not to use ... and why I break the comedy, the title says ... a modular approach!

The main secret of the "ideal" application is that you should not try to "predict" what the user wants there, but allow him to assemble his own "personal" application, which will meet his wishes and needs as fully as possible. The process of assembling such an application will be to select the desired functions of the application and aspects of the user interface, which will be represented by the corresponding modules.

In addition, it is obvious that if you correctly organize the process of developing such an application, then the overall complexity will be significantly reduced, since the implemented functions will not disappear anywhere - they are only “packed” into modules that are convenient for use by other developers.

This is not only theory

So that this article does not look like nonsense from a developer who has lost his mind on his theory, I would like to show how this all works on the example of my project. I will not describe it in this article for the time being - now I will only describe the idea itself. In general, there is a certain application X - at the moment it is possible to connect new modules to the system, where each module can significantly change the interface and expand the available functions of the application.

Here is the situation as in the example above, when the to-do list module is extended by the Pomodoro module:

At the moment, the application is under development, and is not ready to provide access to users. There is still a lot to do, but something is already there - for example, a list of the working functions of the application:

1. Task list - tasks have the following properties: name, date, performed by Pomodoro, sketch
2. Technique Pomodoro - run cycles Pomodoro for tasks from the task list
3. Custom sketches - create sketches for saving in a separate gallery or linking to tasks from the task list

Each of the described functions is represented by a group of modules, each of which can be removed without affecting the performance of the entire system — removing the module will only exclude the corresponding function from the system for which it was responsible.

Perspectives

At the end of the article I would like to share with you my concepts for the further development and use of this project.

In this article, I did not consider the features of the implementation, so as not to overload the text with details. I will certainly cover the development process itself, but in the next article. If someone is interested, you can familiarize yourself with the already implemented modules:

The source code can be found at the link .

Thanks for attention.