diff --git a/worksheets/worksheet1/worksheet1.md b/worksheets/worksheet1/worksheet1.md
index d784140d96deada71caed1487fad25f39fed24b2..68aeaea792b3c1477dd5cee9f83e66dc6b0cb768 100644
--- a/worksheets/worksheet1/worksheet1.md
+++ b/worksheets/worksheet1/worksheet1.md
@@ -17,12 +17,12 @@ The marking scheme for this session is as follows:
 >
 > All work is handed in via git/GitLab and will require the skills demonstrated in this worksheet.
 
-In order to complete these tasks you will need to read the guides provided for git [here](https://blackboard.uwe.ac.uk/webapps/blackboard/content/listContentEditable.jsp?content_id=_8555749_1&course_id=_340256_1), in the guides directory on blackboard.
+In order to complete these tasks you will need to read the guides provided for git [here](https://gitlab.uwe.ac.uk/ng-renney/cpp-resources/-/tree/main/guides/git), or in the guides directory on blackboard.
 
 These cover:
-- [Git introduction](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556007-dt-content-rid-26598777_2/xid-26598777_2)
-- [Git submissions](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556004-dt-content-rid-26598775_2/xid-26598775_2)
-- [Git Reference](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556005-dt-content-rid-26598776_2/xid-26598776_2)
+- [git intro](https://gitlab.uwe.ac.uk/ng-renney/cpp-resources/-/blob/main/guides/git/intro-to-git.md)
+- [git reference]( https://gitlab.uwe.ac.uk/ng-renney/cpp-resources/-/blob/main/guides/git/git-reference.md)
+- [git submission](https://gitlab.uwe.ac.uk/ng-renney/cpp-resources/guides/git/git-submissions.md)
 
 ## Working with existing Projects
 
@@ -60,20 +60,15 @@ https://gitlab.uwe.ac.uk/ng-renney/example.git but instead takes the form (where
 
 https://gitlab.uwe.ac.uk/your-username/example.git
 
-Read these urls carefully, and ensure that you are using the correct one going forward.
-
+> ***Read these urls carefully***, and ensure that you are using the correct one going forward.
 
 
 With a version of the repo forked for your own use, you can clone the repo and edit it locally.
 
-This is described in the **'Git Submissions'** resource [[here]](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556004-dt-content-rid-26598775_2/xid-26598775_2) which you should have read and can also be looked up in the 'Git Reference' resource sheet [[here]](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556005-dt-content-rid-26598776_2/xid-26598776_2). If you haven't, go through those sheets (as well as the [git intro](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556007-dt-content-rid-26598777_2/xid-26598777_2)) and you should be ready to tackle your first set of tasks.
-
-
+This is described in the **'Git Submissions'** resource [here](https://blackboard.uwe.ac.uk/ultra/courses/_358428_1/cl/outline) which you should have read and can also be looked up in the 'Git Reference' resource sheet [[here]](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556005-dt-content-rid-26598776_2/xid-26598776_2). If you haven't, go through those sheets (as well as the [git intro](https://blackboard.uwe.ac.uk/bbcswebdav/pid-8556007-dt-content-rid-26598777_2/xid-26598777_2)) and you should be ready to tackle your first set of tasks.
 
 # Tasks
 
-
-
 **Task 1**
 
 - Create a git repo locally and add a readme.md file
diff --git a/worksheets/worksheet2/worksheet2.md b/worksheets/worksheet2/worksheet2.md
index dccea89dcdc9ce035f81d92db76109f810942cc0..2a4d1d40c7c0872a026d9618098171b8856b7298 100644
--- a/worksheets/worksheet2/worksheet2.md
+++ b/worksheets/worksheet2/worksheet2.md
@@ -1,4 +1,3 @@
-```UFCFGL-30-1 Programming in c++```
 # Vars, expr & ; Worksheet(2)
 
 ```c++
@@ -18,7 +17,6 @@ The marking scheme for this session is as follows:
 - Task 4 : 0 Marks
 
 
-
 ## Variables
 
 Variables are values that we can refer to by name. By default, in C++ we can modify variables. 
@@ -39,10 +37,10 @@ char example;
 
  There are a number of primitive types available in c++.
 
-Types are discussed in this video ([here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=9c7ab01d-4e38-435e-9e59-ac5201055a03&instance=Blackboard)) but the following are common examples of types:
+Types are discussed in this video ([here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=9c7ab01d-4e38-435e-9e59-ac5201055a03)) but the following are common examples of types:
 
-- ```int``` - Integer numbers (whole numbers that truncate rather than rounding [[more]](https://techterms.com/definition/integer#:~:text=An%20integer%20is%20a%20whole,data%20type%20in%20computer%20programming.) 
-- ```float``` - floating point numbers (decimal numbers with some limitations [[more](https://techterms.com/definition/floatingpoint#:~:text=As%20the%20name%20implies%2C%20floating,decimal%20places%20are%20called%20integers.)]
+- ```int``` - Integer numbers (whole numbers that truncate rather than rounding [more](https://techterms.com/definition/integer#:~:text=An%20integer%20is%20a%20whole,data%20type%20in%20computer%20programming) )
+- ```float``` - floating point numbers (decimal numbers with some limitations [more](https://techterms.com/definition/floatingpoint#:~:text=As%20the%20name%20implies%2C%20floating,decimal%20places%20are%20called%20integers))
 - ```char``` - an 8bit value representing a single ascii character.
 - ```bool``` - a type representing either true or false
 
@@ -59,7 +57,6 @@ char three = '3';
 In each case, we must ensure that we provide the right type of data for the variable. Integers cannot have a decimal point, floats should. Characters can be written using single quotes. Therefore, the variable ```three``` actually contains the ascii character 3, not the numeric value 3.
 
 
-
 We can assign other variables to variables and use them where we can use a fixed value in expressions.
 
 ```c++
@@ -67,8 +64,7 @@ int x = 10;
 int y = x + 5;
 ```
 
- For more on expressions and the operators available in c++, see Ben's video on operators ([here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=2afae8bd-a465-4f33-bd29-ac52010559dc&instance=Blackboard)).
-
+ For more on expressions and the operators available in c++, see Ben's video on operators ([here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=2afae8bd-a465-4f33-bd29-ac52010559dc)).
 
 
 ## Expressions
@@ -99,7 +95,7 @@ An expression is simply the description of some computation using the available
 | **Equal to** | **Not equal** | **Greater than** | **Less than**  |
 |   ```==```   |   ```!=```    |     ```>```      |    ```<```     |
 
-> You should take some time to study and familiarize yourself with this more complete list [[here]](https://en.cppreference.com/w/cpp/language/expressions) of operators in C++, as you will need to use most of them!
+> You should take some time to study and familiarize yourself with this more complete list [here](https://en.cppreference.com/w/cpp/language/expressions)) of operators in C++, as you will need to use most of them!
 
 
 
@@ -157,7 +153,7 @@ Usually an expression will be used to assign to a variable, were the result of t
 int result = 4 + 4;
 ```
 
-> Note that care should be taken with the ```=``` assignment operator. Don't confuse it with ```==``` which is used for comparison. 
+> Note that care should be taken with the `=` assignment operator. Don't confuse it with `==` which is used for comparison. 
 
 
 
@@ -168,18 +164,14 @@ When programming, don't forget to create statements to sequence your code. If yo
 **Tasks 1 - 3:** Programming with expressions variables and statements.
 
 
-
 Tasks 1 - 3 are provided as a small c++ project. ***Fork*** and ***clone*** the following repo, write solutions and pass them to the relevant test functions.
 
-**Task Repo:** ```https://gitlab.uwe.ac.uk/ng-renney/worksheet2_tasks```
-
+[**Task Repo:**](https://gitlab.uwe.ac.uk/ng-renney/worksheet2_tasks) ```https://gitlab.uwe.ac.uk/ng-renney/worksheet2_tasks```
 
 
 Tasks are provided in code and you should follow the comments to provide solutions to all test functions.
 
-With this repo cloned, you should be able to use ```ctrl + shift + b``` (```cmd``` on OS X), to run the build task - however, note you must select the correct task for your platform each time. 
-
-*Remember to launch VS Code from the Developer console!*
+With this repo cloned, you should be able to use ```ctrl + shift + b``` (```cmd``` on OS X), to run the build task - however, note you must select the correct task for your platform. 
 
 
 
diff --git a/worksheets/worksheet3/worksheet3.md b/worksheets/worksheet3/worksheet3.md
index 72b83dba1d866966dfa48aeff401b21116dc8384..d5483ff8b81d42cdb971f6b6a569f6174f2f6eee 100644
--- a/worksheets/worksheet3/worksheet3.md
+++ b/worksheets/worksheet3/worksheet3.md
@@ -22,7 +22,9 @@ The marking scheme for this session is as follows:
 - Task 5 : 40 marks 
 - Task 6 : 0 marks 
 
-## 	
+  
+  ## Main
+  
 
 In this session, we will need to create a project from scratch.
 
@@ -114,19 +116,17 @@ There are four conditional statements in C++:
 
 We define an ```if``` and a corresponding ```else``` block as follows:
 
-> if (```condition```){
->
-> ​	// Code to be executed if condition is **true**
->
-> ​	// goes here (inside curly braces ```{}```)
->
-> } else {
->
-> ​	// Code to be executed if condition is **false**
->
-> ​	// goes here (inside curly braces ```{}```)
->
-> }
+
+```c++
+if (condition){
+// Code to be executed if condition is **true**
+// goes here - inside these curly braces { }
+} else {
+// Code to be executed if condition is **false**
+// goes here - inside curly braces { }
+}
+
+```
 
 
 
@@ -135,17 +135,21 @@ We can see some examples in the following block. They show the use of expression
 
 
 ```c++
+
+// we can directly write an expression with constants (although this isn't very useful)
 if ( 10 > 4){
   printf("Ten is greater that four\n");
 } else {
   printf("Ten is NOT greater that four!\n");
 }
 
+// a variable itself is a valid expression. So we can store the result of an expression in a variable and then use that variable as a condition for if 
 bool test_condition = (10 * 10) == (50 + 50);
 if (test_condition){
   printf("Condition is true\n");
 }
 
+// we can build epxressions entirely out of variables too...
 int a = 42;
 int b = 42;
 
@@ -163,7 +167,7 @@ if ( a > b ){
 
 Notice that, as conditional statements (```if``` & ```else```) are predefined statements, we do not need to use a semicolon to make them into statements! We do however need to ensure that the curly braces surround valid statements.
 
-For a more in depth look at using conditionals, see Ben's video [here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=0748132a-18f4-4135-aca0-ac520105598b&instance=Blackboard).
+For a more in depth look at using conditionals, see Ben's video [here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=0748132a-18f4-4135-aca0-ac520105598b).
 
 
 
@@ -227,7 +231,7 @@ void functionName(){
 
 A function is structured by first providing a ***return type***.
 
-Types are discussed in this video ([click here](https://www.youtube.com/watch?v=70TAcAJojPY&list=PLe2QYG8u2CjNi6aeW9x6-BDi5T-XJ1VLt&index=1)) but we can quickly define some for example:
+Types are discussed in in the previous worksheet but we can quickly define some for example:
 
 - ```int``` - Integer numbers (whole numbers that truncate rather than rounding [learn more](https://techterms.com/definition/integer#:~:text=An%20integer%20is%20a%20whole,data%20type%20in%20computer%20programming).
 
@@ -261,28 +265,32 @@ int main(){
 
 # Tasks
 
+For this worksheet, a single file for each program will be created, meaning you will create the following files yourself:
+- task1.cpp
+- task2.cpp
+- task3.cpp
+- task4.cpp
+- task5.cpp
 
+each file should have a program that can be built and run and should be stored inside a single git repo together.
 
-**Task 1 -** Write a program that prints "Hello World".
 
+**Task 1 -** Write a program that prints "Hello World".
 
 
 **Task 2 -** Print a message out 10 times using only a single print statement.
 
 
-
 **Task 3 -** Ask the user to input their name and then print back a greeting followed by their name.
 
 > This task includes the use of input and output. It will be discussed in the lectures and you are expected to research more on 
 
 
-
 **Task 4 -** Ask the user to input the number of times a statement should be printed. 
 
 >  Consider how you might want to validate the response the user provides. Marks will be awarded for handling of unsuitable input.
 
 
-
 **Task 5 -** Fizz Buzz
 
 Fizz Buzz is the age old interview entry level programming question...
@@ -294,10 +302,9 @@ Fizz Buzz is the age old interview entry level programming question...
 - Whenever a number is divisible by 5 print 'buzz' instead of the number.
 
 
-
 **Task 6 -** Check and commit
 
-Check you solutions, ensuring that a single file is supplied for each solution. Commit and push your solutions to you Gitlab repo using git.
+Check you solutions, ensuring that a single file is supplied for each solution. Create a repo, add these files and , commit and push your solutions to your Gitlab repo using git.
 
 
 
diff --git a/worksheets/worksheet4/worksheet4.md b/worksheets/worksheet4/worksheet4.md
index 1ace184c55677b582a9bf5c872fcb561e9b856c3..254b8ad85e4874f54a2f7db87359cf9bcbff0fda 100644
--- a/worksheets/worksheet4/worksheet4.md
+++ b/worksheets/worksheet4/worksheet4.md
@@ -1,4 +1,3 @@
-```UFCFGL-30-1 Programming in c++```
 # Conway's Game of Life
 
 ```c++
diff --git a/worksheets/worksheet5/worksheet5.md b/worksheets/worksheet5/worksheet5.md
index 009deeb4e968c46f7dcc4e6192bfb684f19e75d9..b0993c91a1305ad7bb7fd58673fb219b696c2b22 100644
--- a/worksheets/worksheet5/worksheet5.md
+++ b/worksheets/worksheet5/worksheet5.md
@@ -1,142 +1,211 @@
-```UFCFGL-30-1 Programming in c++```
-
 # Worksheet 5:
+## Stacks & RPN Calculator
 
-## Arrays, Strings and String Manipulation
+  
 
 ```c++
-#include <iostream>
-int main(){
-  	char title[9] = {'S','t','r','i','n','g','s','\n','\0'};
-		std::cout << title;
-    return 0;
+
+class Worksheet{
+
+public:
+
+Worksheet(int n){
+
+sessionNo = n;
+
+}
+
+void whatSession(){
+
+printf("Worksheet %d", sessionNo);
+
+}
+
+private:
+
+int sessionNo;
+
 };
-```
 
-The marking scheme for this session is as follows:
+  
 
-- Task 1 : 30 marks
-- Task 2 : 30 marks
-- Task 3 : 40 marks
-- Task 4 : 0 marks 
+int main(){
 
+Worksheet worksheet(6);
 
+worksheet.whatSession();
 
-A project is provided for you at the following link:
+return 0;
 
-https://gitlab.uwe.ac.uk/br-gaster/worksheet5_tasks
+}
 
+  
 
+```
 
-You will also **need to install Python** for this worksheet if you do not already have it.
+  
 
-https://www.python.org/downloads/windows/
+The marking scheme for this session is as follows:
 
+  
 
+- Task 1 : 40 marks
 
-## C Style Strings
+- Task 2 : 60 marks
 
-Whilst we have the option of using ```std::string``` in C++, it is important to understand how the C programming language represents strings too.
+- Task 3 : 0 marks
 
 
+# Stacks
 
-C uses arrays of characters as strings and denotes the end of a string with the 'null terminator' 
+  
+Stacks are a common data structure in computer science and is easily understood with an analogy. A stack can be described using the operations you can apply to a stack of plates, where every plate is a piece of data.
 
-character: ```\0```.
+When creating a stack of plates, you can only access the last plate that was placed on top of the stack. We describe this as being first in last out (abbreviated **FILO**). This is in contrast to something like a queue of people which would be First in First out.
 
-This means that a C string always needs to be oversized by one character to accommodate the null terminator.
+Given a stack of plates we can do the following:
 
-Fortunately, rather than having to initialise each element individually, we can use a string literal to assign to a ``` char``` array and the null terminator will automatically be added (so we just need to ensure the size is correct.)
 
-```c++
-char str[8] = "String\n";
-```
+- Add a plate to the top (push)
+
+- Take a plate from the top (pop)
 
+- Count the number of stacked plates (size)
 
+- Check if there are any plates at all (empty)
 
-This gives us the following array. Note that ```\n``` and ```\0``` are single characters as far as the compiler is concerned. 
+- Check if the stack is as high as is possible (full)
 
-| [0]  | [1]  | [2]  | [3]  | [4]  | [5]  | [6]  | [7]  |
-| :--: | :--: | :--: | :--: | :--: | :--: | :--: | ---- |
-|  S   |  t   |  r   |  i   |  n   |  g   |  \n  | \0   |
+  
+  
+These analogous operations represent the functions we require to implement a stack.
 
+  
+By then researching reverse Polish notation we can use the stack data structure to implement one and to see how useful stacks can actually be.
 
+# Notes on Classes
 
-## Accessing Array Elements / Manipulating Strings
 
+For an introduction to Classes you should watch the lecture [here](https://uwe.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=90cfe1db-c303-4dac-8250-ade700f7c3a5).
 
+  
 
-The most basic and common way to access elements in an array is using a variable as an index into the array. Using a ```for``` loop, we can increment the variable to move through the range of accepted values.
+### Using a class
 
-As we know, we can declare and increment a variable a for loop (see previous worksheets and videos to revise the for loop if you are unsure). By ensuring we count up to one less that the length of a string (remember elements start at zero), we can use this variable as the index.
+  
 
-Here's an example where we get the length of a string by using the ```strlen()``` function (found in ```#include <cstring>```):
+Remember, as discussed in a lecture. Writing a class is like a blueprint. To use you class you need to create an instance of a class (in a similar way to how you declare a variable). You do this by providing the name of the class and then a name for you instance:
+
+  
 
 ```c++
-char str[8] = "String\n";
-int len = std::strlen(str);
-for(int i = 0; i < len; i++){
-	std::cout << "letter at pos: " << i << " is: " << str[i] <<'\n';
-}
+
+ClassName instance_name;
+
 ```
 
-> Note ```strlen``` counts up to a null terminator, but does not include it. This means that we can leave it unaffected and continue to use the string as a null terminated c string. For use with other arrays, ```sizeof()``` should be used.
+  
+  
+  
+
+To call member functions, you will need to use the scope operator:
 
+  
 
+```c++
 
-Instead of printing using c++, you can manipulate a string by accessing the individual elements (in this example using ```str[i]``` for the current element in the array called ```str```). You can then assign to this value using the assignment operator ```=```.
+instance_name.function_call();
 
+```
 
+### Classes split between ```hpp``` and ```cpp```
 
-For example, we can replace each character with an x, using the following code:
+Often, classes are split with declarations in ```.hpp``` files and the corresponding definitions for any member functions in a ```.cpp``` file.
+
+This typically results in the following code:
+#### example.hpp
 
 ```c++
-char str[8] = "String\n";
-int len = std::strlen(str);
-for(int i = 0; i < len; i++){
-	 str[i] = 'x';
-}
-std::cout << str <<'\n';
-```
 
+class Example {
 
+private:
 
-## Cyphers
+int data_member;
 
+public:
 
+int get_data();
 
-What is Caesar Cipher?
+void set_data(int x);
 
-Supposedly, Caesar (yes, that Caesar) used to "encrypt" (i.e., conceal in a reversible way) confidential messages by shifting each letter therein by some number of places. For instance, he might write A as B, B as C, C as D, …, and, wrapping around alphabetically, Z as A. And so, to say HELLO to someone, Caesar might write IFMMP. Upon receiving such messages from Caesar, recipients would have to "decrypt" them by shifting letters in the opposite direction by the same number of places.
+};
 
-The secrecy of this "cryptosystem" relied on only Caesar and the recipients knowing a secret, the number of places by which Caesar had shifted his letters (e.g., 1). Not particularly secure by modern standards, but, hey, if you’re perhaps the first in the world to do it, pretty secure!
+```
 
+#### example.cpp
 
+```c++
 
-Unencrypted text is generally called plaintext. Encrypted text is generally called ciphertext. And the secret used is called a key.
+#include "Example.hpp"
 
- 
+  
 
-For more details check out the Wikipedia page:  https://en.wikipedia.org/wiki/Caesar_cipher
+int Example::get_data(){
 
+return data_member;
 
+}
 
+void Example::set_data(int x){
+
+data_member = x;
+
+}
+
+```
+
+Note that in order for the function definitions in the ```.cpp``` file to access the internal members of the class (and appropriately define the member functions) the classes namespace is added to the function name with the ```::``` scope operator. For this to work, the ```.hpp``` file **must** be included.
 
 # Tasks
-> Note that completing the initials and attempting the Caesar cypher is enough to pass this worksheet. The substitution cipher is intended as an extended challenge that requires independent research and learning.
+
+To compile your program, you will need to select the main file and compile from there. Your program will not do anything unless you comment in/out the relevant functions. Use the ```test_stack();``` function when working on task 1 and then ensure you call the ```run();``` function to run your server and test the ```run_eval()``` function.
+
+
+All of the files you will need to work on are found in the ```tasks/``` directory.
+
+Please also refer to the Readme.md that you can view on the gitlab page for your project. 
+
+ **Task 1 -** Implement a stack using the provided class as a starting point.
+
+  
+
+- You can find the empty stack class in the tasks directory, in files ```stack.hpp``` & ```stack.cpp```.
+
+- You need to create a class that manages a stack of at least 256 ```integers```.
+
+- You will need to add appropriate member variable(s) to ```stack.hpp```
+
+- You will need to add appropriate function definitions to ```stack.cpp```
 
 
-**Task 1 -** Implement the initials function that given a string, returns a users initials.
+**Task 2 -** Using your stack class, implement the reverse polish notation calculator.
 
+  
 
+- You can find a good explanation of RPN in the related [wikipedia article (here)](https://en.wikipedia.org/wiki/Reverse_Polish_notation) and the popular computer science Youtube channel Computerphile also has an excellent video on how RPN is related to stacks [here](https://www.youtube.com/watch?v=7ha78yWRDlE).
 
-**Task 2 -** Implement Caesar Cypher
+- You need to implement the ```rpn_eval(std::string expr)``` function, found in ```rpn.cpp```. This function receives the expression that is input in the web client and you should return the answer as a string.
 
+- Note that this with require converting from string to a number then back to a string.
 
+- You should use your stack class to implement rpn
 
-**Task 3 -** Implement a Substitution Cypher
+- Push on any numbers in the expression
 
+- When an operator is found, pop the values off and apply the operator to them
 
+- Push the result back onto the stack and continue to push any remaining values in the expression
 
-**Task 4 -** Commit and push to git 
 
+**Task 3 -** Commit and push your code to gitlab
\ No newline at end of file