A MINI PROJECT REPORT

TO-DO LIST

BACHELOR OF COMPUTER SCIENCE

Submitted By
MRITHULA KS
(Reg. No. 2422K0598)

Under the Guidance of

Dr. Kanimozhi, MSc.(CS),M.Phil,PhD.,
DEPARTMENT OF COMPUTER SCIENCE

OCTOBER 2024
CERTIFICATE
 CERTIFICATE

This is to certify that the Mini Project entitled “TO-DO LIST” is the bonafide record of
Mini Project work done by MRITHULA KS, REGISTER No: 2422K0598 of I BSc Computer
Science during the academic year 2024-2025 of her study in the Department of Computer science,
Sri Krishna Adithya College of Arts and Science, Coimbatore.

SIGNATURE OF THE GUIDE

SIGNATURE OF THE HOD PROJECT HEAD

DEAN-RESEARCH SIGNATURE OF THE PRINCIPAL

Submitted for the Mini Project Viva-Voce Examination held on ___________

EXAMINER
DECLARATION
 DECLARATION

I, MRITHULA KS, hereby declare that the Mini Project work, entitled
“TO-DO LIST”, submitted to the Sri Krishna Adithya College of Arts and Science, in partial
fulfilment of the requirements for the award of the Degree of BACHELOR OF COMPUTER
SCIENCE, is a record of original research work done by me during the period 2024-2025. This
Mini Project is the original work carried out by me and it is not a part of any other Mini
Project/Project work.

Place: Coimbatore Signature of the Candidate

Date: ( MRITHULA KS)

ACKNOWLEDGEMENT
 ACKNOWLEDGEMENT
I first and foremost thank the almighty for having bestowed his blessings on me to complete
the mini project.

I am indebted to our beloved Principal Dr.S.Palaniammal.,M.Sc.,M.Phil.,Ph.D., Sri

Krishna Adithya College of Arts and Science, Coimbatore for her support and encouragement.

I wish to express my gratitude to the respected Dr.K.Chitra.,M.Sc.,MBA.,M.Phil.,Ph.D.,

Dean-Research, Sri Krishna Adithya College of Arts and Science, Coimbatore for supporting me
to complete this mini project work.

I deep sense of gratitude to the respected Dr.K.Geetha,MSc.,M.Phil.,Ph.D., Dean of

Computer Science and Dr.D. Shanmuga Priya, MSc.,M.Phil.,M.E.,Ph.D., Head, Department of
Computer Science, Sri Krishna Adithya College of Arts and Science, Coimbatore for their
encouragement and support for the successful completion of this mini project.

I would like to convey my sincere gratitude to Dr.S.Sheeja.,MCA.,M.Phil.,Ph.D.,

Assistant Professor, Department of Computer Science and Project Head, Sri Krishna Adithya
College of Arts and Science, Coimbatore for her encouragement and support for the successful
completion of this mini project.

I thank my project guide Mrs.Kanimozhi.,MSc(CS),M.Phil.PhD, Assistant Professor,

Department of Computer Science, Sri Krishna Adithya College of Arts and Science, Coimbatore
for his/her timely advice and guidelines which assisted me in completing the mini project work
successfully.

My sincere thanks and gratitude to all the faculty members of Department of Computer
Science, Sri Krishna Adithya College of Arts and Science, Coimbatore for their encouragement
and support for the successful completion of this mini project.

My special thanks to my Parents, Friends and Well-wishers for their moral support
throughout the mini project work period.

MRITHULA KS
 TABLE OF CONTENT
Chapter Particulars Page
CERTIFICATE
DECLARATION
ACKNOWLEDGMENT
1. INTRODUCTION
1.1 About the project
2. REVIEW OF LITERATURE
2.1 Existing Systems
2.2 Limitations of existing systems
3. SYSTEM STUDY
3.1 Proposed System
3.2 Advantages
4. SYSTEM ANALYSIS
4.1 Module Description
4.2 Functional Requirements
4.3 Non-functional Requirements
5. SYSTEM DESIGN
5.1 Input Design
5.2 Output Design
6. CONCLUSION
7. 7.1 CODING
7.2 Output
 Introduction
1.1 About the project

• In today’s fast-paced world, staying organized is essential, and one effective way to do
this is by using a to-do list application.

• Developing your own to-do list app can be a rewarding project that not only helps you
manage your tasks but also allows you to enhance your programming skills.

• By keeping such a list, you make sure that your tasks are written down all in one place so
you don’t forget anything important. And by prioritizing tasks, you plan the order in
which you’ll do them, so that you can tell what needs your immediate attention, and what
you can leave until later.

• This app is designed to help you manage your daily tasks and stay organized. With a
user-friendly interface and essential features, you can easily keep track of your to-do lists
and achieve your goals.

1. Increased Productivity: Stay on top of your tasks and achieve more.

2. Reduced Stress: Keep your tasks organized and feel more in control.
3. Improved Time Management: Prioritize tasks and manage your time effectively.
4. Enhanced Focus: By breaking tasks into manageable steps, you can concentrate on one
thing at a time, minimizing distractions.
5. Customizable Features: Tailor your to-do lists to fit your unique needs, from deadlines and
reminders to categories and tags.
6. Progress Tracking: Monitor your accomplishments and celebrate small wins, helping to
motivate you to keep going.
7. Collaboration Options: Share lists with others for group projects or family tasks, making
teamwork more efficient.
8. Accessibility: Access your to-do lists from anywhere, ensuring you always have your tasks
at your fingertips.
• With these features, this app empowers you to take charge of your day, streamline your
workload, and ultimately achieve your personal and professional goals.
 REVIEW OF LITERATURE
2.1 Existing Systems

1. Paper-Based Lists:

• Traditional method using notebooks or sticky notes.

• Pros: Tangible, easy to customize, no technology required.
• Cons: Prone to loss, difficult to reorganize, not easily shareable.

2. Digital Notes Apps:

• Applications like Apple Notes or Google Keep.

• Pros: Accessible across devices, supports multimedia, easy to edit.
• Cons: Limited task management features, less focus on prioritization.

3. Dedicated To-Do List Apps:

• Apps such as Todoist, Microsoft To Do, and Any.do.

• Pros: Robust features like reminders, deadlines, and prioritization; often includes
collaboration tools.
• Cons: May have a learning curve, some features might require a subscription.

4. Project Management Tools:

• Platforms like Trello, Asana, and Notion.

• Pros: Comprehensive task management with team collaboration; great for larger projects.
• Cons: Can be overwhelming for simple to-do lists, requires an account and internet :

5. Calender Application

• Tools like Google Calendar or Outlook.

• Pros: Integrates tasks with schedules, provides reminders, and visual organization.
 • Cons: Primarily focused on time management, which may detract from detailed task
tracking.

2.2 Limitations of Existing Systems

1. Lack of Flexibility: Many to-do list apps are rigid in their structure, making it difficult to
adjust priorities or rearrange tasks quickly.

2. Overcomplication: Some tools offer too many features, leading to confusion and
overwhelm rather than simplicity and ease of use.

3. Poor Integration: Difficulty syncing tasks across various platforms or integrating with
other productivity tools can disrupt workflow.

4. Limited Collaboration: While some apps allow sharing, they may lack robust features for
team collaboration, making joint task management challenging.

5. Ineffective Prioritization: Not all systems allow users to easily categorize or prioritize
tasks, which can lead to a lack of focus on what’s most important.

6. Insufficient Reminders: Many existing tools do not offer customizable reminders, which
can lead to missed deadlines.

7. Accessibility Issues: Some apps require internet access or specific devices, limiting
usability in offline situations.

8. User Experience: Cluttered interfaces or complicated navigation can deter users from
effectively managing their tasks.

9. Focus on Scheduling: Some tools prioritize calendar integration over task management,
which may detract from detailed tracking of individual tasks.
 10. Limited Progress Tracking: Many systems lack features that allow users to track their
progress or visualize accomplishments over time.

SYSTEM STUDY
3.1 Proposed System

Overview
This To-Do List application is designed for managing tasks and setting reminders. It provides a
simple command-line interface for users to add tasks, mark them as completed, display current
tasks, and set reminders.

Functional Requirements

1. Add Task: Users can input a description of a task, which gets stored in an array.

2. Display Tasks: Users can view all tasks with their completion status.

3. Mark Task as Completed: Users can mark a specific task as completed based on its index.

4. Set Reminder: Users can set a reminder for a task, specifying the time in seconds from
the current moment.

5. Check Reminders: The application checks and displays any reminders that have
triggered.

Non-Functional Requirements

1. Usability: The interface is straightforward and easy to navigate.

2. Performance: The app is designed for quick interactions, with task management
operations executed in constant time.
 3. Scalability: The app can handle a maximum of 100 tasks and 100 reminders.

4. Robustness: Basic error handling is implemented to manage invalid inputs and limits on
tasks and reminders.

3.2 Advantages:

1. Task Management:
Users can easily add, view, and manage tasks, helping to keep their responsibilities organized.

2. Reminder Functionality:
The ability to set reminders for specific tasks ensures that users don’t forget important deadlines.

3. User-Friendly Interface:
The command-line interface is straightforward and allows users to navigate options without
complexity.

4. Task Completion Tracking:

Users can mark tasks as completed, providing a clear overview of progress.

5. Flexible Reminder Timing:

Users can set reminders based on custom time intervals, allowing for personalized task
management.

6. Memory Management:
With defined limits for tasks and reminders, the application efficiently manages memory and
prevents overflow.

7. Periodic Reminder Checking:

The app regularly checks for due reminders, ensuring timely notifications without user
intervention.

8. Simplicity and Portability:

Being a console application, it is lightweight and can run on various platforms without heavy
resource requirements.

SYSTEM ANALYSIS
4.1 MODULE DESCRIPTION

1. Data Structures:
• Task: Represents a task with a description and a completion status.
• Reminder: Associates a task with a specific reminder time.

2. Global Variables:
• Arrays to hold tasks and reminders (tasks, reminders) and counters to track the
number of tasks and reminders (numTasks, numReminders).

3. Functions:
• addTask(): Prompts the user to enter a task description and adds it to the task list.
• displayTasks(): Displays all tasks with their completion status.
• markTaskCompleted(): Allows the user to mark a specific task as completed based on
its number.
• setReminder(): Sets a reminder for a specific task by asking for the task number and
the time in seconds until the reminder.
• checkReminders(): Checks for any reminders that are due and displays them. It also
removes reminders once they’ve been shown.

4. Main Loop:
• The main() function contains a loop that continuously displays a menu, allowing
users to interact with the application (add tasks, display them, mark them as
completed, or set reminders) until they choose to exit.

5. User Interaction:
• The program uses standard input to receive user choices and task descriptions,
handling basic error checking for valid task numbers.
Features:

• Task management (adding, displaying, marking completed).

• Reminder system based on user-defined intervals.

• Continuous running with periodic checks for reminders.

4.2 FUNCTIONAL REQUIREMENTS

1. Task Management

Add Task:
• Users can enter a task description.
• Each task should have a completion status (pending/completed).
• A maximum of 100 tasks can be stored.

Display Tasks:
• Users can view all tasks with their status.
• Tasks should be listed with corresponding task numbers.

Mark Task as Completed:

• Users can mark a task as completed using its task number.
• Only valid task numbers should be accepted.

2. Reminder Management
Set Reminder:
• Users can set a reminder for a specific task.
• Users should specify the task number and the reminder time in seconds.
 • A maximum of 100 reminders can be stored.

Check Reminders:
• The application should periodically check for any reminders that are due.
• If a reminder is due, it should notify the user and remove the reminder from
the list.

3. User Interface
• The application should present a menu with the following options:
1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
• User inputs should be handled via standard input (stdin).

4. Error Handling
• The application should handle invalid inputs gracefully, providing error
messages for:
• Exceeding the maximum number of tasks or reminders.
• Invalid task numbers when marking tasks as completed or setting reminders.
• Task descriptions should be limited to 100 characters.

4.3 Non-Functional Requirements

1. Performance
• The application should respond to user inputs promptly, with a
maximum delay of 1 second for reminders.
• The reminder check should not excessively consume CPU resources.

2. Usability
• The user interface should be clear and straightforward.
• Instructions and feedback messages should be easy to understand.
 3. Scalability
• While the current implementation supports a maximum of 100 tasks
and reminders, the code structure should allow for future
enhancements if needed (e.g., increasing limits or adding features).

4.Portability
• The application should compile and run on standard C compilers
across different operating systems (Linux, macOS, Windows with
minimal modifications).

5.Maintainability
• Code should be well-structured and commented to facilitate future
updates and maintenance.
• Functions should be modular to isolate functionality.

5. SYSTEM DESIGN
5.1. Input Design for To-Do List Application

The input design outlines how users will interact with the To-Do List application. This includes
the expected inputs, their formats, and any validation checks that should be implemented to
ensure a smooth user experience.

User Menu Options

Upon starting the application, users will see a menu with the following options:

1. Add Task
2. Display Tasks
3. Mark Task as Completed
4. Set Reminder
5. Exit

Input Details for Each Option

 1. Add Task
• Prompt: “Enter task description: “
• Input Type: Text string (up to 100 characters)

Handling:
• Use fgets to read the input to accommodate spaces.
• Ensure the task count does not exceed MAX_TASKS.

2. Display Tasks
• Input: No additional input is required.
• Functionality: The application will display all currently added tasks along
with their completion status.
3. Mark Task as Completed
• Prompt: “Enter task number to mark as completed:”
• Input Type: Integer (task number)

Handling:
• Validate that the input is a positive integer.
• Ensure the input falls within the range of existing tasks (1 to
numTasks).

4. Set Reminder
Prompts:
1. “Enter task number to set reminder: “
2. “Enter reminder time (seconds from now): “
Handling:
• Validate that the task number is valid (1 to numTasks).
• Ensure the reminder time is a positive integer.
• Check that the reminder count does not exceed
MAX_REMINDERS.
5.Exit
• Input: No additional input is required.
• Functionality: The application will terminate, displaying a goodbye
message.
 5.2. Output Design Overview
The output design of the To-Do List App emphasizes clarity and user engagement. It is
structured to guide users through the application’s functionality while providing clear feedback
for their actions.

1. Main Menu Display

Upon starting the application, the user is presented with a main menu that offers various options.
The menu is displayed in a loop, allowing users to select different functionalities repeatedly until
they choose to exit.
Menu Structure:

To-Do List App

1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice:

2. Task Addition Confirmation

• When a user chooses to add a task, they are prompted to enter a task description. Upon
successful addition, the app provides immediate feedback:

Enter task description: [User input]

Task added!

3. Displaying Task
• When the user opts to display tasks, the app lists all current tasks along with their
completion status. Each task is numbered for easy reference:
Tasks:
1. Buy groceries – Pending
2. Finish homework – Completed

4. Marking Tasks as Completed

After a user chooses to mark a task as completed, they are prompted for the task number. The
app validates this input and provides feedback based on whether the operation was successful or
if the input was invalid:

Enter task number to mark as completed: [User input]

Task marked as completed!

Or

Invalid task number.

5. Setting Reminders
• Users can set reminders for specific tasks. The app prompts for both the task number and
the reminder time in seconds. Successful reminder creation is acknowledged with
feedback:

Enter task number to set reminder: [User input]

Enter reminder time (seconds from now): [User input]
Reminder set!

Or, if limits are exceeded:

Reminder limit exceeded!

6. Reminder Notifications
 • The app periodically checks for reminders that need to be triggered. When a reminder is
due, it notifies the user with clear information about the task:

Reminder: Task 1 – Buy groceries

7. Exit Confirmation
• When the user decides to exit the application, a farewell message is displayed:

Exiting app. Bye!

8. Error Handling

Throughout the application, various points include error messages for invalid inputs or actions
that exceed limits (e.g., exceeding the maximum number of tasks or reminders). These messages
ensure users understand what went wrong and can correct their actions.

6. CONCLUSION

This To-Do List app is a functional tool for managing tasks and reminders effectively. While
it serves its purpose well, potential enhancements could include:

• Adding persistent storage (e.g., saving tasks to a file).

• Implementing more robust error handling.
• Enhancing the user interface for a better experience.

Overall, this program demonstrates basic programming principles in C and serves as a

foundation for more complex applications.
 7.1 CODING

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define MAX_TASKS 100

#define MAX_REMINDERS 100

Typedef struct {
Char description[100];
Int completed;
} Task;

Typedef struct {
Int taskNumber;
Time_t reminderTime;
} Reminder;

Task tasks[MAX_TASKS];
Int numTasks = 0;

Reminder reminders[MAX_REMINDERS];
Int numReminders = 0;

Void addTask() {
 If (numTasks < MAX_TASKS) {
Printf(“Enter task description: “);
Scanf(“%*c”);
Fgets(tasks[numTasks].description, sizeof(tasks[numTasks].description), stdin);
Tasks[numTasks].completed = 0;
numTasks++;
printf(“Task added!\n”);
} else {
Printf(“Task limit exceeded!\n”);
}
}

Void displayTasks() {
Printf(“\nTasks:\n”);
For (int I = 0; I < numTasks; i++) {
Printf(“%d. %s - %s\n”, I + 1, tasks[i].description, tasks[i].completed ? “Completed” :
“Pending”);
}
}

Void markTaskCompleted() {
Int taskNumber;
Printf(“Enter task number to mark as completed: “);
Scanf(“%d”, &taskNumber);
If (taskNumber > 0 && taskNumber <= numTasks) {
Tasks[taskNumber – 1].completed = 1;
Printf(“Task marked as completed!\n”);
} else {
Printf(“Invalid task number.\n”);
 }
}

Void setReminder() {
Int taskNumber;
Time_t reminderTime;
Printf(“Enter task number to set reminder: “);
Scanf(“%d”, &taskNumber);
Printf(“Enter reminder time (seconds from now): “);
Scanf(“%ld”, (long*) &reminderTime);
reminderTime += time(NULL);

if (numReminders < MAX_REMINDERS) {

reminders[numReminders].taskNumber = taskNumber;
reminders[numReminders].reminderTime = reminderTime;
numReminders++;
printf(“Reminder set!\n”);
} else {
Printf(“Reminder limit exceeded!\n”);
}
}

Void checkReminders() {
Time_t currentTime = time(NULL);
For (int I = 0; I < numReminders; i++) {
If (reminders[i].reminderTime <= currentTime) {
Printf(“Reminder: Task %d - %s\n”, reminders[i].taskNumber,
tasks[reminders[i].taskNumber – 1].description);
// Remove the reminder after displaying
 For (int j = I; j < numReminders – 1; j++) {
Reminders[j] = reminders[j + 1];
}
numReminders--;
}
}
}

Int main() {
While (1) {
Printf(“\nTo-Do List App\n”);
Printf(“1. Add task\n”);
Printf(“2. Display tasks\n”);
Printf(“3. Mark task as completed\n”);
Printf(“4. Set reminder\n”);
Printf(“5. Exit\n”);
Printf(“Enter your choice: “);

Int choice;
Scanf(“%d”, &choice);
Switch (choice) {
Case 1:
addTask();
break;
case 2:
displayTasks();
break;
case 3:
 markTaskCompleted();
break;
case 4:
setReminder();
break;
case 5:
printf(“Exiting app. Bye!\n”);
return 0;
}
checkReminders();
usleep(1000000);
}
Return 0;
}

7.2 OUTPUT
Add task
To-Do List App
1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 1
Enter task description: Buy groceries
Task added!

To-Do List App

1. Add task
 2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit

Enter your choice: 1

Enter task description: Read books
Task added!

Display task

To-Do List App

1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 2

Tasks:
1. Buy groceries
- Pending
2. Read books
- Pending

Task completed
To-Do List App
1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 3
Enter task number to mark as completed: 1
Task marked as completed!

To-Do List App

1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 2

Tasks:
1. Buy groceries
- Completed
3. Read books
- Pending

Set Reminder
To-Do List App
1. Add task
2. Display tasks
3. Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 4
Enter task number to set reminder: 2
Enter reminder time (seconds from now): 10
Reminder set!
Reminder: Task 2 – Read books

Exit
To-Do List App
1. Add task
2. Display task
3. .Mark task as completed
4. Set reminder
5. Exit
Enter your choice: 5
Exiting app. Bye!

=== Code Execution Successful ===

THANK YOU