diff --git a/.gitignore b/.gitignore
index 99712178bf..0c78facf79 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,4 @@ src/main/resources/docs/
 .DS_Store
 *.iml
 bin/
+src/main/java/META-INF/MANIFEST.MF
diff --git a/Duke/data.txt b/Duke/data.txt
new file mode 100644
index 0000000000..1f967c739f
--- /dev/null
+++ b/Duke/data.txt
@@ -0,0 +1,2 @@
+T | true | poo
+D | true | pie  | 2020-12-12 | 1200
diff --git a/README.md b/README.md
index 2fd105ed3b..4e491f3b85 100644
--- a/README.md
+++ b/README.md
@@ -22,11 +22,12 @@
 
 # Tutorials 
 
-Duke Increment | Tutorial
+Duke.Duke Increment | Tutorial
 ---------------|---------------
 `A-TextUiTesting` | [Text UI Testing Tutorial](tutorials/textUiTestingTutorial.md)
 
 
+
 # Feedback, Bug Reports
 
 * If you have feedback or bug reports, please post in [se-edu/duke issue tracker](https://github.com/se-edu/duke/issues).
diff --git a/Save/data.txt b/Save/data.txt
new file mode 100644
index 0000000000..eb5c36b4b2
--- /dev/null
+++ b/Save/data.txt
@@ -0,0 +1,6 @@
+T | true | read book
+D | false | return book | June 6th
+E | false | project meeting | Aug 6th 2-4pm
+T | false | poo
+D | false | return homework | nowT | false | eat
+E | false | sleep | tonight
diff --git a/docs/README.md b/docs/README.md
index fd44069597..2ab6bc481d 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,20 +1,99 @@
 # User Guide
 
-## Features 
+## 1. Introduction
+Duke - version LISA, is a CLI task scheduler that supports three 
+different types of tasks (todo, event and deadline). 
+It is simple to use, and comes with a save function to 
+remember your
 
-### Feature 1 
-Description of feature.
+## 2. Quick Start
+1. Ensure you have Java 11 or above installed in your Computer
 
-## Usage
+1. Download the latest duke.jar
 
-### `Keyword` - Describe action
+1. Copy the file to the folder you want to use as the home folder.
 
-Describe action and its outcome.
+1. Run the jar file using `java - jar duke.jar`
 
-Example of usage: 
+## 3. Features
 
-`keyword (optional arguments)`
+### 3.1 - Add
+There are three types of tasks users can add
 
-Expected outcome:
+##### Todo:
+* Basic tasks for quick noting down, no date or time required 
+* **Usage**: `todo <description>`
 
-`outcome`
+##### Event:
+* Event type tasks, _date and time required_ 
+* **Usage**: `event <description> / <date> <time>`
+    * date format: YYYY-MM-DD
+    * time format: HHMM  
+    
+##### Deadline:
+* Tasks with a deadline, _date and time required_ 
+* **Usage**: `deadline <description> / <date> <time>`
+    * date format: YYYY-MM-DD
+    * time format: HHMM 
+     
+### 3.2 - List
+* Lists all tasks
+* **Usage**: `list`
+
+### 3.3 - Delete
+* Deletes a task from the list
+* **Usage**: `delete <task index>`
+    * The index refers to the index number shown in the displayed task list.
+    * use `list` to derive task index
+    * index has to be an _integer_
+
+### 3.4 - Done
+* Changes the status of a task to completed
+* **Usage**: `done <task index>`
+    * The index refers to the index number shown in the displayed task list.
+    * use `list` to derive task index
+    * index has to be an _integer_
+
+### 3.5 - Find
+* Searches all task descriptions for supplied keyword
+* **Usage**: `find <keyword>`
+    * Keyword has to be a _**single word**_
+    * Keyword is case _insensitive_
+
+### 3.6 - Help
+* displays the set of commands supported
+* **Usage**: `help`
+
+### 3.7 - Exit
+* Exits the program
+* **Usage**: `bye`
+
+## 4. Sample Usage
+
+1. Adding new todo task: `todo homework before class` 
+   * Expected outcome: adds "homework" to the list 
+
+1. Adding new deadline task: `deadline bathe after class / 2020-02-29 1500`
+    * Expected outcome: adds "bathe" to the list
+ 
+1. Search for specific keyword: `find class`
+    * Expected outcome: displays the above two tasks since they contain keyword "class" in description
+    
+## 5. FAQ
+ * How do I save my tasks?
+    * Tasks are saved automatically and loaded upon start up of application
+    * If unable to load, check the directory and file name
+        * Default folder (windows): `C:\Users\<computer name>\Duke`
+        * Default file name: `data.txt`
+ 
+## 6. Command Summary
+ * **Add**:
+    1. `todo <description>`
+    1. `event <description> / <date> <time>`
+    1. `deadline <description> / <date> <time>`
+ * **List**: `list` 
+ * **Delete**: `delete <task index>` 
+ * **Done**: `done <task index>` 
+ * **Find**: `find <keyword>` 
+ * **Help**: `help`
+ * **Exit**: `bye`
\ No newline at end of file
diff --git a/docs/_config.yml b/docs/_config.yml
new file mode 100644
index 0000000000..c4192631f2
--- /dev/null
+++ b/docs/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
\ No newline at end of file
diff --git a/src/main/java/Command/AddCommand.java b/src/main/java/Command/AddCommand.java
new file mode 100644
index 0000000000..7c3dc17367
--- /dev/null
+++ b/src/main/java/Command/AddCommand.java
@@ -0,0 +1,63 @@
+package Command;
+
+import Exceptions.MissingParameterException;
+import Exceptions.NoParameterException;
+import java.time.format.DateTimeParseException;
+
+/**
+ * Adds a task to the task list.
+ * Processes the task based on its task type
+ */
+public class AddCommand extends Command {
+
+    private static final char TASK_TODO = 'T';
+    private static final char TASK_EVENT = 'E';
+    private static final char TASK_DEADLINE = 'D';
+
+    String userInput;
+    int wordArrayLength;
+    char taskType;
+
+    /**
+     * Convenience constructor using raw values
+     *
+     * @param userCommand full user input, including command and task descriptions
+     * @param wordArrayLength number of parameters supplied for command
+     * @param taskType type of task to be processed
+     */
+    public AddCommand(String userCommand, int wordArrayLength, char taskType) {
+        this.userInput = userCommand;
+        this.wordArrayLength  = wordArrayLength;
+        this.taskType = taskType;
+    }
+
+
+    @Override
+    public void execute() {
+        try {
+            switch (taskType) {
+            case TASK_DEADLINE:
+                tasks.addDeadline(userInput, wordArrayLength);
+                break;
+            case TASK_EVENT:
+                tasks.addEvent(userInput, wordArrayLength);
+                break;
+            case TASK_TODO:
+                tasks.addTodo(userInput, wordArrayLength);
+                break;
+            default:
+                System.out.println("[Error][New Task]: Keyword not recognised!\n");
+                System.out.println("Task types:\ntodo\nevent\ndeadline");
+            }
+        } catch (NoParameterException e) {
+            System.out.println("[Error][New Task]: Missing parameters");
+            System.out.println("Usage:\n{todo} <Details>\n{event or deadline} <Details> / <YYYY-MM-DD> HH");
+        } catch (MissingParameterException | NullPointerException e) {
+            System.out.println("[Error][New Task]: Missing Date or Time field");
+        } catch (DateTimeParseException e) {
+            System.out.println("[Error][New Task]: Wrong format for date\nPlease record in YYYY-DD-MM format");
+        } catch (NumberFormatException e) {
+            System.out.println("[Error][New Task]: time should be all numbers in 24Hr format: HHMM");
+        }
+    }
+}
diff --git a/src/main/java/Command/Command.java b/src/main/java/Command/Command.java
new file mode 100644
index 0000000000..bd3442e796
--- /dev/null
+++ b/src/main/java/Command/Command.java
@@ -0,0 +1,42 @@
+package Command;
+
+import Storage.Storage;
+import Task.TaskList;
+import UI.Ui;
+
+/**
+ * Represents an executable command
+ */
+public abstract class Command {
+
+    protected TaskList tasks;
+    protected Storage storage;
+    protected Ui ui;
+
+    /**
+     * Called to check if exit command is given
+     * @return condition whether program should continue looping or exit
+     */
+    public boolean isExit() {
+        return false;
+    }
+
+    /**
+     * Supplies the objects other commands will call upon
+     *
+     * @param tasks  current instance of tasks and corresponding tasklist methods
+     * @param storage instance of storage object
+     * @param ui instance of user interaction object
+     */
+    public void setCommandVariables(TaskList tasks, Storage storage, Ui ui) {
+        this.tasks = tasks;
+        this.storage = storage;
+        this.ui = ui;
+    }
+
+    /**
+     * Executes user command processed by parser
+     */
+    public abstract void execute();
+
+}
diff --git a/src/main/java/Command/DeleteCommand.java b/src/main/java/Command/DeleteCommand.java
new file mode 100644
index 0000000000..981a48dbe0
--- /dev/null
+++ b/src/main/java/Command/DeleteCommand.java
@@ -0,0 +1,35 @@
+package Command;
+
+import Exceptions.EmptyListException;
+
+/**
+ * Deletes a task from the given task list object,
+ * updates data file upon completion
+ */
+public class DeleteCommand extends Command {
+
+    private String indexToDelete;
+
+    /**
+     * Convenience constructor using raw values
+     *
+     * @param indexToDelete String input of task index, will be checked later if it is a valid integer
+     */
+    public DeleteCommand(String indexToDelete) {
+        this.indexToDelete = indexToDelete;
+    }
+
+    @Override
+    public void execute() {
+        try{
+            tasks.deleteTask(Integer.parseInt(indexToDelete));
+            storage.rebuildTaskFile(tasks.getTaskList());
+        } catch (EmptyListException e) {
+            System.out.println("[Error][Delete]: " + e.getMessage());
+        } catch (NumberFormatException e) {
+            System.out.println("[Error][Delete]: Please input task number as a number, instead of spelling it out");
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("[Error][Delete]: Please input a task within the range of: 1 - " + tasks.getTaskListCounter());
+        }
+    }
+}
diff --git a/src/main/java/Command/DoneCommand.java b/src/main/java/Command/DoneCommand.java
new file mode 100644
index 0000000000..431547674d
--- /dev/null
+++ b/src/main/java/Command/DoneCommand.java
@@ -0,0 +1,34 @@
+package Command;
+
+/**
+ * Changes the status of a task to complete
+ * updates data file upon completion
+ */
+public class DoneCommand extends Command {
+
+    private String indexCompleteTask;
+
+    /**
+     * Convenience constructor using raw values
+     *
+     * @param indexCompleteTask String input of task index, will be checked later if it is a valid integer
+     */
+    public DoneCommand( String indexCompleteTask) {
+        super();
+        this.indexCompleteTask = indexCompleteTask;
+    }
+
+    @Override
+    public void execute() {
+        try {
+            boolean successfulUpdate = tasks.completeTask(Integer.parseInt(indexCompleteTask));
+            if (successfulUpdate) {
+                storage.rebuildTaskFile(tasks.getTaskList());
+            }
+        } catch (IndexOutOfBoundsException e) {
+            System.out.println("[Error][Done]: Please input a task within the range of: 1 - " + tasks.getTaskListCounter() + "\n");
+        } catch (NumberFormatException e) {
+            System.out.println("[Error][Done]: Please input task number as a number, instead of spelling it out\n");
+        }
+    }
+}
diff --git a/src/main/java/Command/ExitCommand.java b/src/main/java/Command/ExitCommand.java
new file mode 100644
index 0000000000..946285b320
--- /dev/null
+++ b/src/main/java/Command/ExitCommand.java
@@ -0,0 +1,21 @@
+package Command;
+
+/**
+ * Sends the exit signal to main loop, program is exited after this command
+ */
+public class ExitCommand extends Command {
+
+    /**
+     * Check if exit command is given
+     * @return signal to main loop that program will be terminated
+     */
+    @Override
+    public boolean isExit() {
+        return true;
+    }
+
+    @Override
+    public void execute() {
+        System.out.println("LISA: Bye, hope to see you again!");
+    }
+}
diff --git a/src/main/java/Command/FailedCommand.java b/src/main/java/Command/FailedCommand.java
new file mode 100644
index 0000000000..7980a1e805
--- /dev/null
+++ b/src/main/java/Command/FailedCommand.java
@@ -0,0 +1,24 @@
+package Command;
+
+/**
+ * Assist auxiliary parser methods if failed validation
+ */
+public class FailedCommand extends Command {
+    private String errorMessage;
+
+    /**
+     * Saves a custom message when command is returned
+     *
+     * @param errorMessage
+     */
+    public FailedCommand(String errorMessage) {
+        super();
+        this.errorMessage = errorMessage;
+    }
+
+    @Override
+    public void execute() {
+        System.out.println(errorMessage);
+    }
+
+}
diff --git a/src/main/java/Command/FindCommand.java b/src/main/java/Command/FindCommand.java
new file mode 100644
index 0000000000..18ab0d2e6c
--- /dev/null
+++ b/src/main/java/Command/FindCommand.java
@@ -0,0 +1,53 @@
+package Command;
+
+import Duke.Task;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Find tasks based on keyword provided
+ */
+public class FindCommand extends Command {
+    private String searchItem;
+
+    /**
+     * Convenience constructor using raw values
+     *
+     * @param searchItem keyword used to search
+     */
+    public FindCommand(String searchItem) {
+        this.searchItem = searchItem;
+    }
+
+    /**
+     * Searches for keyword in all task description
+     * search term is case insensitive
+     */
+    @Override
+    public void execute() {
+        try {
+            ArrayList<Task> searchTasks = tasks.getTaskList();
+            ArrayList<Task> foundTasks = new ArrayList<>();
+            String regex = "\\b" + searchItem + "\\b";
+            Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
+            for (Task task : searchTasks) {
+                Matcher matchQuery = pattern.matcher(task.getDescription());
+                if (matchQuery.find()) {
+                    foundTasks.add(task);
+                }
+            }
+            if (!foundTasks.isEmpty()) {
+                int taskIndexCounter = 1;
+                System.out.println("Here are the matching tasks in your list:");
+                for (Task task : foundTasks) {
+                    task.printListDetails(taskIndexCounter++);
+                }
+            } else {
+                System.out.println("No match found!");
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Please input a valid keyword!");
+        }
+    }
+}
diff --git a/src/main/java/Command/HelpCommand.java b/src/main/java/Command/HelpCommand.java
new file mode 100644
index 0000000000..53503e5355
--- /dev/null
+++ b/src/main/java/Command/HelpCommand.java
@@ -0,0 +1,11 @@
+package Command;
+
+/**
+ * Displays a list of commands available
+ */
+public class HelpCommand extends Command {
+    @Override
+    public void execute() {
+        ui.printHelp();
+    }
+}
diff --git a/src/main/java/Command/ListCommand.java b/src/main/java/Command/ListCommand.java
new file mode 100644
index 0000000000..34e144ac4e
--- /dev/null
+++ b/src/main/java/Command/ListCommand.java
@@ -0,0 +1,12 @@
+package Command;
+
+/**
+ * Displays the list of tasks stored, both completed and uncompleted
+ */
+public class ListCommand extends Command {
+
+    @Override
+    public void execute() {
+        tasks.printList();
+    }
+}
diff --git a/src/main/java/Duke.java b/src/main/java/Duke.java
deleted file mode 100644
index 5d313334cc..0000000000
--- a/src/main/java/Duke.java
+++ /dev/null
@@ -1,10 +0,0 @@
-public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
-    }
-}
diff --git a/src/main/java/Duke/Deadline.java b/src/main/java/Duke/Deadline.java
new file mode 100644
index 0000000000..a9cff87c29
--- /dev/null
+++ b/src/main/java/Duke/Deadline.java
@@ -0,0 +1,44 @@
+package Duke;
+
+/**
+ * Specifies the additional requirements for deadline type tasks
+ */
+public class Deadline extends Task {
+
+    public static final String TYPE_DEADLINE = "D";
+
+    public Deadline (String description, String date, String time) {
+        super(description, date, time);
+    }
+
+    /**
+     * Retrieve the code for current type of task
+     *
+     * @return deadline task type code
+     */
+    @Override
+    public String getTaskType() {
+        return TYPE_DEADLINE;
+    }
+
+    /**
+     * Prints details of task upon adding
+     * Default is set for tasks without date
+     *
+     * @param taskCounter current index of task
+     */
+    @Override
+    public void printAddDetails(int taskCounter) {
+        System.out.println("The following task has been added:\n[" + getTaskType() +"][" +
+                            super.getStatusIcon() + "] " + super.description + " (by: " + super.date + ")\n");
+        System.out.println("You've got " + taskCounter + " task(s) in the list!\n");
+    }
+
+    @Override
+    public void printListDetails(int count) {
+        System.out.println("["+ getTaskType() + "][" + super.getStatusIcon() + "] " +
+                            count + ". " + super.description + " (by: " + super.date + " at " + time +")");
+    }
+
+
+}
diff --git a/src/main/java/Duke/Duke.java b/src/main/java/Duke/Duke.java
new file mode 100644
index 0000000000..772a2ce79e
--- /dev/null
+++ b/src/main/java/Duke/Duke.java
@@ -0,0 +1,65 @@
+package Duke;
+
+import Command.Command;
+import Storage.Storage;
+import Task.TaskList;
+import UI.Ui;
+import Parser.Parser;
+
+/**
+ * The Duke program implements an application that simulates is a task scheduler
+ * It allow the saving of tasks to a file and reloading of data when application starts
+ */
+public class Duke {
+
+    private Storage storage;
+    private TaskList tasks;
+    private Ui ui;
+
+    /**
+     * Main Duke constructor to set up required classes and check for data file
+     */
+    public Duke() {
+        ui = new Ui();
+        storage = new Storage();
+        tasks = new TaskList();
+        // search for folder, create if not found
+        storage.checkFolderPath();
+        // populate if data file is found
+        if (storage.checkFileExists()) {
+            storage.populateList(tasks);
+        }
+    }
+
+    /**
+     * Runner method to read and execute user commands
+     * Loops until "bye" command given
+     */
+    public void run() {
+        ui.showWelcome();
+        boolean isExit = false;
+        while (!isExit) {
+            try {
+                String fullCommand = ui.readCommand();
+                Command c = Parser.parseCommand(fullCommand);
+                c.setCommandVariables(tasks, storage, ui);
+                c.execute();
+                isExit = c.isExit();
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println("[Error][Input]: Missing parameters detected");
+            }
+            finally {
+                ui.showLine();
+            }
+        }
+    }
+
+    /**
+     * Main method for Duke program
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        new Duke().run();
+    }
+}
diff --git a/src/main/java/Duke/Event.java b/src/main/java/Duke/Event.java
new file mode 100644
index 0000000000..a6769b81d9
--- /dev/null
+++ b/src/main/java/Duke/Event.java
@@ -0,0 +1,45 @@
+package Duke;
+
+/**
+ * Specifies the additional requirements for event type tasks
+ */
+public class Event extends Task {
+
+    public static final String TYPE_EVENT = "E";
+
+
+    public Event(String description, String date, String time){
+        super(description, date, time);
+    }
+
+    /**
+     * Retrieve the code for current type of task
+     *
+     * @return deadline task type code
+     */
+    @Override
+    public String getTaskType(){
+        return TYPE_EVENT;
+    }
+
+    /**
+     * Prints details of task upon adding
+     * Default is set for tasks without date
+     *
+     * @param taskCounter current index of task
+     */
+    @Override
+    public void printAddDetails(int taskCounter) {
+        System.out.println("The following task has been added:\n[" + getTaskType() +"][" +
+                            getStatusIcon() + "] " + super.description + " (by: " + super.date + " at " + time +")");
+
+        System.out.println("You've got " + taskCounter + " task(s) in the list!\n");
+    }
+
+    @Override
+    public void printListDetails(int count) {
+        System.out.println("["+ getTaskType() + "][" + super.getStatusIcon() + "] " +
+                            count + ". " + super.description + " (by: " + super.date + " at " + time +")");
+    }
+
+}
diff --git a/src/main/java/Duke/Task.java b/src/main/java/Duke/Task.java
new file mode 100644
index 0000000000..81a804c7c3
--- /dev/null
+++ b/src/main/java/Duke/Task.java
@@ -0,0 +1,98 @@
+package Duke;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Default task class, provides skeleton for specific task types
+ */
+public abstract class Task {
+
+    /*
+    Symbols do not work on windows
+    public static final char TICK = '\u2713';
+    public static final char CROSS = '\u2718';
+    */
+
+    public static final char TICK = 'Y'; //Yes
+    public static final char CROSS = 'N'; //No
+
+    protected String description;
+    protected LocalDate date;
+    protected boolean isDone;
+    protected String time;
+
+    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+
+    /**
+     * Constructs for task types without date field
+     *
+     * @param description information about the task
+     */
+    public Task(String description) {
+        this.description = description;
+        this.date = null;
+        this.isDone = false;
+        this.time = null;
+    }
+
+    /**
+     * Constructor for task types with date and time field
+     *
+     * @param description information about the task
+     * @param date Stored in a YYYY-MM-DD format
+     */
+    public Task(String description, String date, String time) {
+        this.description = description;
+        this.date = LocalDate.parse(date, formatter);
+        this.isDone = false;
+        this.time = time;
+    }
+
+    public LocalDate getDate() {
+        return date;
+    }
+
+    public boolean getStatus() {
+        return isDone;
+    }
+
+    /**
+     * Returns symbol for status of task
+     *
+     * @return tick for done, cross for not done
+     */
+    public char getStatusIcon() {
+        return (isDone ? TICK : CROSS); //return tick or X symbols
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void markAsDone() {
+        this.isDone = true;
+    }
+
+    public String getTaskType() {
+        return null;
+    }
+
+    public String getTime() {
+        return time;
+    }
+
+    /**
+     * Prints details of task upon adding
+     * Default is set for tasks without date
+     *
+     * @param taskCounter current index of task
+     */
+    public void printAddDetails(int taskCounter) {
+        System.out.println("The following task has been added:\n[" + getTaskType() +"][" + getStatusIcon() + "] " + getDescription());
+        System.out.println("\nYou've got " + taskCounter + " task(s) in the list!\n");
+    }
+
+    public abstract void printListDetails(int count);
+
+}
diff --git a/src/main/java/Duke/ToDo.java b/src/main/java/Duke/ToDo.java
new file mode 100644
index 0000000000..310cd018da
--- /dev/null
+++ b/src/main/java/Duke/ToDo.java
@@ -0,0 +1,37 @@
+package Duke;
+
+
+/**
+ * Specifies the additional requirements for todo type tasks
+ */
+public class ToDo extends Task {
+
+    public static final String TYPE_TODO = "T";
+
+    public ToDo(String description){
+        super(description);
+    }
+
+    /**
+     * Retrieve the code for current type of task
+     *
+     * @return deadline task type code
+     */
+    @Override
+    public String getTaskType(){
+        return TYPE_TODO;
+    }
+
+    /**
+     * Prints details of task upon adding
+     * Default is set for tasks without date
+     *
+     * @param taskCounter current index of task
+     */
+    @Override
+    public void printListDetails(int taskCounter) {
+        System.out.println("["+ getTaskType() + "][" + getStatusIcon() + "] " + taskCounter + ". " + getDescription());
+    }
+
+
+}
diff --git a/src/main/java/Exceptions/EmptyListException.java b/src/main/java/Exceptions/EmptyListException.java
new file mode 100644
index 0000000000..21ef603e3c
--- /dev/null
+++ b/src/main/java/Exceptions/EmptyListException.java
@@ -0,0 +1,10 @@
+package Exceptions;
+
+/**
+ * Custom exception for delete command
+ */
+public class EmptyListException extends Exception {
+    public EmptyListException(String errorMessage) {
+        super(errorMessage);
+    }
+}
diff --git a/src/main/java/Exceptions/MissingParameterException.java b/src/main/java/Exceptions/MissingParameterException.java
new file mode 100644
index 0000000000..c8ac122eb9
--- /dev/null
+++ b/src/main/java/Exceptions/MissingParameterException.java
@@ -0,0 +1,10 @@
+package Exceptions;
+
+/**
+ * Custom exception to handing missing parameters
+ */
+public class MissingParameterException extends Exception {
+    public MissingParameterException() {
+        super();
+    }
+}
diff --git a/src/main/java/Exceptions/NoParameterException.java b/src/main/java/Exceptions/NoParameterException.java
new file mode 100644
index 0000000000..ee272b97b2
--- /dev/null
+++ b/src/main/java/Exceptions/NoParameterException.java
@@ -0,0 +1,10 @@
+package Exceptions;
+
+/**
+ * Custom exception when no parameter / whitespace is detected for commands
+ */
+public class NoParameterException extends Exception{
+    public NoParameterException(String errorMessage) {
+        super(errorMessage);
+    }
+}
diff --git a/src/main/java/Exceptions/WrongTimeFormatException.java b/src/main/java/Exceptions/WrongTimeFormatException.java
new file mode 100644
index 0000000000..745de16ce0
--- /dev/null
+++ b/src/main/java/Exceptions/WrongTimeFormatException.java
@@ -0,0 +1,7 @@
+package Exceptions;
+
+public class WrongTimeFormatException extends Exception {
+    public WrongTimeFormatException(String errorMessage) {
+        super(errorMessage);
+    }
+}
diff --git a/src/main/java/Parser/Parser.java b/src/main/java/Parser/Parser.java
new file mode 100644
index 0000000000..67f995a4a9
--- /dev/null
+++ b/src/main/java/Parser/Parser.java
@@ -0,0 +1,100 @@
+package Parser;
+
+import Command.Command;
+import Command.ListCommand;
+import Command.FailedCommand;
+import Command.DoneCommand;
+import Command.HelpCommand;
+import Command.AddCommand;
+import Command.DeleteCommand;
+import Command.ExitCommand;
+import Command.FindCommand;
+
+/**
+ * Parses user input
+ */
+public class Parser {
+
+    private static final int SIZE_DONE_COMMAND = 2;
+    private static final int SIZE_DELETE_COMMAND = 2;
+    private static final char TASK_TODO = 'T';
+    private static final char TASK_EVENT = 'E';
+    private static final char TASK_DEADLINE = 'D';
+
+    /**
+     * Parses user input into command for execution
+     *
+     * @param userCommand user input including command word and parameters
+     * @return  command based on user input
+     */
+    public static Command parseCommand(String userCommand) {
+
+            String[] words = userCommand.split(" ");
+            int wordLength = words.length;
+
+            switch (words[0]) {
+            case "list":
+                return new ListCommand();
+            case "done":
+                return prepareDoneCommand(words[1], wordLength);
+
+            case "help":
+                return new HelpCommand();
+
+            case "delete":
+                return prepareDeleteCommand(words[1], wordLength);
+
+            case "todo":
+                return new AddCommand(userCommand, wordLength, TASK_TODO);
+
+            case "event":
+                return new AddCommand(userCommand, wordLength, TASK_EVENT);
+
+            case "deadline":
+                return new AddCommand(userCommand, wordLength, TASK_DEADLINE);
+
+            case "find":
+                return new FindCommand(words[1]);
+
+            case "bye":
+                return new ExitCommand();
+
+            default:
+                System.out.println("Command not recognised\n");
+                return new HelpCommand();
+            }
+    }
+
+    /**
+     * Auxiliary function for delete command
+     * validates input before parsing
+     *
+     * @param wordIndex index of task to be processed
+     * @param wordLength length of user input for validation
+     * @return command to execute
+     */
+    private static Command prepareDeleteCommand(String wordIndex, int wordLength) {
+        if (wordLength != SIZE_DELETE_COMMAND) {
+            String errorMessage = "Wrong format for command \"Delete\"\n";
+            return new FailedCommand(errorMessage);
+        }
+            return new DeleteCommand(wordIndex);
+    }
+
+    /**
+     * Auxiliary function for done command
+     * validates input before parsing
+     *
+     * @param wordIndex index of task to be processed
+     * @param wordLength length of user input for validation
+     * @return command to execute
+     */
+    private static Command prepareDoneCommand(String wordIndex, int wordLength) {
+        if (wordLength != SIZE_DONE_COMMAND) {
+            String errorMessage = "Wrong format for command \"Done\"";
+            return new FailedCommand(errorMessage);
+        }
+            return new DoneCommand(wordIndex);
+    }
+
+}
diff --git a/src/main/java/Storage/Storage.java b/src/main/java/Storage/Storage.java
new file mode 100644
index 0000000000..c87346bd08
--- /dev/null
+++ b/src/main/java/Storage/Storage.java
@@ -0,0 +1,156 @@
+package Storage;
+
+import Duke.Task;
+import Duke.ToDo;
+import Task.TaskList;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents the fle to store task data
+ */
+public class Storage {
+
+    private static final char TASK_TODO = 'T';
+    private static final char TASK_EVENT = 'E';
+    private static final char TASK_DEADLINE = 'D';
+    private static final String WORKING_DIRECTORY = System.getProperty("user.dir");
+    private static final java.nio.file.Path FOLDER_PATH = java.nio.file.Paths.get(WORKING_DIRECTORY, "Duke");
+    private static final java.nio.file.Path FILE_PATH = java.nio.file.Paths.get(WORKING_DIRECTORY, "Duke", "data.txt");
+
+    /**
+     * Locate folder location and check availability
+     * If missing create folder
+     */
+    public static void checkFolderPath() {
+
+        boolean directoryExists = java.nio.file.Files.exists(FOLDER_PATH);
+        try {
+            if (!directoryExists) {
+                Files.createDirectory(FOLDER_PATH);
+                System.out.println("Directory created\n");
+            } else {
+                System.out.println("Directory found\n");
+            }
+        } catch (IOException e) {
+            System.out.println("Error creating folder!\n");
+        }
+    }
+
+    /**
+     * Check whether data file has is present in directory
+     *
+     * @return status of file availability
+     */
+    public static boolean checkFileExists() {
+        boolean fileExists = java.nio.file.Files.exists(FILE_PATH);
+        return fileExists;
+    }
+
+    /**
+     * Writes newly created task to data file
+     *
+     * @param newTask newly created task
+     * @param myWriter FileWriter object to operate on task
+     * @throws IOException if error writing to file
+     */
+    private static void writeTaskToFile(Task newTask, FileWriter myWriter) throws IOException {
+        if (newTask instanceof ToDo) {
+            myWriter.write(newTask.getTaskType() + " | " + newTask.getStatus() + " | "
+                    + newTask.getDescription() + "\n");
+        } else {
+            myWriter.write(newTask.getTaskType() + " | " + newTask.getStatus() + " | "
+                    + newTask.getDescription() + " | " + newTask.getDate().toString() + " | " + newTask.getTime() + "\n");
+        }
+    }
+
+    /**
+     * Parser method for task objects to call when requires saving
+     * Sets up environment for writing to file
+     *
+     * @param newTask newly created task
+     */
+    public static void saveTask(Task newTask) {
+        try {
+            File file = new File(String.valueOf(FILE_PATH));
+            FileWriter myWriter = new FileWriter(file, true);
+            writeTaskToFile(newTask, myWriter);
+            myWriter.close();
+            System.out.println("Successfully updated data file!\n");
+        } catch (IOException e) {
+            System.out.println("Error updating file!\n");
+        }
+    }
+
+    /**
+     * Reads in entries from data file line by line
+     *
+     * @param tasks instance of the list of tasks
+     */
+    public static void populateList(TaskList tasks) {
+        try {
+            List<String> allLines = Files.readAllLines(Paths.get(String.valueOf(FILE_PATH)));
+            for (String oneLine : allLines) {
+                processDataFile(oneLine, tasks);
+            }
+        } catch (IOException e) {
+            System.out.println("Error reading data file! \n");
+        }
+
+    }
+
+    /**
+     * Parse entry in datafile according to data type
+     *
+     * @param oneLine current entry in data file
+     * @param tasks instance of the list of tasks
+     */
+    public static void processDataFile(String oneLine, TaskList tasks) {
+        String[] words = oneLine.split(" \\| ");
+        try {
+            switch (words[0].charAt(0)) {
+            case TASK_TODO:
+                tasks.loadFromFileTodo(words);
+                break;
+            case TASK_DEADLINE:
+                tasks.loadFromFileDeadline(words);
+                break;
+            case TASK_EVENT:
+                tasks.loadFromFileEvent(words);
+                break;
+            default:
+                // in case user touches txt file and fills with random data
+                System.out.println("Line not added: " + oneLine + "\n");
+            }
+        } catch (ArrayIndexOutOfBoundsException | NumberFormatException e) {
+            System.out.println("Corrupted entry detected, skipping entry");
+        }
+
+    }
+
+    /**
+     * Updates the entire task file after delete or complete command is given
+     *
+     * @param tasks instance of the list of tasks
+     */
+    public static void rebuildTaskFile(ArrayList<Task> tasks) {
+        // replace current list with new updated list
+        try {
+            File file = new File(String.valueOf(FILE_PATH));
+            FileWriter myWriter = new FileWriter(file, false);
+            for (Task newTask : tasks) {
+                writeTaskToFile(newTask, myWriter);
+            }
+            myWriter.close();
+            System.out.println("Successfully updated data file!\n");
+        } catch (IOException e) {
+            System.out.println("Error updating file!\n");
+        }
+    }
+}
+
diff --git a/src/main/java/Task/TaskList.java b/src/main/java/Task/TaskList.java
new file mode 100644
index 0000000000..7a7d90e393
--- /dev/null
+++ b/src/main/java/Task/TaskList.java
@@ -0,0 +1,322 @@
+package Task;
+
+import Duke.Deadline;
+import Duke.Event;
+import Duke.Task;
+import Duke.ToDo;
+import Exceptions.MissingParameterException;
+import Exceptions.NoParameterException;
+import Exceptions.EmptyListException;
+import Exceptions.WrongTimeFormatException;
+import Storage.Storage;
+import java.util.ArrayList;
+
+/**
+ * Instance of tasks used in program
+ * Contains methods required to modify tasks
+ */
+public class TaskList {
+
+    public static final int LENGTH_DEADLINE = 9;
+    public static final int LENGTH_EVENT = 6;
+    public static final int LENGTH_TODO = 5;
+    public static final int LIST_TO_INDEX = 1;
+    public static final String TASK_INCORRECT_PARAMETERS_DETECTED = "[Error][New Task]: Incorrect Parameters detected";
+    public static final int DATETIME_PARAMETER_SIZE = 2;
+    public static final int LENGTH_OF_DATE_VAR = 4;
+
+    private static ArrayList<Task> tasks;
+
+    /**
+     * Creating new instance of task list
+     */
+    public TaskList() {
+        tasks = new ArrayList<Task>();
+    }
+
+    /**
+     * Updates task status upon completion
+     *
+     * @param indexCompleteTask index of complete task
+     * @return whether update is successful or not
+     */
+    public static boolean completeTask(int indexCompleteTask) {
+        indexCompleteTask -= 1; // index starts from 0, unlike listing number
+        if ( (indexCompleteTask < tasks.size()) || (indexCompleteTask > 0)) { // check if out of bounce
+            Task currentTask = tasks.get(indexCompleteTask);
+            if (currentTask.getStatus()) { // check if already completed
+                System.out.println("[Alert][Done]: Task already completed!\n");
+            } else {
+                currentTask.markAsDone();
+                System.out.println("[Alert][Duke]: Nice! I've marked this task as done:");
+                System.out.println( "["+ currentTask.getTaskType() + "][" + currentTask.getStatusIcon() + "] " + currentTask.getDescription() + "\n");
+                return true;
+            }
+        } else {
+            System.out.println("[Error][Done] Error: No such index in use\n");
+        }
+        return false;
+    }
+
+    /**
+     * Deletion of task from task list
+     *
+     * @param taskIndex index of task to be deleted
+     * @throws EmptyListException if task list is empty
+     */
+    public static void deleteTask(int taskIndex) throws EmptyListException {
+        if(tasks.isEmpty()) {
+            throw  new EmptyListException("List is currently empty!");
+        }
+        taskIndex -= LIST_TO_INDEX;
+        if ( (taskIndex < tasks.size()) || (taskIndex > 0)) { // check if out of bounce
+            Task currentTask = tasks.get(taskIndex);
+            System.out.println("[Alert]: Noted. I've removed this task:");
+            System.out.println("["+ currentTask.getTaskType() + "][" + currentTask.getStatusIcon() + "] " + currentTask.getDescription() + "\n");
+            tasks.remove(taskIndex);
+            System.out.println("Now you have " + tasks.size() +" tasks in the list.\n");
+
+        } else {
+            System.out.println("[Error][Delete]: No such index in use\n");
+        }
+    }
+
+    /**
+     * Processes task types with date and time fields
+     *
+     * @param taskDescription description of task
+     * @param wordLength    length of user command for parameter validation
+     * @param commandLength length of command word for extraction
+     * @return word array for task fields
+     * @throws NoParameterException
+     * @throws MissingParameterException
+     */
+    public static String[] processDatedTasks(String taskDescription, int wordLength, int commandLength)
+                                            throws NoParameterException, MissingParameterException {
+        if (wordLength <= 1) { // empty parameter
+            throw new NoParameterException("[Error][New Task]: Incorrect Parameters detected");
+        }
+        try {
+            String itemName = taskDescription.substring(commandLength);
+            String[] words = itemName.split("/"); // potential problem is not accepting date format with '/' inside, throw err if more than 2 len
+            for (int i = 0; i < words.length; i++) { // checking for blank tasks, including one char of space
+                if (words[i].isBlank()){
+                    throw new NoParameterException(TASK_INCORRECT_PARAMETERS_DETECTED);
+                }
+            }
+            return words;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("[Error][New Task]: Please input the date using the specified format");
+        }
+        System.out.println("[Error]: Incorrect input found");
+        return null;
+    }
+
+    /**
+     * Check if date is valid number
+     *
+     * @param date date of task
+     * @return whether date is a valid numerical value
+     */
+    private static boolean isInteger(String date) {
+        for (char c : date.toCharArray()) {
+            if (!Character.isDigit(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Separating date and time from parsed parameter
+     *
+     * @param dateTime parameter from user input task
+     * @return array of size two for date and time
+     * @throws MissingParameterException if either date or time is missing
+     */
+    public static String[] formatDatetime(String dateTime) throws MissingParameterException, WrongTimeFormatException {
+        try {
+            String[] splitDateTime = dateTime.trim().split(" ");
+
+            if (splitDateTime.length != DATETIME_PARAMETER_SIZE) {
+                throw new NullPointerException();
+            }
+
+            if (splitDateTime[1].length() != LENGTH_OF_DATE_VAR) {
+                throw new WrongTimeFormatException("Time format is wrong!");
+            }
+
+            if (!isInteger(splitDateTime[1])) {
+                throw new WrongTimeFormatException("Time Format is Wrong!");
+            }
+
+            for (int i = 0; i < splitDateTime.length; i++) { // checking for blank tasks, including one char of space
+                if (splitDateTime[i].isBlank()){
+                    throw new MissingParameterException();
+                }
+            }
+            return splitDateTime;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("[Error][New Task]: Please input the date using the specified format");
+        }
+        return null;
+    }
+
+    /**
+     * Adding deadline task into task list
+     *
+     * @param userInput user input
+     * @param wordLength length of user input for validation
+     * @throws NoParameterException no parameters given
+     * @throws MissingParameterException not all parameters filled
+     */
+    public static void addDeadline(String userInput, int wordLength) throws NoParameterException, MissingParameterException {
+        try {
+            String[] words = processDatedTasks(userInput, wordLength, LENGTH_DEADLINE);
+            String[] splitDateTime = formatDatetime(words[1]);
+            if (splitDateTime.length != DATETIME_PARAMETER_SIZE) {
+                throw new MissingParameterException();
+            }
+            Task newTask = new Deadline(words[0], splitDateTime[0], splitDateTime[1]);
+            tasks.add(newTask);
+            newTask.printAddDetails(getTaskListCounter());
+            Storage.saveTask(newTask);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("[Error][New Task]: Please input the date using the specified format");
+        } catch (WrongTimeFormatException e) {
+            System.out.println("[Error][New Task]: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Adding event task into task list
+     *
+     * @param userInput user input
+     * @param wordLength length of user input for validation
+     * @throws NoParameterException no parameters given
+     * @throws MissingParameterException not all parameters filled
+     */
+    public static void addEvent(String userInput, int wordLength) throws NoParameterException, MissingParameterException {
+        try {
+            String[] words = processDatedTasks(userInput, wordLength, LENGTH_EVENT);
+            String[] splitDateTime = formatDatetime(words[1]);
+            if (splitDateTime.length != DATETIME_PARAMETER_SIZE) {
+                throw new MissingParameterException();
+            }
+            Task newTask = new Event(words[0], splitDateTime[0], splitDateTime[1]);
+            tasks.add(newTask);
+            newTask.printAddDetails(getTaskListCounter());
+            Storage.saveTask(newTask);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("[Error][New Task]: Please input the date using the specified format");
+        } catch (WrongTimeFormatException e) {
+            System.out.println("[Error][New Task]: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Adding deadline task into task list
+     *
+     * @param userInput user input
+     * @param wordLength length of user input for validation
+     * @throws NoParameterException no parameters given
+     */
+    public static void addTodo(String userInput, int wordLength) throws NoParameterException {
+
+        if (wordLength <= 1) { // empty parameter
+            throw new NoParameterException(TASK_INCORRECT_PARAMETERS_DETECTED);
+        }
+        String itemName = userInput.substring(LENGTH_TODO);
+        if (itemName.isBlank()) { // task is a space/blank char
+            throw new NoParameterException(TASK_INCORRECT_PARAMETERS_DETECTED);
+        }
+        Task newTask = new ToDo(itemName.trim());
+        tasks.add(newTask);
+        newTask.printAddDetails(getTaskListCounter());
+        Storage.saveTask(newTask);
+    }
+
+    /**
+     * Retrieves the current size of task list
+     *
+     * @return number of tasks
+     */
+    public static int getTaskListCounter() {
+        return tasks.size();
+    }
+
+    /**
+     * Loading todo task from data file
+     *
+     * @param words entry of task in data file
+     */
+    public static void loadFromFileTodo(String[] words) {
+        boolean taskStatus = Boolean.parseBoolean(words[1]);
+        String taskDescription = words[2];
+        Task newTask = new ToDo(taskDescription);
+        if (taskStatus) {
+            newTask.markAsDone();
+        }
+        tasks.add(newTask);
+    }
+
+    /**
+     * Loading deadline task from data file
+     *
+     * @param words entry of task in data file
+     */
+    public static void loadFromFileDeadline(String[] words) {
+        boolean taskStatus = Boolean.parseBoolean(words[1]);
+        String taskDescription = words[2];
+        String taskDate = words[3];
+        String taskTime = words[4];
+        Task newTask = new Deadline(taskDescription, taskDate, taskTime);
+        if (taskStatus) {
+            newTask.markAsDone();
+        }
+        tasks.add(newTask);
+
+    }
+
+    /**
+     * Loading event task from data file
+     *
+     * @param words entry of task in data file
+     */
+    public static void loadFromFileEvent(String[] words ) {
+        boolean taskStatus = Boolean.parseBoolean(words[1]);;
+        String taskDescription = words[2];
+        String taskDate = words[3];
+        String taskTime = words[4];
+        Task newTask = new Event(taskDescription, taskDate, taskTime);
+        if (taskStatus) {
+            newTask.markAsDone();
+        }
+        tasks.add(newTask);
+    }
+
+    /**
+     * Displays the full task list
+     */
+    public static void printList() {
+        int count = 1;
+        System.out.println("Listing tasks below:");
+
+        if (tasks.isEmpty()) {
+            System.out.println("No tasks at the moment!");
+        } else {
+            for (Task currentTask : tasks) {
+                currentTask.printListDetails(count);
+                count++;
+            }
+        }
+        System.out.println("");
+    }
+
+    /**
+     * Retrieves actual task list
+     */
+    public static ArrayList<Task> getTaskList() {
+        return tasks;
+    }
+}
diff --git a/src/main/java/UI/Ui.java b/src/main/java/UI/Ui.java
new file mode 100644
index 0000000000..bb04fa74e0
--- /dev/null
+++ b/src/main/java/UI/Ui.java
@@ -0,0 +1,68 @@
+package UI;
+
+import java.util.Scanner;
+
+/**
+ * Text UI of the application
+ */
+public class Ui {
+
+    /**
+     * Prints the list of operations supported
+     */
+    public static void printHelp() {
+        String commandList =
+            "Legend:\n"
+            + "[Y]: Task is completed\n"
+            + "[N]: Task is not completed\n\n"
+            + "Commands: "
+            + "Exit: Exits program \nUsage: bye\n\n"
+            + "List: Lists all recorded tasks \nUsage: list\n\n"
+            + "Done: Mark task as completed \nUsage: done <task number>\n\n"
+            + "Todo: Basic Tasks without date/time \nUsage: todo <task> \n\n"
+            + "Event: Event tasks including date/time \nUsage: event <task> /<YYYY-MM-DD> <HHMM> \n\n"
+            + "Deadline: Deadline tasks including date/time \nUsage: deadline <task> /<YYYY-MM-DD> <HHMM> \n\n"
+            + "Delete: Deletes task from list \nUsage: delete <task number>\n\n"
+            + "Find: Search for task using keyword \nUsage: find <key word>\nnote: Keyword is only one word\n";
+        System.out.println(commandList);
+    }
+
+    public static void showLine() {
+        System.out.println("____________________________________________________________");
+    }
+
+    /**
+     * Prompts user for input
+     *
+     * @return String containing user command for parsing
+     */
+    public static String readCommand() {
+        System.out.print("> ");
+        Scanner input = new Scanner(System.in);
+        String userCommand = input.nextLine();
+        return userCommand;
+    }
+
+    public static void showWelcome() {
+        String logo =   "  ,--,       ,---,   .--.--.       ,---,\n"
+                + ",--.'|    ,`--.' |  /  /    '.    '  .' \\\n"
+                + "|  | :    |   :  : |  :  /`. /   /  ;    '.\n"
+                + ":  : '    :   |  ' ;  |  |--`   :  :       \\\n"
+                + "|  ' |    |   :  | |  :  ;_     :  |   /\\   \\\n"
+                + "'  | |    '   '  ;  \\  \\    `.  |  :  ' ;.   :\n"
+                + "|  | :    |   |  |   `----.   \\ |  |  ;/  \\   \\\n"
+                + "'  : |__  '   :  ;   __ \\  \\  | '  :  | \\  \\ ,'\n"
+                + "|  | '.'| |   |  '  /  /`--'  / |  |  '  '--'\n"
+                + ";  :    ; '   :  | '--'.     /  |  :  :\n"
+                + "|  ,   /  ;   |.'    `--'---'   |  | ,'\n"
+                + "---`-'   '---'                 `--''\n";
+
+        String welcomeMessage = "\n" + logo + "\nYour Lifestyle Scheduling Assistant\n\n"
+                                + "type \"help\" for list of commands\n"
+                                + "____________________________________________________________\n"
+                                + "Everyday is a sunny day!\n"
+                                + "____________________________________________________________\n";
+
+        System.out.println(welcomeMessage);
+    }
+}
diff --git a/text-ui-test/ACTUAL.TXT b/text-ui-test/ACTUAL.TXT
new file mode 100644
index 0000000000..b09a372ca6
--- /dev/null
+++ b/text-ui-test/ACTUAL.TXT
@@ -0,0 +1,50 @@
+
+  ,--,       ,---,   .--.--.       ,---,
+,--.'|    ,`--.' |  /  /    '.    '  .' \
+|  | :    |   :  : |  :  /`. /   /  ;    '.
+:  : '    :   |  ' ;  |  |--`   :  :       \
+|  ' |    |   :  | |  :  ;_     :  |   /\   \
+'  | |    '   '  ;  \  \    `.  |  :  ' ;.   :
+|  | :    |   |  |   `----.   \ |  |  ;/  \   \
+'  : |__  '   :  ;   __ \  \  | '  :  | \  \ ,'
+|  | '.'| |   |  '  /  /`--'  / |  |  '  '--'
+;  :    ; '   :  | '--'.     /  |  :  :
+|  ,   /  ;   |.'    `--'---'   |  | ,'
+---`-'   '---'                 `--''
+
+Your Lifestyle Scheduling Assistant
+
+type "help" for list of commands
+____________________________________________________________
+
+Everyday is a sunny day!
+____________________________________________________________
+The following task has been added:
+[T][✘] add pie crust
+
+You've got 1 task(s) in the list!
+
+The following task has been added:
+[D][✘] complete homework (by: now)
+
+You've got 2 task(s) in the list!
+
+The following task has been added:
+[E][✘] tutorial (at: Tuesday 2pm)
+
+You've got 3 task(s) in the list!
+
+Listing tasks below:
+[T][✘] 1. add pie crust
+[D][✘] 2. complete homework (by: now)
+[E][✘] 3. tutorial (by: Tuesday 2pm)
+
+Nice! I've marked this task as done:
+[D][✓] complete homework
+
+Listing tasks below:
+[T][✘] 1. add pie crust
+[D][✓] 2. complete homework (by: now)
+[E][✘] 3. tutorial (by: Tuesday 2pm)
+
+LISA: Bye, hope to see you again!
diff --git a/text-ui-test/EXPECTED.TXT b/text-ui-test/EXPECTED.TXT
new file mode 100644
index 0000000000..b09a372ca6
--- /dev/null
+++ b/text-ui-test/EXPECTED.TXT
@@ -0,0 +1,50 @@
+
+  ,--,       ,---,   .--.--.       ,---,
+,--.'|    ,`--.' |  /  /    '.    '  .' \
+|  | :    |   :  : |  :  /`. /   /  ;    '.
+:  : '    :   |  ' ;  |  |--`   :  :       \
+|  ' |    |   :  | |  :  ;_     :  |   /\   \
+'  | |    '   '  ;  \  \    `.  |  :  ' ;.   :
+|  | :    |   |  |   `----.   \ |  |  ;/  \   \
+'  : |__  '   :  ;   __ \  \  | '  :  | \  \ ,'
+|  | '.'| |   |  '  /  /`--'  / |  |  '  '--'
+;  :    ; '   :  | '--'.     /  |  :  :
+|  ,   /  ;   |.'    `--'---'   |  | ,'
+---`-'   '---'                 `--''
+
+Your Lifestyle Scheduling Assistant
+
+type "help" for list of commands
+____________________________________________________________
+
+Everyday is a sunny day!
+____________________________________________________________
+The following task has been added:
+[T][✘] add pie crust
+
+You've got 1 task(s) in the list!
+
+The following task has been added:
+[D][✘] complete homework (by: now)
+
+You've got 2 task(s) in the list!
+
+The following task has been added:
+[E][✘] tutorial (at: Tuesday 2pm)
+
+You've got 3 task(s) in the list!
+
+Listing tasks below:
+[T][✘] 1. add pie crust
+[D][✘] 2. complete homework (by: now)
+[E][✘] 3. tutorial (by: Tuesday 2pm)
+
+Nice! I've marked this task as done:
+[D][✓] complete homework
+
+Listing tasks below:
+[T][✘] 1. add pie crust
+[D][✓] 2. complete homework (by: now)
+[E][✘] 3. tutorial (by: Tuesday 2pm)
+
+LISA: Bye, hope to see you again!
diff --git a/text-ui-test/input.txt b/text-ui-test/input.txt
new file mode 100644
index 0000000000..0d4fc33aad
--- /dev/null
+++ b/text-ui-test/input.txt
@@ -0,0 +1,7 @@
+todo add pie crust
+deadline complete homework /now
+event tutorial /Tuesday 2pm
+list
+done 2
+list
+bye
\ No newline at end of file
diff --git a/text-ui-test/runtest.bat b/text-ui-test/runtest.bat
new file mode 100644
index 0000000000..2ffa02474e
--- /dev/null
+++ b/text-ui-test/runtest.bat
@@ -0,0 +1,21 @@
+@ECHO OFF
+
+REM create bin directory if it doesn't exist
+if not exist ..\bin mkdir ..\bin
+
+REM delete output from previous run
+del ACTUAL.TXT
+
+REM compile the code into the bin folder
+javac  -cp ..\src -Xlint:none -d ..\bin ..\src\main\java\*.java
+IF ERRORLEVEL 1 (
+    echo ********** BUILD FAILURE **********
+    exit /b 1
+)
+REM no error here, errorlevel == 0
+
+REM run the program, feed commands from input.txt file and redirect the output to the ACTUAL.TXT
+java -classpath ..\bin Duke.Duke < input.txt > ACTUAL.TXT
+
+REM compare the output to the expected output
+FC ACTUAL.TXT EXPECTED.TXT
\ No newline at end of file
diff --git a/tutorials/gradleTutorial.md b/tutorials/gradleTutorial.md
index 08292b118d..f3142111e2 100644
--- a/tutorials/gradleTutorial.md
+++ b/tutorials/gradleTutorial.md
@@ -30,10 +30,10 @@ As a developer, you write a _build file_ that describes the project. A build fil
    git checkout master
    git merge gradle
    ```
-1. Open the `build.gradle` file in an editor. Update the following code block to point to the main class (i.e., the one containing the `main` method) of your application. The code below assumes your main class is `seedu.duke.Duke`
+1. Open the `build.gradle` file in an editor. Update the following code block to point to the main class (i.e., the one containing the `main` method) of your application. The code below assumes your main class is `seedu.duke.Duke.Duke`
    ```groovy
    application {
-       mainClassName = "seedu.duke.Duke"
+       mainClassName = "seedu.duke.Duke.Duke"
    }
    ```
 1. To check if Gradle has been added to the project correctly, open a terminal window, navigate to the root directory of your project and run the command `gradlew run`. This should result in Gradle running the main method of your project.
@@ -146,7 +146,7 @@ By convention, java tests belong in `src/test/java` folder. Create a new `test/j
 src
 ├─main
 │  └─java
-│     └─seedu/duke/Duke.java
+│     └─seedu/duke/Duke.Duke.java
 └─test
     └─java
         └─seedu/duke/DukeTest.java
diff --git a/tutorials/javaFxTutorialPart1.md b/tutorials/javaFxTutorialPart1.md
index 561daeca43..b90034895d 100644
--- a/tutorials/javaFxTutorialPart1.md
+++ b/tutorials/javaFxTutorialPart1.md
@@ -44,7 +44,7 @@ javafx {
 
 ## Writing your first program
 
-As customary, let’s start off with a simple “Hello World” program. Modify your `Duke` class to extend `javafx.application.Application`. This requires you to override the `Application#start()` method and provide a concrete implementation. Notice that the method signature for `Application#start()` has a parameter `Stage`. This is the _primary stage_ that JavaFX provides.
+As customary, let’s start off with a simple “Hello World” program. Modify your `Duke.Duke` class to extend `javafx.application.Application`. This requires you to override the `Application#start()` method and provide a concrete implementation. Notice that the method signature for `Application#start()` has a parameter `Stage`. This is the _primary stage_ that JavaFX provides.
 
 ```java
 import javafx.application.Application;
@@ -52,7 +52,7 @@ import javafx.scene.Scene;
 import javafx.scene.control.Label;
 import javafx.stage.Stage;
 
-public class Duke extends Application {
+public class Duke.Duke extends Application {
     
     // ...
 
@@ -73,7 +73,7 @@ Next, we create another Java class, `Launcher`, as an entry point to our applica
 The `Launcher` class is reproduced below in its entirety.
 
 ```java
-import javafx.application.Application;
+import Duke.Duke;import javafx.application.Application;
 
 /**
  * A launcher class to workaround classpath issues.
diff --git a/tutorials/javaFxTutorialPart2.md b/tutorials/javaFxTutorialPart2.md
index f24a0cd6ad..5060722948 100644
--- a/tutorials/javaFxTutorialPart2.md
+++ b/tutorials/javaFxTutorialPart2.md
@@ -1,8 +1,8 @@
-# JavaFX Tutorial Part 2 - Creating a GUI for Duke
+# JavaFX Tutorial Part 2 - Creating a GUI for Duke.Duke
 
-In this tutorial, we will be creating a GUI for Duke from scratch based on the following mockup.
+In this tutorial, we will be creating a GUI for Duke.Duke from scratch based on the following mockup.
 
-![Mockup for Duke](assets/DukeMockup.png)
+![Mockup for Duke.Duke](assets/DukeMockup.png)
 
 ## JavaFX controls
 
@@ -34,7 +34,7 @@ But how do we get the exact layout we want in the UI? JavaFX provides that funct
 
 One way to obtain the layout in the mockup is as follows. 
 
-![Duke's layout](assets/DukeSceneGraph.png) 
+![Duke.Duke's layout](assets/DukeSceneGraph.png) 
 
 To get that layout, we create a new `AnchorPane` and add our controls to it. Similarly, we create a new `VBox` to hold the contents of the `ScrollPane`. The code should look something like this:
 
@@ -49,7 +49,7 @@ import javafx.scene.layout.VBox;
 import javafx.stage.Stage;
 
 
-public class Duke extends Application {
+public class Duke.Duke extends Application {
 
     private ScrollPane scrollPane;
     private VBox dialogContainer;
@@ -88,7 +88,7 @@ public class Duke extends Application {
 
 Run the application and you should see something like this:
 
-![Duke's raw layout](assets/RawLayout.png)
+![Duke.Duke's raw layout](assets/RawLayout.png)
  
 That is not what we were expecting, what did we forget to do?
 
@@ -106,7 +106,7 @@ Add the following code to the bottom of the `start` method. You'll have to add `
         //...
 
         //Step 2. Formatting the window to look as expected
-        stage.setTitle("Duke");
+        stage.setTitle("Duke.Duke");
         stage.setResizable(false);
         stage.setMinHeight(600.0);
         stage.setMinWidth(400.0);
@@ -141,7 +141,7 @@ Add the following code to the bottom of the `start` method. You'll have to add `
 
 Run the application again. It should now look like this:
 
-![Duke's Final layout](assets/FinalLayout.png)
+![Duke.Duke's Final layout](assets/FinalLayout.png)
 
 ## Exercises
 
diff --git a/tutorials/javaFxTutorialPart3.md b/tutorials/javaFxTutorialPart3.md
index a9e1bdddd3..88c48326cd 100644
--- a/tutorials/javaFxTutorialPart3.md
+++ b/tutorials/javaFxTutorialPart3.md
@@ -8,7 +8,7 @@ Rather than to do everything in one try, let’s iterate and build up towards ou
 
 JavaFX has an _event-driven architecture style_. As such, we programmatically define _handler_ methods to execute as a response to certain _events_. When an event is detected, JavaFX will call the respective handlers.
 
-For Duke, there are two events that we want to respond to, namely the user pressing `Enter` in the `TextField` and left-clicking the `Button`. These are the `onAction` event for the `TextField` and the `onMouseClicked` event for the `Button`.
+For Duke.Duke, there are two events that we want to respond to, namely the user pressing `Enter` in the `TextField` and left-clicking the `Button`. These are the `onAction` event for the `TextField` and the `onMouseClicked` event for the `Button`.
 
 For now, let’s have the application add a new `Label` with the text from the `TextField`. Update the `Main` class as follows. You'll need to add an `import javafx.scene.control.Label;` too.
 ```java
@@ -103,7 +103,7 @@ import javafx.scene.image.ImageView;
 ```
 
 Next, add two images to the `main/resources/images` folder.
-For this tutorial, we have two images `DaUser.png` and `DaDuke.png` to represent the user avatar and Duke's avatar respectively but you can use any image you want.
+For this tutorial, we have two images `DaUser.png` and `DaDuke.png` to represent the user avatar and Duke.Duke's avatar respectively but you can use any image you want.
 
 Image|Filename
 ---|---
@@ -112,7 +112,7 @@ Image|Filename
 
 
 ```java
-public class Duke extends Application {
+public class Duke.Duke extends Application {
     // ...
     private Image user = new Image(this.getClass().getResourceAsStream("/images/DaUser.png"));
     private Image duke = new Image(this.getClass().getResourceAsStream("/images/DaDuke.png"));
@@ -124,7 +124,7 @@ Add a new method to handle user input:
 ```java
 /**
  * Iteration 2:
- * Creates two dialog boxes, one echoing user input and the other containing Duke's reply and then appends them to
+ * Creates two dialog boxes, one echoing user input and the other containing Duke.Duke's reply and then appends them to
  * the dialog container. Clears the user input after processing.
  */
 private void handleUserInput() {
@@ -142,7 +142,7 @@ private void handleUserInput() {
  * Replace this stub with your completed method.
  */
 private String getResponse(String input) {
-    return "Duke heard: " + input;
+    return "Duke.Duke heard: " + input;
 }
 ```
 
@@ -170,7 +170,7 @@ Run the program and see how it works.
 
 ## Iteration 3 – Adding custom behavior to DialogBox
 
-One additional benefit of defining a custom control is that we can add behavior specific to our `DialogBox`. Let’s add a method to flip a dialog box such that the image on the left to differentiate between user input and Duke’s output.
+One additional benefit of defining a custom control is that we can add behavior specific to our `DialogBox`. Let’s add a method to flip a dialog box such that the image on the left to differentiate between user input and Duke.Duke’s output.
 
 ```java
 /**
@@ -224,7 +224,7 @@ Run the application and play around with it.
 ![DialogBoxes Iteration 3](assets/DialogBoxesIteration3.png)
 
 Congratulations! 
-You have successfully implemented a fully functional GUI for Duke!  
+You have successfully implemented a fully functional GUI for Duke.Duke!  
 
 ## Exercises
 
diff --git a/tutorials/javaFxTutorialPart4.md b/tutorials/javaFxTutorialPart4.md
index 0e0ab280c4..50e8c3d762 100644
--- a/tutorials/javaFxTutorialPart4.md
+++ b/tutorials/javaFxTutorialPart4.md
@@ -29,7 +29,7 @@ FXML is a XML-based language that allows us to define our user interface. Proper
 
 The FXML snippet define a TextField similar to the one that we programmatically defined previous in Tutorial 2. Notice how concise FXML is compared to the plain Java version.
 
-Let's return to Duke and convert it to use FXML instead.
+Let's return to Duke.Duke and convert it to use FXML instead.
 
 # Rebuilding the Scene using FXML
 
@@ -101,14 +101,14 @@ We will get to that later.
 
 ## Using Controllers
 
-As part of the effort to separate the code handling Duke's logic and UI, let's _refactor_ the UI-related code to its own class.
+As part of the effort to separate the code handling Duke.Duke's logic and UI, let's _refactor_ the UI-related code to its own class.
 We call these UI classes _controllers_. 
 
 Let's implement the `MainWindow` controller class that we specified in `MainWindow.fxml`.
 
 **MainWindow.java**
 ```java
-import javafx.fxml.FXML;
+import Duke.Duke;import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.ScrollPane;
 import javafx.scene.control.TextField;
@@ -143,7 +143,7 @@ public class MainWindow extends AnchorPane {
     }
 
     /**
-     * Creates two dialog boxes, one echoing user input and the other containing Duke's reply and then appends them to
+     * Creates two dialog boxes, one echoing user input and the other containing Duke.Duke's reply and then appends them to
      * the dialog container. Clears the user input after processing.
      */
     @FXML
@@ -168,7 +168,7 @@ Similarly, methods like private methods like `handleUserInput` can be used in FX
 
 ## Using FXML in our application
 
-Let's create a new `Main` class as the bridge between the existing logic in `Duke` and the UI in `MainWindow`.
+Let's create a new `Main` class as the bridge between the existing logic in `Duke.Duke` and the UI in `MainWindow`.
 
 **Main.java**
 ```java
@@ -182,7 +182,7 @@ import javafx.scene.layout.AnchorPane;
 import javafx.stage.Stage;
 
 /**
- * A GUI for Duke using FXML.
+ * A GUI for Duke.Duke using FXML.
  */
 public class Main extends Application {
 
diff --git a/tutorials/textUiTestingTutorial.md b/tutorials/textUiTestingTutorial.md
index f397d76aef..d6c9e54ade 100644
--- a/tutorials/textUiTestingTutorial.md
+++ b/tutorials/textUiTestingTutorial.md
@@ -13,7 +13,7 @@
    del ACTUAL.TXT
    
    REM compile the code into the bin folder
-   javac  -cp ..\src -Xlint:none -d ..\bin ..\src\main\java\Duke.java
+   javac  -cp ..\src -Xlint:none -d ..\bin ..\src\main\java\Duke.Duke.java
    IF ERRORLEVEL 1 (
        echo ********** BUILD FAILURE **********
        exit /b 1
@@ -21,7 +21,7 @@
    REM no error here, errorlevel == 0
    
    REM run the program, feed commands from input.txt file and redirect the output to the ACTUAL.TXT
-   java -classpath ..\bin Duke < input.txt > ACTUAL.TXT
+   java -classpath ..\bin Duke.Duke < input.txt > ACTUAL.TXT
    
    REM compare the output to the expected output
    FC ACTUAL.TXT EXPECTED.TXT
@@ -44,14 +44,14 @@
    fi
    
    # compile the code into the bin folder, terminates if error occurred
-   if ! javac -cp ../src -Xlint:none -d ../bin ../src/main/java/Duke.java
+   if ! javac -cp ../src -Xlint:none -d ../bin ../src/main/java/Duke.Duke.java
    then
        echo "********** BUILD FAILURE **********"
        exit 1
    fi
    
    # run the program, feed commands from input.txt file and redirect the output to the ACTUAL.TXT
-   java -classpath ../bin Duke < input.txt > ACTUAL.TXT
+   java -classpath ../bin Duke.Duke < input.txt > ACTUAL.TXT
    
    # compare the output to the expected output
    diff ACTUAL.TXT EXPECTED.TXT