diff --git a/overviews/week15.md b/overviews/week15.md
new file mode 100644
index 0000000000000000000000000000000000000000..80265334c0e84414b207c01362a036e20d112783
--- /dev/null
+++ b/overviews/week15.md
@@ -0,0 +1,34 @@
+# Week 15
+
+**This weeks quiz:** https://go.uwe.ac.uk/ctapQuiz
+
+This week we will be looking at our last two topics! They are programming patterns/ paradigms and evaluation (both considering your solutions and personal reflection and how that relates to computational thinking).
+
+## This week you are working on...
+
+### 👉 [THIS WEEKS TASK](https://gitlab.uwe.ac.uk/ctap/ctap-resources/-/blob/main/practicals/week15/tasks.md?ref_type=heads) 👈
+
+## Have already completed ...
+
+All tasks up to week 14! If you have not, now is really the time to work through the previous sessions and get support on your work!
+## By the end of the week...
+
+... you should have completed:
+
+- The tasks provided in `ctap-resources/practicals/week15/tasks.md`
+
+## Resources
+- [Chapter 6 of Computational thinking: a beginner's guide to problem-solving and programming](https://blackboard.uwe.ac.uk/webapps/blackboard/content/listContentEditable.jsp?content_id=_9740235_1&course_id=_358486_1&mode=reset)
+- [Slides](https://go.uwe.ac.uk/ctapSlides)
+- [Markdown Guide](https://gitlab.uwe.ac.uk/ctap/ctap-resources/-/blob/main/guides/markdown.md?ref_type=heads)
+
+### External resources
+
+#### Learning Python 
+- [Linked in Learning - Python Exceptions](https://www.linkedin.com/learning/python-essential-training-18764650/errors-and-exceptions?resume=false&u=56744785)
+- Python: [exceptions](https://docs.python.org/3/tutorial/errors.html)
+- [Learn Python .org's interactive python tutorials](https://www.learnpython.org/)
+- W3 schools [tutorial and reference](https://www.w3schools.com/python/)
+- Raspberry Pi Foundation [tutorials](https://projects.raspberrypi.org/en/pathways/python-intro?gclid=Cj0KCQjwpompBhDZARIsAFD_Fp8FpuLGfd6v863VziU4rGdV-ZHkcnu-bhjB0KuGS1fyYLBHiXpazGcaAnGuEALw_wcB)
+-  [Python in 100 seconds](https://www.youtube.com/watch?v=x7X9w_GIm1s)
+- Learn [python in 1 hour](https://www.youtube.com/watch?v=kqtD5dpn9C8)
diff --git a/practicals/week14/code.py b/practicals/week14/code.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..36679ba8dc65f3b909c2541799a374f9006d118c 100644
--- a/practicals/week14/code.py
+++ b/practicals/week14/code.py
@@ -0,0 +1,21 @@
+# A list of people currently invited to the party
+party_goers = ['jake', 'marceline']
+
+# A function to add to the party (returns true on success or false on failure)
+def invite_to_party(name, age):
+    if age < 18:
+        return False
+    else:
+        party_goers.append(name)
+        return True
+
+# Code to simulate our invite, handling errors as appropriate
+n = input("Enter your name: ")
+a = int(input("Enter your age: "))
+
+if invite_to_party(n,a):
+    print('Invited ' + n + ' to the party')
+else:
+    print( n + ' is too young to join the part')        
+
+    
diff --git a/practicals/week14/notes.md b/practicals/week14/notes.md
index 32dbd324ecff231f9108cf8cf5ac15c591fecce1..3387ee94c1e8e1f6ccddc4bc5261107e6bcdbee3 100644
--- a/practicals/week14/notes.md
+++ b/practicals/week14/notes.md
@@ -136,7 +136,6 @@ In this example, we create two options, one with a value of 10 and another as No
 Here's an example of how you can write unit tests for a function that checks if a user has a valid email using the `unittest` module in Python:
 
 ```python
-
 import unittest
 
 # Function to be tested
diff --git a/practicals/week15/code.py b/practicals/week15/code.py
new file mode 100644
index 0000000000000000000000000000000000000000..8eaec1c300756d2760d4c9a99ccbc6e9bd5c07c2
--- /dev/null
+++ b/practicals/week15/code.py
@@ -0,0 +1,23 @@
+class Model:                   
+    def __init__(self, name , value):
+        self.value = value       
+        self.name = name
+
+def view(model):
+    print('\033[0;35m')
+    print('---------------------------------')
+    print('update name: ' + model.name)
+    print('update value: ' + str(model.value))
+    print('---------------------------------')
+    print('\033[0;37m')
+
+def controller():
+    n = input('name is: ')
+    v = input('value is: ')
+    return Model(n,v)
+
+# main loop
+while True:
+    model = Model('default', 0)
+    model = controller()
+    view(model)
\ No newline at end of file
diff --git a/practicals/week15/notes.md b/practicals/week15/notes.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b83a7fa12e0c47b174e60c95ef662712bf299f4
--- /dev/null
+++ b/practicals/week15/notes.md
@@ -0,0 +1,37 @@
+# Object oriented programming
+
+```python
+class Car:
+    def __init__(self, brand, model, color):
+        self.brand = brand
+        self.model = model
+        self.colour = colour
+        self.speed = 0
+
+    def accelerate(self, increment):
+        self.speed += increment
+
+    def brake(self, decrement):
+        self.speed -= decrement
+
+    def display_info(self):
+        print(f"Brand: {self.brand}, Model: {self.model}, Colour: {self.colour}, Speed: {self.speed} km/h")
+
+
+# Creating instances of the Car class
+car1 = Car("Toyota", "Camry", "Blue")
+car2 = Car("Honda", "Civic", "Red")
+
+# Accessing and modifying object attributes
+car1.accelerate(20)
+car2.accelerate(30)
+car1.brake(5)
+
+# Displaying car information
+car1.display_info()
+car2.display_info()
+```
+
+In this example, we define a `Car` class with attributes like brand, model, colour, and speed. The class also has methods to accelerate, brake, and display information about the car. We then create two instances of the `Car` class (`car1` and `car2`) and perform operations on them, such as accelerating, braking, and displaying their information.
+
+Please note that this is a simplified example to demonstrate the concept of object-oriented programming in Python. In real-world scenarios, classes and objects can have more attributes and methods based on the requirements of the application.
\ No newline at end of file
diff --git a/practicals/week15/tasks.md b/practicals/week15/tasks.md
new file mode 100644
index 0000000000000000000000000000000000000000..19e384ed0918bbb0a89f092c99c856daaa425180
--- /dev/null
+++ b/practicals/week15/tasks.md
@@ -0,0 +1,66 @@
+# Week 15 Tasks for practicals
+
+# Task 1 : 
+## 1.1 
+
+Write functions that take a single parameter and perform the following operations on it, then return that value:
+- half the number provided
+- double the number provided
+- subtract one from the number provided
+- square the number provided
+- append the string '.'
+- prepend the string 'answer: '
+
+## 1.2
+
+Example (assuming your have defined the previous functions):
+
+take 5, double it, subtract 1, prepend the string 'answer: '
+`print(prepend_answer(subtract_one(double_it(5))))`
+> nb. this may vary based on what you named your function
+
+Use function composition to solve and print the following problems:
+- take 11, double it, double it, prepend the string 'answer', append the '.'
+- take 1024, half it, half it, half it, square it
+- take 1, double it, square it, subtract 1, prepend the string 'answer'
+
+## 1.3
+Create a class called Rectangle that represents a rectangle shape.  
+The class should have attributes for width and height, and methods to calculate the area and perimeter of the rectangle.  
+
+You should then be able to test this class with the following code:
+```python
+# Test the Rectangle class  
+rectangle = Rectangle(5, 3)  
+print("Width: ", rectangle.width)  
+print("Height: ", rectangle.height)  
+print("Area: ", rectangle.calculate_area())  
+print("Perimeter: ", rectangle.calculate_perimeter())
+```
+
+# Task 2 (Assessment work)
+
+Considering code that you have written so far, describe the use of programming constructs or patterns that you have used and attempt to identify where strategies such as those discussed in the lecture can be applied. 
+For example, you may identify that print statements could be better placed by focusing on returning values throughout your code and then printing in one place, imitating the MVC pattern. 
+
+You may also observe places where function composition or classes might be a useful programming construct for a part of your problem. 
+
+In this section, you could also discuss where these ideas might be relevant in code that you haven't written. Classes in particular often help to build up representations of real world things that contain both behaviour and data and you might suggest some examples of this in relation to your problem. Bonus points if you write some of the class as a snippet!
+
+What other 'best practices' have you discovered or learned that you have attempted or are attempting to apply in your work?
+
+# Task 3 (Assessment work)
+
+For this task we want to begin evaluating your work in preparation for the final section of your report. **Even if you are not finished with the rest *complete this task!***
+This will give you something to build upon...
+
+Task: Using bullet points document 4-8 challenges that you faced in the process of this module. Engage your practical tutor and/or peers in discussion and create sub points that indicate what was challenging, how you overcame the challenge and/or what you would do differently next time for this challenge.
+
+This take the form of something similar to this:
+
+ - Decomposition of the initial scenarios problem was challenging as it was hard to know where to start.
+	- Discussed the problem with peers
+	- started with a broad definition of the problem and added lots of initial sub problems
+	- later simplified to make less sub problems and more focused
+	- I made some problems like flow charts
+	- next time, I'd be more familiar with what the end goal should look like and I would be faster getting a high level decomposition drawn out.