diff --git a/src/main/java/com/booleanuk/core/Task.java b/src/main/java/com/booleanuk/core/Task.java
new file mode 100644
index 000000000..52a59a741
--- /dev/null
+++ b/src/main/java/com/booleanuk/core/Task.java
@@ -0,0 +1,35 @@
+package com.booleanuk.core;
+
+public class Task {
+    Boolean isComplete;
+    String description;
+
+    public Task(String description) {
+        this.description = description;
+        this.isComplete = false;
+    }
+
+    public Boolean isComplete() {
+        return this.isComplete;
+    }
+
+    void setComplete() {
+        this.isComplete = true;
+    }
+
+    void setIncomplete() {
+        this.isComplete = false;
+    }
+
+    @Override
+    public String toString() {
+        String str = "";
+        str += "Task " + description;
+        if (isComplete) {
+            str += ": Complete.";
+            return str;
+        }
+        str += ": Incomplete.";
+        return str;
+    }
+}
diff --git a/src/main/java/com/booleanuk/core/TodoList.java b/src/main/java/com/booleanuk/core/TodoList.java
index 675adaf0b..808523207 100644
--- a/src/main/java/com/booleanuk/core/TodoList.java
+++ b/src/main/java/com/booleanuk/core/TodoList.java
@@ -1,5 +1,115 @@
 package com.booleanuk.core;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class TodoList {
+    List<Task> allTasks;
+
+    public TodoList() {
+        allTasks = new ArrayList<>();
+    }
+
+    public void addTask(Task t) {
+        if (!(allTasks.contains(t))) {
+            allTasks.add(t);
+        }
+    }
+
+    public void seeTasks() {
+        if (allTasks.isEmpty()) {
+            return;
+        }
+        for (Task t : allTasks) {
+            t.toString();
+        }
+    }
+
+    public List<Task> getCompleteTasks() {
+        List<Task> completed = new ArrayList<>();
+        for (Task t : allTasks) {
+            if (t.isComplete()) {
+                completed.add(t);
+            }
+        }
+        return completed;
+    }
+
+    public List<Task> getIncompleteTasks() {
+        List<Task> incomplete = new ArrayList<>();
+
+        for (Task t : allTasks) {
+            if (!t.isComplete()) {
+                incomplete.add(t);
+            }
+        }
+        return incomplete;
+    }
+
+    public Task searchForTask(String description) {
+        for (Task t : allTasks) {
+
+            if (t.description.equals(description)) {
+                return t;
+            }
+        }
+        noSuchTask();
+        return null;
+    }
+
+    public Task removeTask(Task t) {
+        allTasks.remove(t);
+        return t;
+    }
+
+    public List<Task> ascendingView() {
+        Task[] toBeSorted = new Task[allTasks.size()];
+        Task temp;
+
+        for (int i = 0; i < toBeSorted.length; i ++) {
+            toBeSorted[i] = allTasks.get(i);
+        }
+
+        for (int i = 0; i < allTasks.size(); i ++) {
+            for (int j = i + 1; j < allTasks.size(); j ++) {
+
+                if (toBeSorted[i].description.compareTo(toBeSorted[j].description) > 0) {
+                    temp = toBeSorted[i];
+                    toBeSorted[i] = toBeSorted[j];
+                    toBeSorted[j] = temp;
+                }
+            }
+        }
+        List<Task> ascending = new ArrayList<>();
+        ascending.addAll(List.of(toBeSorted));
+        return ascending;
+    }
+
+    public List<Task> descendingView() {
+        Task[] toBeSorted = new Task[allTasks.size()];
+        Task temp;
+
+        for (int i = 0; i < toBeSorted.length; i ++) {
+            toBeSorted[i] = allTasks.get(i);
+        }
+
+        for (int i = 0; i < allTasks.size(); i ++) {
+            for (int j = i + 1; j < allTasks.size(); j ++) {
+
+                if (toBeSorted[i].description.compareTo(toBeSorted[j].description) < 0) {
+                    temp = toBeSorted[i];
+                    toBeSorted[i] = toBeSorted[j];
+                    toBeSorted[j] = temp;
+                }
+            }
+        }
+        List<Task> descending = new ArrayList<>();
+        descending.addAll(List.of(toBeSorted));
+        return descending;
+    }
 
+    public Task noSuchTask() {
+        System.out.println("There is no such task in the todo-list.");
+        return null;
+    }
 }
diff --git a/src/main/java/com/booleanuk/extension/TaskExtension.java b/src/main/java/com/booleanuk/extension/TaskExtension.java
new file mode 100644
index 000000000..859156997
--- /dev/null
+++ b/src/main/java/com/booleanuk/extension/TaskExtension.java
@@ -0,0 +1,53 @@
+package com.booleanuk.extension;
+
+import java.time.LocalDateTime;
+
+public class TaskExtension {
+    private Boolean isComplete;
+    private String description;
+    private final int id;
+    private LocalDateTime timeCreated;
+
+    public TaskExtension(int id, String description) {
+        this.id = id;
+        this.isComplete = false;
+        this.description = description;
+        timeCreated = LocalDateTime.now();
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    public String getDescription() {
+        return this.description;
+    }
+
+    public LocalDateTime getTimeCreated() {
+        return this.timeCreated;
+    }
+
+    public Boolean isComplete() {
+        return this.isComplete;
+    }
+
+    public void setComplete() {
+        this.isComplete = true;
+    }
+
+    public void setIncomplete() {
+        this.isComplete = false;
+    }
+
+    @Override
+    public String toString() {
+        String str = "";
+        str += "Task " + description;
+        if (isComplete) {
+            str += ": Complete.";
+            return str;
+        }
+        str += ": Incomplete.";
+        return str;
+    }
+}
diff --git a/src/main/java/com/booleanuk/extension/TodoListExtension.java b/src/main/java/com/booleanuk/extension/TodoListExtension.java
new file mode 100644
index 000000000..b08755478
--- /dev/null
+++ b/src/main/java/com/booleanuk/extension/TodoListExtension.java
@@ -0,0 +1,155 @@
+package com.booleanuk.extension;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+public class TodoListExtension {
+    List<TaskExtension> allTasks;
+
+    public TodoListExtension() {
+        allTasks = new ArrayList<>();
+    }
+
+    public void addTask(TaskExtension t) {
+        if (!(allTasks.contains(t))) {
+            allTasks.add(t);
+        }
+    }
+
+    public void setTaskCompleteById(int otherId) {
+        for (TaskExtension t : allTasks) {
+            if (t.getId() == otherId) {
+                t.setComplete();
+            }
+        }
+    }
+
+    public void setTaskIncompleteById(int otherId) {
+        for (TaskExtension t : allTasks) {
+            if (t.getId() == otherId) {
+                t.setIncomplete();
+            }
+        }
+    }
+
+    public TaskExtension getTaskById(int id) {
+
+        for (TaskExtension t : allTasks) {
+            if (t.getId() == id) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    public void getTasks() {
+        // tests by comparing two TodoLists, is that ok?
+        if (allTasks.isEmpty()) {
+            return;
+        }
+
+        for (TaskExtension t : allTasks) {
+            t.toString();
+        }
+    }
+
+    public LocalDateTime getTaskTimeCreated(int id) {
+        if (allTasks.isEmpty()) {
+            return null;
+        }
+        return getTaskById(id).getTimeCreated();
+    }
+
+    public List<TaskExtension> getCompleteTasks() {
+
+        List<TaskExtension> completed = new ArrayList<>();
+        for (TaskExtension t : allTasks) {
+            if (t.isComplete()) {
+                completed.add(t);
+            }
+        }
+        return completed;
+    }
+
+    public List<TaskExtension> getIncompleteTasks() {
+
+        List<TaskExtension> incomplete = new ArrayList<>();
+
+        for (TaskExtension t : allTasks) {
+            if (!t.isComplete()) {
+                incomplete.add(t);
+            }
+        }
+        return incomplete;
+    }
+
+    public TaskExtension searchForTask(String description) {
+
+        for (TaskExtension t : allTasks) {
+
+            if (t.getDescription().equals(description)) {
+                return t;
+            }
+        }
+
+        noSuchTask();
+        return null;
+    }
+
+    public TaskExtension removeTask(TaskExtension t) {
+        allTasks.remove(t);
+        return t;
+    }
+
+    public List<TaskExtension> ascendingView() {
+        TaskExtension[] toBeSorted = new TaskExtension[allTasks.size()];
+        TaskExtension temp;
+
+        for (int i = 0; i < toBeSorted.length; i ++) {
+            toBeSorted[i] = allTasks.get(i);
+        }
+
+        for (int i = 0; i < allTasks.size(); i ++) {
+            for (int j = i + 1; j < allTasks.size(); j ++) {
+
+                if (toBeSorted[i].getDescription().compareTo(toBeSorted[j].getDescription()) > 0) {
+                    temp = toBeSorted[i];
+                    toBeSorted[i] = toBeSorted[j];
+                    toBeSorted[j] = temp;
+                }
+            }
+        }
+        List<TaskExtension> ascending = new ArrayList<>();
+        ascending.addAll(List.of(toBeSorted));
+        return ascending;
+    }
+
+    public List<TaskExtension> descendingView() {
+        TaskExtension[] toBeSorted = new TaskExtension[allTasks.size()];
+        TaskExtension temp;
+
+        for (int i = 0; i < toBeSorted.length; i ++) {
+            toBeSorted[i] = allTasks.get(i);
+        }
+
+        for (int i = 0; i < allTasks.size(); i ++) {
+            for (int j = i + 1; j < allTasks.size(); j ++) {
+
+                if (toBeSorted[i].getDescription().compareTo(toBeSorted[j].getDescription()) < 0) {
+                    temp = toBeSorted[i];
+                    toBeSorted[i] = toBeSorted[j];
+                    toBeSorted[j] = temp;
+                }
+            }
+        }
+        List<TaskExtension> descending = new ArrayList<>();
+        descending.addAll(List.of(toBeSorted));
+        return descending;
+    }
+
+    public TaskExtension noSuchTask() {
+        System.out.println("There is no such task in the todo-list.");
+        return null;
+    }
+}
diff --git a/src/test/java/com/booleanuk/core/TodoListTest.java b/src/test/java/com/booleanuk/core/TodoListTest.java
index 0bef779a4..2bfaf6800 100644
--- a/src/test/java/com/booleanuk/core/TodoListTest.java
+++ b/src/test/java/com/booleanuk/core/TodoListTest.java
@@ -3,11 +3,138 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+
 class TodoListTest {
     @Test
-    public void exampleTest() {
-        String hello = "Hello";
-        Assertions.assertEquals("Hello", hello);
-        Assertions.assertNotEquals("Goodbye", hello);
+    public void shouldBeIncomplete() {
+        Task task = new Task(" ");
+        Assertions.assertEquals(false, task.isComplete());
+    }
+
+    @Test
+    public void shouldMakeComplete() {
+        Task task = new Task(" ");
+        task.setComplete();
+        Assertions.assertEquals(true, task.isComplete());
+    }
+
+    @Test
+    public void shouldMakeIncomplete() {
+        Task task = new Task(" ");
+        task.setComplete();
+        task.setIncomplete();
+        Assertions.assertEquals(false, task.isComplete());
+    }
+
+    @Test
+    public void shouldAddTask() {
+        TodoList todo = new TodoList();
+        Task t = new Task(" ");
+        todo.addTask(t);
+        Assertions.assertTrue(todo.allTasks.contains(t));
+    }
+
+    @Test
+    public void shouldPrintAll() {
+        TodoList todo1 = new TodoList();
+        TodoList todo2 = new TodoList();
+        Task t1 = new Task("a");
+        Task t2 = new Task("b");
+        todo1.allTasks.add(t1);
+        todo1.allTasks.add(t2);
+        todo2.allTasks.add(t1);
+        todo2.allTasks.add(t2);
+        Assertions.assertEquals(todo1.allTasks, todo2.allTasks);
+    }
+
+    @Test
+    public void shouldGetAllComplete() {
+        TodoList todo = new TodoList();
+        Task t1 = new Task("1");
+        Task t2 = new Task("2");
+        Task t3 = new Task("3");
+        Task t4 = new Task("4");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t4.setComplete();
+        Assertions.assertEquals(List.of(t4), todo.getCompleteTasks());
+
     }
+
+    @Test
+    public void shouldGetAllIncomplete() {
+        TodoList todo = new TodoList();
+        Task t1 = new Task("1");
+        Task t2 = new Task("2");
+        Task t3 = new Task("3");
+        Task t4 = new Task("4");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t3.setComplete();
+        t4.setComplete();
+        Assertions.assertEquals(List.of(t1, t2), todo.getIncompleteTasks());
+    }
+
+    @Test
+    public void shouldSearchForTask() {
+        TodoList todo = new TodoList();
+        Task t1 = new Task("cook");
+        Task t2 = new Task("work");
+        Task t3 = new Task("shop");
+        Task t4 = new Task("clean");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t4.setComplete(); t3.setComplete();
+        Assertions.assertEquals(todo.noSuchTask(), todo.searchForTask("relax"));
+    }
+
+    @Test
+    public void shouldRemoveTask() {
+        TodoList todo = new TodoList();
+        Task t1 = new Task(" ");
+        todo.addTask(t1);
+        Task removed = todo.removeTask(t1);
+        Assertions.assertTrue(!todo.allTasks.contains(t1));
+        Assertions.assertTrue(removed.equals(t1));
+    }
+
+    @Test
+    public void shouldShowAscending() {
+        // a-z
+        // a < b
+        // b > a
+        TodoList todo = new TodoList();
+        Task a = new Task("a");
+        Task b = new Task("b");
+        Task c = new Task("c");
+        Task d = new Task("d");
+        todo.addTask(a);
+        todo.addTask(b);
+        todo.addTask(c);
+        todo.addTask(d);
+        Assertions.assertEquals(a, todo.ascendingView().getFirst());
+    }
+
+    @Test
+    public void shouldShowDescending() {
+        // z-a
+        TodoList todo = new TodoList();
+        Task a = new Task("a");
+        Task b = new Task("b");
+        Task c = new Task("c");
+        Task d = new Task("d");
+        todo.addTask(a);
+        todo.addTask(b);
+        todo.addTask(c);
+        todo.addTask(d);
+        Assertions.assertEquals(d, todo.descendingView().getFirst());
+    }
+
 }
diff --git a/src/test/java/com/booleanuk/extension/TodoListExtensionTest.java b/src/test/java/com/booleanuk/extension/TodoListExtensionTest.java
new file mode 100644
index 000000000..4e60f0edf
--- /dev/null
+++ b/src/test/java/com/booleanuk/extension/TodoListExtensionTest.java
@@ -0,0 +1,187 @@
+package com.booleanuk.extension;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class TodoListExtensionTest {
+
+    @Test
+    public void shouldGetId() {
+        TaskExtension task = new TaskExtension(0, " ");
+        Assertions.assertEquals(0, task.getId());
+    }
+    @Test
+    public void shouldBeIncomplete() {
+        TaskExtension task = new TaskExtension(0, " ");
+        Assertions.assertEquals(false, task.isComplete());
+    }
+
+    @Test
+    public void shouldMakeComplete() {
+        TaskExtension task = new TaskExtension(0, " ");
+        task.setComplete();
+        Assertions.assertEquals(true, task.isComplete());
+    }
+
+    @Test
+    public void shouldMakeCompleteById() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        todo.allTasks.add(t1);
+        todo.allTasks.add(t2);
+        todo.setTaskCompleteById(1);
+        Assertions.assertTrue(t2.isComplete());
+    }
+
+    @Test
+    public void shouldMakeIncompleteById() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        todo.allTasks.add(t1);
+        todo.allTasks.add(t2);
+        todo.setTaskCompleteById(1);
+        todo.setTaskIncompleteById(1);
+        Assertions.assertFalse(t2.isComplete());
+    }
+
+
+    @Test
+    public void shouldMakeIncomplete() {
+        TaskExtension task = new TaskExtension(0, " ");
+        task.setComplete();
+        task.setIncomplete();
+        Assertions.assertEquals(false, task.isComplete());
+    }
+
+    @Test
+    public void shouldGetTaskById() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        todo.allTasks.add(t1);
+        todo.allTasks.add(t2);
+        Assertions.assertEquals(t2, todo.getTaskById(1));
+    }
+    @Test
+    public void shouldAddTask() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t = new TaskExtension(0, " ");
+        todo.addTask(t);
+        Assertions.assertTrue(todo.allTasks.contains(t));
+    }
+
+    @Test
+    public void shouldPrintAll() {
+        TodoListExtension todo1 = new TodoListExtension();
+        TodoListExtension todo2 = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        todo1.allTasks.add(t1);
+        todo1.allTasks.add(t2);
+        todo2.allTasks.add(t1);
+        todo2.allTasks.add(t2);
+        Assertions.assertEquals(todo1.allTasks, todo2.allTasks);
+    }
+
+    @Test
+    public void shouldGetAllComplete() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        TaskExtension t3 = new TaskExtension(2, " ");
+        TaskExtension t4 = new TaskExtension(3, " ");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t4.setComplete();
+        Assertions.assertEquals(List.of(t4), todo.getCompleteTasks());
+    }
+
+    @Test
+    public void shouldGetAllIncomplete() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, " ");
+        TaskExtension t2 = new TaskExtension(1, " ");
+        TaskExtension t3 = new TaskExtension(2, " ");
+        TaskExtension t4 = new TaskExtension(3, " ");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t3.setComplete();
+        t4.setComplete();
+        Assertions.assertEquals(List.of(t1, t2), todo.getIncompleteTasks());
+    }
+
+
+    @Test
+    public void shouldSearchForTask() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0, "clean");
+        TaskExtension t2 = new TaskExtension(1, "laundry");
+        TaskExtension t3 = new TaskExtension(2, "cook");
+        TaskExtension t4 = new TaskExtension(3, "work");
+        todo.addTask(t1);
+        todo.addTask(t2);
+        todo.addTask(t3);
+        todo.addTask(t4);
+        t4.setComplete(); t3.setComplete();
+        Assertions.assertEquals(todo.noSuchTask(), todo.searchForTask("relax"));
+    }
+
+    @Test
+    public void shouldRemoveTask() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension t1 = new TaskExtension(0," ");
+        todo.addTask(t1);
+        TaskExtension removed = todo.removeTask(t1);
+        Assertions.assertFalse(todo.allTasks.contains(t1));
+        Assertions.assertEquals(removed, t1);
+    }
+
+    @Test
+    public void shouldShowAscending() {
+        // a-z
+        // a < b
+        // b > a
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension a = new TaskExtension(0,"a");
+        TaskExtension b = new TaskExtension(1, "b");
+        TaskExtension c = new TaskExtension(2, "c");
+        TaskExtension d = new TaskExtension(3, "d");
+        todo.addTask(a);
+        todo.addTask(b);
+        todo.addTask(c);
+        todo.addTask(d);
+        Assertions.assertEquals(a, todo.ascendingView().getFirst());
+    }
+
+    @Test
+    public void shouldShowDescending() {
+        // z-a
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension a = new TaskExtension(0,"a");
+        TaskExtension b = new TaskExtension(1, "b");
+        TaskExtension c = new TaskExtension(2, "c");
+        TaskExtension d = new TaskExtension(3, "d");
+        todo.addTask(a);
+        todo.addTask(b);
+        todo.addTask(c);
+        todo.addTask(d);
+        Assertions.assertEquals(d, todo.descendingView().getFirst());
+    }
+
+    @Test
+    public void shouldReturnLocalDateTime() {
+        TodoListExtension todo = new TodoListExtension();
+        TaskExtension a = new TaskExtension(0,"a");
+        todo.addTask(a);
+        Assertions.assertInstanceOf(LocalDateTime.class, todo.getTaskTimeCreated(0));
+    }
+}