We created a basic task management system, which includes functionality to sync across devices, and auto-generate a daily "to-do" list from existing tasks (based on a number of user set parameters). This was a good oportunity to see how functional programming might work in an application setting, rather than simply as a quick fetch script. The addition of an auto-generated todo list is also something we have no found in other individual task management/todo list software (Todoist, Wunderlist, etc), and we found a good way to implement it. We learned how scheme and functional programming might be applied in a formal application, rather than just as a simple script.
We used data abstraction, object-orientation and state modification in the implementation of task objects. These objects store information like time, location, date, and tags that can be modified, displayed and shared by other parts of the program. We used filter to select a subset of all tasks to display and map to transform the task data objects to objects that can be used by the gui. We will use iterative recursion to perform operations on each element of a list of tasks.
This program is able to connect with a server and sync tasks between the device and server. It uses JSON to pass the data between the server and client.
At completion we are able to display a schedule and add/remove tasks from it. We will also be able to filter based on tags or task types and set priorities for tasks.
This program stores and displays user inputted data. We can show it working by adding, removing or modifying data through the program.
We divided our goals for this program into core objectives and stretch goals.
Basic Task management system
- task object
- priority
- deadline
- expected duration (total)
- expected time remaining
- tags
- basic interface (GUI/REPL)
- auto-gen daily TODO list
- server for cross device syncing
- better features for multi-user systems
- group tasks
- shared task ownership
- some way to check status of other people's tasks
- some way to set someone else's task as 'blocking' one of your tasks
- create/assign tasks for other people
- sub tasks
- ordered and unordered
- group tasks
- daily to-do options
- based on day of the week
- skip a task for today and get a new one
- get tasks from different 'categories' on different days (i.e. don't get work tasks on the weekend)
- additional task options
- put a task on hold (set period of time or indefinitely)
- time slice options (good for large tasks)
- ongoing tasks with no real time estimate
- only one sub-task per day option
- automatically increase priority of tasks that are due soon or overdue
- some options/hardcoded control on maximum amount to increase by
- 'flexible' option that gives a date range instead of a single due date
- reminders
- GUI
We have completed all of the core objectives outlined here, and a few of the stretch objectives, including a GUI.
This diagram has two major parts: the client and the server. The data is moved between these components using JSON as shown.
Within each part, we handle the data as needed for whatever it will be used for. On the client side we have user input coming through the ui and being stored as data and sorting and filtering the data for display to the user.
On the client side we will be moving between the client interface data, which will be represented using JSON, to the internal represention of the data in the program.
Basic task objects can be fetched from the server, and basic interactions (view, add, delete, edit, sync) can be done through the REPL.
Server side application will be able to store basic task objects and send them to client.
Can generate a "today's tasks" list, and have some simple customizations for it (Hours of work for the day, etc)
Full basic server functionality will be implemented.
Very basic GUI to view tasks.
Application will be functional and server stretch goals may be implemented.
I was responsible for all baseline client code, including the task objects, all sorting, filtering, and interaction functionality, and the GUI.
Will write the server side program and networking.