From 8d80d61d2763acb17ef1875fc1dbf0bf173fe907 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Mon, 7 Sep 2026 09:44:21 +0200
Subject: [PATCH 01/21] Added assigment to lists.md lesson

---
 curriculum/05-data-structures/01-list.md | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/curriculum/05-data-structures/01-list.md b/curriculum/05-data-structures/01-list.md
index 64d3e43..1f82310 100644
--- a/curriculum/05-data-structures/01-list.md
+++ b/curriculum/05-data-structures/01-list.md
@@ -160,7 +160,26 @@ Learn more about Python Lists from these resources:
 Complete [Exercise 05 — The Cozy Bakery Inventory](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
 
 ## Assignment {#assignment}
-**Todo**
+1. Replace `item_name`, `item_price` and `item_stock` static values with an empty list.
+2. In *infinite loop* ask the user to fill up the inventory by typing in a name, price and stock level of item.
+    * If user types **empty string**, break out of the loop and continue with program execution.
+    * User should enter all of the information on the same line. Use `.split()` method on the inputed string to catch all information needed. **Do not forget** to cast `price` to `float` and `stock` to `integer`.
+    * Append every information to their own respective list.
+3. Display the inventory by using `zip()` function and combining all three lists to display items one by one.
+4. Create variable `order` and assign it an empty list.
+5. Create another *infinite loop* and inside the loop ask the user to enter the name of the item he wants to buy.
+    * If user enters empty string, break out of the loop.
+    * If the item user entered is in the `item_name` list, find its index position and assign it to variable, otherwise inform the user that there is no such item at the moment, and **continue** with next iteration of loop
+    * When you have an index of the item user asked, ask the user to enter quantity of the items. Check if entered item quantity is not bigger then actual item stock and if it is, tell the user that we do not have that many items in stock, then **continue** with new iteration.
+    * If we have the item and have enough of stock, add the total for item (item price multiplied by quantity) to `order` list.
+    * Decrease the stock number of items by the quantity ammount and if item stock reaches 0, remove the item (and its relevant info) from the inventory lists.
+6. Calculate the total by adding all the numbers in `order` list using `sum()` function and calculate whether to give 10% discount (if `total > 100`).
+7. Print out the final receipt in the following format:
+    ```
+    Your total is: $<total>
+    ```
+8. Print the inventory after shopping.
+9. Make sure your application works correctly, commit the changes and push your code to Github.
 
 ## What's Next {#next-lesson}
 Lists are ordered and mutable, which makes them ideal for collections that grow or change over time. But what if you need an ordered collection that **cannot** be modified once created?

From 3314b18dc6856aadd993f16099720d4c8043abe2 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Mon, 7 Sep 2026 09:47:00 +0200
Subject: [PATCH 02/21] Changed assigment in lesson 03-user-input to better
 follow the storyline

---
 .../03-user-input-and-conditionals.md         | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/curriculum/04-python-foundations/03-user-input-and-conditionals.md b/curriculum/04-python-foundations/03-user-input-and-conditionals.md
index 1352303..0f2a698 100644
--- a/curriculum/04-python-foundations/03-user-input-and-conditionals.md
+++ b/curriculum/04-python-foundations/03-user-input-and-conditionals.md
@@ -94,20 +94,15 @@ Now that you know how to get user input and branch your program using conditiona
 
 **Goal:** use `input()` to collect user choices, cast strings to numbers, and use conditional logic to apply discounts and stock checks.
 
-1. Open `main.py` file in our `simple-python-shop` project directory.
-2. Add a new variable `item_stock` and set it to some integer
-3. Interactive input: 
-    * Ask the user for desired `item_quantity` using `input()`. **Don't forget** to cast the string to integer !
-4. Stock & Availability Check
-    * If `item_quantity` is less or equal to `0` print an error message: `Invalid quantity ordered`
-    * If `item_quantity` is greater then `item_stock` print `Sorry, we do not have enough stock.`
-5. Dynamic discount (conditionals)
-    * Calculate the total (you should have this from the last lesson)
-    * If `total` is over `100` apply a **10%** discount (`total * 0.90`) and print: `Discount applied: 10%`
-    * Otherwise print: `No discount applied`
-6. Receipt Output
-    * Output the final receipt showing item name, quantity, applied discount state, and final amount due.
-7. Commit and push your updated code to Github.
+Open `main.py` in your `simple-python-shop` project.
+1. Set `item_quantity` to `0` as its initial value and remove `item_price` variable.
+2. Use a `while` loop to repeatedly prompt the user for an item price.
+    * If the price entered is less then 0, print message saying `Invalid price, must be positive`, and skipping the rest of the iteration code, asking user again to enter the price.
+    * Otherwise check if the price entered is 0 and if so, break out of the loop.
+    * Otherwise, check if `item_stock - item_quantity` is more than `1` and if not, break out of the loop, informing the user we are out of stock.
+    * Otherwise, add the price user entered to `total` and increment `item_quantity` by 1.
+3. When the loop finishes, determine if the `total` can have a discount and print out the final receipt.
+4. Make sure your program works, then commit and push your code
 
 ## Deepen Your Knowledge
 * Learn more about [Indentation in Python](https://realpython.com/ref/glossary/indentation/) from this **Real Python** article

From 5a8276cd3ca7596a32afea9a52ee59f110bf619e Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Mon, 7 Sep 2026 09:49:07 +0200
Subject: [PATCH 03/21] Changed assigment in lesson 02-math-string-ops to
 better follow storyline

---
 .../02-math-stringops-comparisons.md          | 40 +++++++++----------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/curriculum/04-python-foundations/02-math-stringops-comparisons.md b/curriculum/04-python-foundations/02-math-stringops-comparisons.md
index 5564b2a..15fcc55 100644
--- a/curriculum/04-python-foundations/02-math-stringops-comparisons.md
+++ b/curriculum/04-python-foundations/02-math-stringops-comparisons.md
@@ -215,28 +215,24 @@ print(not True) # False
 Try to solve [excercise-3](https://github.com/ThePythonLedger/python-exercises/tree/main/exercises%2Ffoundations%2F03_math_and_comparisons) for better understanding.
 
 ## Assignment
-In the last assignment we have declared our shop variables and printed the inventory. In this one you are tasked with:
-1. Open your code editor in your last project directory `simple-python-shop`
-2. Open `main.py` file we have been working on
-3. Standardize your strings:
-    * Convert `shop_name` to **uppercase** (e.g., `MERLIN SHOP`)
-    * Convert item name to **titlecase** (e.g., `Excalibur`)
-4. Calculate the checkout price:
-    * Create variable `total` by multiplying `item_price` and `item_quantity`
-5. Comparison checks:
-    * Create a boolean `is_large_order` that evaluates whether `item_quantity` is greater then or equal to `3`.
-6. Update your output to use **f-string** :
-    ```
-    Welcome to MERLIN SHOP
-    --------------------------------
-    Item: Excalibur
-    Purchased: 3 x 67.20
-    Total: $201.60
-    Large Order: True
-    --------------------------------
-    Thank you for your purchase !
-    ```
-7. Commit your changes with `git` and push to Github
+Now that you know how to get user input and branch your program using conditional logic (`if`, `elif`, `else`) the code can move away from hardcoded values and become interactive. 
+
+**Goal:** use `input()` to collect user choices, cast strings to numbers, and use conditional logic to apply discounts and stock checks.
+
+1. Open `main.py` file in our `simple-python-shop` project directory.
+2. Add a new variable `item_stock` and set it to some integer
+3. Interactive input: 
+    * Ask the user for desired `item_quantity` using `input()`. **Don't forget** to cast the string to integer !
+4. Stock & Availability Check
+    * If `item_quantity` is less or equal to `0` print an error message: `Invalid quantity ordered`
+    * If `item_quantity` is greater then `item_stock` print `Sorry, we do not have enough stock.`
+5. Dynamic discount (conditionals)
+    * Calculate the total (you should have this from the last lesson)
+    * If `total` is over `100` apply a **10%** discount (`total * 0.90`) and print: `Discount applied: 10%`
+    * Otherwise print: `No discount applied`
+6. Receipt Output
+    * Output the final receipt showing item name, quantity, applied discount state, and final amount due.
+7. Commit and push your updated code to Github.
 
 ## Deepen Your Knowledge
 1. Learn more about [Basic math in Python](https://cs.stanford.edu/people/nick/py/python-math.html#math) from article in **Stanford University**, covering all the topics in this lesson but in a different style and a bit more.

From 29373ffff0c27eb40e05bef788ec2b61d15bba56 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Mon, 7 Sep 2026 09:55:43 +0200
Subject: [PATCH 04/21] Fixed assigments due to mistake in copy-paste

---
 .../01-output-variable-datatypes.md           |  2 +-
 .../02-math-stringops-comparisons.md          | 40 ++++++++++---------
 .../03-user-input-and-conditionals.md         | 23 ++++++-----
 curriculum/04-python-foundations/04-loops.md  |  8 ++--
 4 files changed, 42 insertions(+), 31 deletions(-)

diff --git a/curriculum/04-python-foundations/01-output-variable-datatypes.md b/curriculum/04-python-foundations/01-output-variable-datatypes.md
index d794ab4..be93b37 100644
--- a/curriculum/04-python-foundations/01-output-variable-datatypes.md
+++ b/curriculum/04-python-foundations/01-output-variable-datatypes.md
@@ -185,7 +185,7 @@ You will need to do this assignment on your own machine.
     Item price: $67.2
     Item available: True
     ```
-7. Make sure your program works as expected then create a repository and push your code to github
+7. Make sure your program works as expected then create a repository and push your code to Github.
 
 ## Deepen Your Knowlege
 Go through these articles to deepen your knowlege about the topics covered in this lesson.
diff --git a/curriculum/04-python-foundations/02-math-stringops-comparisons.md b/curriculum/04-python-foundations/02-math-stringops-comparisons.md
index 15fcc55..5c8ffff 100644
--- a/curriculum/04-python-foundations/02-math-stringops-comparisons.md
+++ b/curriculum/04-python-foundations/02-math-stringops-comparisons.md
@@ -215,24 +215,28 @@ print(not True) # False
 Try to solve [excercise-3](https://github.com/ThePythonLedger/python-exercises/tree/main/exercises%2Ffoundations%2F03_math_and_comparisons) for better understanding.
 
 ## Assignment
-Now that you know how to get user input and branch your program using conditional logic (`if`, `elif`, `else`) the code can move away from hardcoded values and become interactive. 
-
-**Goal:** use `input()` to collect user choices, cast strings to numbers, and use conditional logic to apply discounts and stock checks.
-
-1. Open `main.py` file in our `simple-python-shop` project directory.
-2. Add a new variable `item_stock` and set it to some integer
-3. Interactive input: 
-    * Ask the user for desired `item_quantity` using `input()`. **Don't forget** to cast the string to integer !
-4. Stock & Availability Check
-    * If `item_quantity` is less or equal to `0` print an error message: `Invalid quantity ordered`
-    * If `item_quantity` is greater then `item_stock` print `Sorry, we do not have enough stock.`
-5. Dynamic discount (conditionals)
-    * Calculate the total (you should have this from the last lesson)
-    * If `total` is over `100` apply a **10%** discount (`total * 0.90`) and print: `Discount applied: 10%`
-    * Otherwise print: `No discount applied`
-6. Receipt Output
-    * Output the final receipt showing item name, quantity, applied discount state, and final amount due.
-7. Commit and push your updated code to Github.
+In the last assignment we have declared our shop variables and printed the inventory. In this one you are tasked with:
+1. Open your code editor in your last project directory `simple-python-shop`
+2. Open `main.py` file we have been working on
+3. Standardize your strings:
+    * Convert `shop_name` to **uppercase** (e.g., `MERLIN SHOP`)
+    * Convert item name to **titlecase** (e.g., `Excalibur`)
+4. Calculate the checkout price:
+    * Create variable `total` by multiplying `item_price` and `item_quantity`
+5. Comparison checks:
+    * Create a boolean `is_large_order` that evaluates whether `item_quantity` is greater then or equal to `3`.
+6. Update your output to use **f-string** :
+    ```
+    Welcome to MERLIN SHOP
+    --------------------------------
+    Item: Excalibur
+    Purchased: 3 x 67.20
+    Total: $201.60
+    Large Order: True
+    --------------------------------
+    Thank you for your purchase !
+    ```
+7. Commit your changes with `git` and push to Github.
 
 ## Deepen Your Knowledge
 1. Learn more about [Basic math in Python](https://cs.stanford.edu/people/nick/py/python-math.html#math) from article in **Stanford University**, covering all the topics in this lesson but in a different style and a bit more.
diff --git a/curriculum/04-python-foundations/03-user-input-and-conditionals.md b/curriculum/04-python-foundations/03-user-input-and-conditionals.md
index 0f2a698..1352303 100644
--- a/curriculum/04-python-foundations/03-user-input-and-conditionals.md
+++ b/curriculum/04-python-foundations/03-user-input-and-conditionals.md
@@ -94,15 +94,20 @@ Now that you know how to get user input and branch your program using conditiona
 
 **Goal:** use `input()` to collect user choices, cast strings to numbers, and use conditional logic to apply discounts and stock checks.
 
-Open `main.py` in your `simple-python-shop` project.
-1. Set `item_quantity` to `0` as its initial value and remove `item_price` variable.
-2. Use a `while` loop to repeatedly prompt the user for an item price.
-    * If the price entered is less then 0, print message saying `Invalid price, must be positive`, and skipping the rest of the iteration code, asking user again to enter the price.
-    * Otherwise check if the price entered is 0 and if so, break out of the loop.
-    * Otherwise, check if `item_stock - item_quantity` is more than `1` and if not, break out of the loop, informing the user we are out of stock.
-    * Otherwise, add the price user entered to `total` and increment `item_quantity` by 1.
-3. When the loop finishes, determine if the `total` can have a discount and print out the final receipt.
-4. Make sure your program works, then commit and push your code
+1. Open `main.py` file in our `simple-python-shop` project directory.
+2. Add a new variable `item_stock` and set it to some integer
+3. Interactive input: 
+    * Ask the user for desired `item_quantity` using `input()`. **Don't forget** to cast the string to integer !
+4. Stock & Availability Check
+    * If `item_quantity` is less or equal to `0` print an error message: `Invalid quantity ordered`
+    * If `item_quantity` is greater then `item_stock` print `Sorry, we do not have enough stock.`
+5. Dynamic discount (conditionals)
+    * Calculate the total (you should have this from the last lesson)
+    * If `total` is over `100` apply a **10%** discount (`total * 0.90`) and print: `Discount applied: 10%`
+    * Otherwise print: `No discount applied`
+6. Receipt Output
+    * Output the final receipt showing item name, quantity, applied discount state, and final amount due.
+7. Commit and push your updated code to Github.
 
 ## Deepen Your Knowledge
 * Learn more about [Indentation in Python](https://realpython.com/ref/glossary/indentation/) from this **Real Python** article
diff --git a/curriculum/04-python-foundations/04-loops.md b/curriculum/04-python-foundations/04-loops.md
index 4489eab..c3f5ac7 100644
--- a/curriculum/04-python-foundations/04-loops.md
+++ b/curriculum/04-python-foundations/04-loops.md
@@ -122,10 +122,12 @@ These statements `break` and `continue` work only in loops. If you try to use th
 
 ## Assigment
 1. Open `main.py` in your `simple-python-shop` project.
-2. Create a new variable named `item_count` and set it to `0` as its initial value.
+2. Set `item_quantity` to `0` as its initial value and remove `item_price` variable.
 3. Use a `while` loop to repeatedly prompt the user for an item price.
-    * If the price entered is 0 break out of the loop
-    * Otherwise, add the price user entered to `total` and increment `item_count` by 1.
+    * If the price entered is less then 0, print message saying `Invalid price, must be positive`, and skipping the rest of the iteration code, asking user again to enter the price.
+    * Otherwise check if the price entered is 0 and if so, break out of the loop.
+    * Otherwise, check if `item_stock - item_quantity` is more than `1` and if not, break out of the loop, informing the user we are out of stock.
+    * Otherwise, add the price user entered to `total` and increment `item_quantity` by 1.
 4. When the loop finishes, determine if the `total` can have a discount and print out the final receipt.
 5. Make sure your program works, then commit and push your code
 

From d72917c7b06e5424d3a6bcb5f16a2b0ba7c839e0 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Mon, 7 Sep 2026 11:32:55 +0200
Subject: [PATCH 05/21] Updated Learn More resources

---
 curriculum/05-data-structures/01-list.md  | 10 ++++------
 curriculum/05-data-structures/02-tuple.md |  4 ++--
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/curriculum/05-data-structures/01-list.md b/curriculum/05-data-structures/01-list.md
index 1f82310..97da206 100644
--- a/curriculum/05-data-structures/01-list.md
+++ b/curriculum/05-data-structures/01-list.md
@@ -148,16 +148,14 @@ for item in a:
 This is very useful as we often need to work with specific elements from the list.
 
 :::explore[Learn more about Python lists]
-
 Learn more about Python Lists from these resources:
-* [Google for Education - Python Lists](https://developers.google.com/edu/python/lists)
-* [Official Python Documentation on Lists](https://docs.python.org/3/library/stdtypes.html#typesseq-list)
-* [Official Python Documentation on Data Structures - more on Lists](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)
-
+* Learn about `zip()` function from [zip() function - RealPython](https://realpython.com/ref/builtin-functions/zip/) and [zip() function - official Python Documentation](https://docs.python.org/3.3/library/functions.html#zip) that allows for combining of multiple lists (or other iterables as we will see later) by producing **tuples** (we cover these in the next lesson)
+* Learn about `.sort()` method from [official Python Documentation](https://docs.python.org/3/library/stdtypes.html#list.sort) which is very useful in sorting lists in-place. Sorting iterables is a very useful tehnique and there are multiple arguments and ways to sort iterables in Python. Be sure to read this [Sorting Tehniques - official Python documentation](https://docs.python.org/3/howto/sorting.html) to familiarize yourself with tehniques used.
+* Go thrue all the available methods on the lists in [More on Lists - official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists), as these will come in handy when working on your projects. You do not need to remember them all, but just read thrue them and their intended purpouse so you will know what is out there.
 :::
 
 ## Exercise
-Complete [Exercise 05 — The Cozy Bakery Inventory](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
+Complete [[TODO] Exercise 05 — The Cozy Bakery Inventory](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
 
 ## Assignment {#assignment}
 1. Replace `item_name`, `item_price` and `item_stock` static values with an empty list.
diff --git a/curriculum/05-data-structures/02-tuple.md b/curriculum/05-data-structures/02-tuple.md
index d97d13e..022cac4 100644
--- a/curriculum/05-data-structures/02-tuple.md
+++ b/curriculum/05-data-structures/02-tuple.md
@@ -7,7 +7,6 @@ lesson: true
 isDraft: true
 ---
 # Tuple
-## Introduction {#introduction}
 Tuple is an ordered and immutable collection data structure. **Ordered** meaning it keeps the order of elements in which they are inserted, and **immutable** means that once the tuple is created it cannot change, and you cannot add or remove elements from it.
 
 ## Lesson Overview {#overview}
@@ -39,7 +38,7 @@ print(f"First element: {a[0]} - Last element: {a[-1]}")
 ```
 
 ## Useful methods
-Unlike functions, as we cannot modify tuples, we don't have a lot of methods available to us, but we will list a few.
+Unlike lists, as we cannot modify tuples, we don't have a lot of methods available to us, but we will list a few.
 * `count()` - returns the number of times a specified value appears in tuple.
     ```python interactive
     numbers = (1, 2, 3, 3, 3, 4, 5)
@@ -52,6 +51,7 @@ Unlike functions, as we cannot modify tuples, we don't have a lot of methods ava
     ```
 
 :::explore[Learn more about Python Tuples]
+Read these resources to learn more about tuples in Python:
 * [Python built-in types: tuples from RealPython](https://realpython.com/ref/builtin-types/tuple/)
 * [Tuples and Sequences from official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)
 :::

From 48a2aa554b12333cabd0849afa9ae8b09372d4b1 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Thu, 10 Sep 2026 19:30:45 +0200
Subject: [PATCH 06/21] Added assigment and closing words to tuples lesson

---
 curriculum/05-data-structures/01-list.md  | 19 ++++++++++---------
 curriculum/05-data-structures/02-tuple.md | 17 +++++++++++++++--
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/curriculum/05-data-structures/01-list.md b/curriculum/05-data-structures/01-list.md
index 97da206..013a0d0 100644
--- a/curriculum/05-data-structures/01-list.md
+++ b/curriculum/05-data-structures/01-list.md
@@ -158,26 +158,27 @@ Learn more about Python Lists from these resources:
 Complete [[TODO] Exercise 05 — The Cozy Bakery Inventory](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
 
 ## Assignment {#assignment}
-1. Replace `item_name`, `item_price` and `item_stock` static values with an empty list.
-2. In *infinite loop* ask the user to fill up the inventory by typing in a name, price and stock level of item.
+1. Open `main.py` file in our `simple-python-shop` directory
+2. Replace `item_name`, `item_price` and `item_stock` static values with an empty list.
+3. In *infinite loop* ask the user to fill up the inventory by typing in a name, price and stock level of item.
     * If user types **empty string**, break out of the loop and continue with program execution.
     * User should enter all of the information on the same line. Use `.split()` method on the inputed string to catch all information needed. **Do not forget** to cast `price` to `float` and `stock` to `integer`.
     * Append every information to their own respective list.
-3. Display the inventory by using `zip()` function and combining all three lists to display items one by one.
-4. Create variable `order` and assign it an empty list.
-5. Create another *infinite loop* and inside the loop ask the user to enter the name of the item he wants to buy.
+4. Display the inventory by using `zip()` function and combining all three lists to display items one by one.
+5. Create variable `order` and assign it an empty list.
+6. Create another *infinite loop* and inside the loop ask the user to enter the name of the item he wants to buy.
     * If user enters empty string, break out of the loop.
     * If the item user entered is in the `item_name` list, find its index position and assign it to variable, otherwise inform the user that there is no such item at the moment, and **continue** with next iteration of loop
     * When you have an index of the item user asked, ask the user to enter quantity of the items. Check if entered item quantity is not bigger then actual item stock and if it is, tell the user that we do not have that many items in stock, then **continue** with new iteration.
     * If we have the item and have enough of stock, add the total for item (item price multiplied by quantity) to `order` list.
     * Decrease the stock number of items by the quantity ammount and if item stock reaches 0, remove the item (and its relevant info) from the inventory lists.
-6. Calculate the total by adding all the numbers in `order` list using `sum()` function and calculate whether to give 10% discount (if `total > 100`).
-7. Print out the final receipt in the following format:
+7. Calculate the total by adding all the numbers in `order` list using `sum()` function and calculate whether to give 10% discount (if `total > 100`).
+8. Print out the final receipt in the following format:
     ```
     Your total is: $<total>
     ```
-8. Print the inventory after shopping.
-9. Make sure your application works correctly, commit the changes and push your code to Github.
+9. Print the inventory after shopping.
+10. Make sure your application works correctly, commit the changes and push your code to Github.
 
 ## What's Next {#next-lesson}
 Lists are ordered and mutable, which makes them ideal for collections that grow or change over time. But what if you need an ordered collection that **cannot** be modified once created?
diff --git a/curriculum/05-data-structures/02-tuple.md b/curriculum/05-data-structures/02-tuple.md
index 022cac4..9ff40f0 100644
--- a/curriculum/05-data-structures/02-tuple.md
+++ b/curriculum/05-data-structures/02-tuple.md
@@ -56,8 +56,21 @@ Read these resources to learn more about tuples in Python:
 * [Tuples and Sequences from official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)
 :::
 
+## Exercise
+Complete [[TODO] Exercise 06 — WorkingTitle](#) to practice tuples.
+
 ## Assignment {#assignment}
-**Todo**
+Using lists to separatly hold multiple related values is brittle and will break if you do not pay attention to all lists containing data. In this assigment we will deal with those issues by using tuples.
+
+1. Open our `main.py` file we have been working on
+2. Create a new empty list called `inventory`. This will hold tuples of related data `(product_name, product_price, product_stock)`.
+3. Delete previusly defined `item_name`, `item_price` and `item_stock` variables, we wont need them anymore.
+4. Just like before, in **infinite loop**, first check if the input is an *empty string* and if it is, break out of the loop, otherwise get the users input containing *name*, *price* and *stock* in a single line, then split the line using `split()` method to get a list of inputed data.
+5. Instead of appending each data to their own list, create a tuple called `item` containing `name`, `price` and `stock` in that particular order and append that to our `inventory` list we declared earlier. Print out each `inventory` element using `for` loop.
+6. On to customer ordering items now. Keep `order` list and instead of storing only totals for each item, we will now store `item_name`, `item_quantity` and `line_total` in **tuple** called `line_item` and append that to our `order` list so our shop can better keep track of the orders. **Keep in mind** - tuples are *immutable* which means that you will have to reduce `stock` of the item by replacing entire tuple with new `stock` value.
+7. Same as before, calculate the `total` for all the items bought, apply a 10% discount if the `total` is over 100.
+8. In the end, print out the inventory, to make sure that the items are actually removed once bought.
+9. Make sure your program runs, then commit the changes and push to Github
 
 ## What's Next {#next-lesson}
-**Todo**
\ No newline at end of file
+Now that you have seen data structures that can contain duplicates, it's time to meet **set** - a unique data structure that does not allows for duplicates.
\ No newline at end of file

From 519f228a34c96a9004bec50d3b1c15b2d276043e Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Thu, 10 Sep 2026 20:14:40 +0200
Subject: [PATCH 07/21] Added assigment for lesson on sets

---
 curriculum/05-data-structures/03-set.md | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/curriculum/05-data-structures/03-set.md b/curriculum/05-data-structures/03-set.md
index e172981..1fbf56b 100644
--- a/curriculum/05-data-structures/03-set.md
+++ b/curriculum/05-data-structures/03-set.md
@@ -78,8 +78,16 @@ Learn more about sets in these materials:
 * [Python data structures: set from official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#sets)
 :::
 
+## Exercise
+Complete [[TODO] Exercise 07 — WorkingTitle](#) to practice sets.
+
 ## Assignment {#assignment}
-**Todo**
+In this assigment our task is simple one. We need to track distinct *unsold* items so we can better prepare for the next day in our little shop.
+
+1. Open `main.py` file we have been working on.
+2. Define a set for all **sold items** (`item[0]` of element in `order` list) and define a set of **all inventory items** (`item[0]` of element in `inventory` list) - you can use set coprehension to do this in one line or use a for loop to iterate over each item in the lists.
+3. Create a variable `unsold_items` and set its value to be `sold_items` substracted from `all_inventory_items`
+4. Print out items that did not have a sale today.
 
 ## What's Next {#next-lesson}
-**Todo**
\ No newline at end of file
+Now that we covered index based data structures, it's time to meet **dictionary** which is unique in its *key-value* approach and is probably most used data structure (besides *lists*).
\ No newline at end of file

From 9c0f4aa40fb6dd8461c2b49cd63e5faa048f33e3 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Thu, 10 Sep 2026 21:12:55 +0200
Subject: [PATCH 08/21] Fixed assigment in set lesson and added assigment to
 dictionary lesson

---
 curriculum/05-data-structures/03-set.md       |  1 +
 .../05-data-structures/04-dictionary.md       | 19 +++++++++++++++----
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/curriculum/05-data-structures/03-set.md b/curriculum/05-data-structures/03-set.md
index 1fbf56b..1d575c2 100644
--- a/curriculum/05-data-structures/03-set.md
+++ b/curriculum/05-data-structures/03-set.md
@@ -88,6 +88,7 @@ In this assigment our task is simple one. We need to track distinct *unsold* ite
 2. Define a set for all **sold items** (`item[0]` of element in `order` list) and define a set of **all inventory items** (`item[0]` of element in `inventory` list) - you can use set coprehension to do this in one line or use a for loop to iterate over each item in the lists.
 3. Create a variable `unsold_items` and set its value to be `sold_items` substracted from `all_inventory_items`
 4. Print out items that did not have a sale today.
+5. Confirm the program works, commit and push to Github
 
 ## What's Next {#next-lesson}
 Now that we covered index based data structures, it's time to meet **dictionary** which is unique in its *key-value* approach and is probably most used data structure (besides *lists*).
\ No newline at end of file
diff --git a/curriculum/05-data-structures/04-dictionary.md b/curriculum/05-data-structures/04-dictionary.md
index 7b6378b..9b6c7fa 100644
--- a/curriculum/05-data-structures/04-dictionary.md
+++ b/curriculum/05-data-structures/04-dictionary.md
@@ -124,12 +124,23 @@ for key, value in mydict.items():
     print(key, value)
 ```
 
-
+## Exercise
+Complete [[TODO] Exercise 08 — WorkingTitle](#) to practice dictionaries.
 
 ## Assignment {#assignment}
-
+In this assignment, we will completely eliminate list index tracking by refactoring our inventory into a dictionary, mapping each product name directly to its price and stock.
+
+1. Open `main.py` in our project directory.
+2. Replace `inventory` list with an empty dictionary `{}`.
+3. When reading users input, assign the item directly to dictionary `inventory`.
+    ```python
+    inventory[name] = {"price": price, "stock": stock}
+    ```
+4. In customer order, look up if item is in the inventory directly with `if item_name in inventory`, verify stock availability with `inventory[item_name]["stock"]` and update stock count in place with `inventory[item_name]["stock"] -= 1` and if stock reaches `0` then delete the item from the inventory using `del inventory[item_name]`.
+5. Keep `order` as a list of tuples, and update the `unsold_items` variable to check between keys of the dictionary and tuple elements - use `inventory.keys()` to get a *tuple-like* object of dictionary keys that you can use in this case to substract `order` elements from keys of dictionary.
+6. Test your application, make sure it works, commit and push to Github.
 
 ## Deepen Your Knowlege {#learn-more}
 
-
-## What's Next {#next-lesson}
\ No newline at end of file
+## What's Next {#next-lesson}
+We are now done with basic data structures in Python, next we move on to something even more fun and useful; **functions**. 
\ No newline at end of file

From f8b636df267d42dfe725337d87d431bff1320147 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Sat, 12 Sep 2026 09:33:50 +0200
Subject: [PATCH 09/21] Updated lists lessons and ROADMAPmd

---
 ROADMAP.md                               | 92 ++++++++++++++++--------
 curriculum/05-data-structures/01-list.md |  2 +-
 2 files changed, 62 insertions(+), 32 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index f6afe74..6c63ef3 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -3,35 +3,65 @@ This may be subject to change.
 
 1. Introduction
     * [x] How course works?
-    * [x] CS Basics
-    * [x] What is a programming language?
-
-2. Foundations
-    * [x] What is Python?
-    * [ ] Local Development Enviroment (WIP)
-        * Command Prompt
-        * Downloading & Installing Python
-        * VS Code
-        * `git` and **Github**
-        * REPL vs *script files*
-    * [x] Foundations (web based)
-        * print()
-        * Variables
-        * Data types
-        * Math
-        * Comparisons
-    * [ ] Conditionals & Loops (web based)
-        * If/elif/else
-        * match/case
-        * for and while loops
-        * enumerate()
-        * zip()
-        * break / continue
-        * for-else pattern
+    * [ ] Motivation and Mindset
+    * [ ] Asking for Help
+    * [x] Join the Community
+    * [x] Computer Science basics, Programming and Python 
+2. Prerequisites 
+    * [x] Software Installation
+    * [x] Text and Code Editors 
+    * [x] Command Line Basics
+    * [x] Python - REPL vs Scripts
+3. Git Basics
+    * [x] Introduction to Git
+    * [x] Setting up Git and Github
+    * [x] Git Basics
+4. Foundations
+    * [x] Output, Variables, Core Datatypes
+    * [x] Arithmetic and String Operations, Comparisons
+    * [x] User Input and Conditionals
+    * [x] Loops
+5. Data Structures
+    * [x] Lists
+    * [x] Tuples
+    * [x] Sets
+    * [x] Dictionaries
+6. Comprehensions
+    * [ ] List Coprehension
+    * [ ] Set Coprehension
+    * [ ] Dict Coprehension
+7. Code Organization
     * [ ] Functions
-        * Functions
-        * `*args`/`**kwargs`
-        * Mutable argument trap
-        * LGBT scope rules
-    * [ ] Mini - Project 1
-        * Terminal guessing game?
\ No newline at end of file
+    * [ ] Scope and Namespaces (LEGB rule)
+    * [ ] Understanding Errors and Error Handling
+    * [ ] File Handling
+    * [ ] Modules
+8. Capstone Project 1
+    * [ ] Problem Solving
+    * [ ] Problem Solving - Fizz-Buzz Example 
+    * [ ] Capstone Project
+9. Built-in and Modules
+    * [ ] `math` module
+    * [ ] `json` module
+    * [ ] `random` module
+    * [ ] `datetime` module
+    * [ ] `pathlib` / `os` module
+    * [ ] `csv` module
+    * [ ] `sys` module
+10. Third-party Modules
+    * [ ] Virtual Environments
+    * [ ] Using `pip` and `requirements.txt`
+    * [ ] Creating python package -  `pyproject.toml` file
+11. Capstone Project 2
+    * [ ] Clean Code Priciples
+    * [ ] Capstone Project
+12. Object Oriented Programming - Part 1
+    * [ ] Introduction to classes and instances
+    * [ ] Methods (instance, class, static)
+    * [ ] Dunder Methods (`__str__`, `__repr__`, etc...)
+13. Capstone Project 3
+    * [ ] Capstone Project
+14. Object Oriented Programming - Part 2
+    * [ ] Four Pillars of Object-Oriented Programming (Encapsulation, Abstraction, Inheritance, Polymorphism)
+15. Capstone Project 4
+    * [ ] Capstone Project
diff --git a/curriculum/05-data-structures/01-list.md b/curriculum/05-data-structures/01-list.md
index 013a0d0..1903710 100644
--- a/curriculum/05-data-structures/01-list.md
+++ b/curriculum/05-data-structures/01-list.md
@@ -155,7 +155,7 @@ Learn more about Python Lists from these resources:
 :::
 
 ## Exercise
-Complete [[TODO] Exercise 05 — The Cozy Bakery Inventory](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
+Complete [[TODO] Exercise 05 — WorkingTitle](#) to practice list creation, indexing, modification, and using python documentation to solve list tasks.
 
 ## Assignment {#assignment}
 1. Open `main.py` file in our `simple-python-shop` directory

From c8504ae5c974bb81f4a151e6b32b6a6b398272e7 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Sat, 12 Sep 2026 19:47:55 +0200
Subject: [PATCH 10/21] Added basics of coprehensions lesson

---
 .../05-data-structures/05-comprehensions.md   | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 curriculum/05-data-structures/05-comprehensions.md

diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
new file mode 100644
index 0000000..96036b0
--- /dev/null
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -0,0 +1,54 @@
+---
+id: comprehensions
+title: Comprehensions
+sidebar_label: Comprehensions
+sidebar_position: 5
+lesson: true
+isDraft: true
+---
+# Comprehensions
+Comprehensions in Python provide a short and clear way to create new sequences from existing iterables. Basicly they are a *fancy* syntax for simple **for-loop** pattern.
+
+## Lesson Overview {#overview}
+At the end of the lesson you will know:
+* What are comprehensions in Python
+* How to write `list`, `dict` or `set` coprehension
+* How to use conditions in coprehensions
+
+The key to understanding list comprehensions is that they’re just `for-loops` over a collection expressed in a more terse and compact syntax.
+
+We will start with **list coprehension** as it is most common.
+
+## List Coprehension
+Let's imagine we have a task of creating a list of **square** numbers from some other list of numbers. For example, let's assume we have a following list of numbers:
+```python
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+```
+To create a new list with **square** of all numbers in a list, we need to first get each element in the list and apply a mathematical operation on it. So it would look something like this:
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared = []
+for nmb in nmb_list:
+    squared.append(nmb**2)
+
+print(squared)
+```
+And the result is correct, but in Python, we can do better. Let's convert our `for-loop` to **list coprehension**.
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared = [nmb**2 for nmb in nmb_list]
+print(squared)
+```
+Result is completly the same, but our code is simpler and more concise.
+
+:::explore
+Documentation Hunting
+:::
+
+## Answer These Questions
+
+## Exercise
+
+## Assignment {#assignment}
+
+## What's Next {#next-lesson}
\ No newline at end of file

From f29e900c56e206d09ebd163dccb955e230f9f7b7 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Sun, 13 Sep 2026 13:27:59 +0200
Subject: [PATCH 11/21] Added more content to coprehensions lessons

---
 .../05-data-structures/05-comprehensions.md   | 95 ++++++++++++++++++-
 1 file changed, 94 insertions(+), 1 deletion(-)

diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index 96036b0..fedda8e 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -20,6 +20,11 @@ The key to understanding list comprehensions is that they’re just `for-loops`
 We will start with **list coprehension** as it is most common.
 
 ## List Coprehension
+Syntax for this looks like:
+```python
+[item for item in iterable]
+```
+
 Let's imagine we have a task of creating a list of **square** numbers from some other list of numbers. For example, let's assume we have a following list of numbers:
 ```python
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
@@ -39,7 +44,95 @@ nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared = [nmb**2 for nmb in nmb_list]
 print(squared)
 ```
-Result is completly the same, but our code is simpler and more concise.
+Result is completly the same, but our code is simpler and more concise. In this simple example we may not see the benefit, but let's add a check there, to only collect **even** numbers.
+
+If we use **for-loop** we may do something like this.
+```python
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared_even = []
+for nmb in nmb_list:
+    if nmb % 2 == 0:
+        squared_even.append(nmb ** 2)
+
+print(squared_even)
+```
+If we use **list comprehension** it would look like this:
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared_even = [nmb ** 2 for nmb in nmb_list if nmb % 2 == 0]
+print(squared_even)
+```
+The result is again, completly the same, but the syntax is shorter and more concise.
+
+You do not need to worry about understanding **coprehensions** right away, but they become extremly useful the more you write your code.
+
+Now that we learned what are list coprehensions, let's look at **dictionary coprehensions** which are very similar in syntax but allows us to create dictionaries in a similar manner.
+
+## Dictionary Coprehension
+When creating a new dictionary using dictionary comprehension, you can perform various operations using expressions to determine the data (key and/or value) that will be stored in the new dictionary.
+
+Syntax for this looks like:
+```python
+{key: value for (key,value) in iterable}
+```
+
+To demonstrate this, let's imagine that you are building a currency converter. You would maybe have a dictionary representing prices in USD and need to convert them to EUR. In traditional **for-loop** you would do something like this:
+```python interactive
+EUR_CONV_RATE = 0.92
+prices_in_usd = {'pen': 4, 'book': 15, 'keyboard': 60}
+prices_in_eur = {}
+for name, price in prices_in_usd.items():
+    prices_in_eur[name] = round(price * EUR_CONV_RATE, 2)
+print(prices_in_eur)
+```
+To use **dict coprehension** we would rewrite the above code to:
+```python interactive
+EUR_CONV_RATE = 0.92
+prices_in_usd = {'pen': 4, 'book': 15, 'keyboard': 60}
+
+prices_in_eur = {key: round(value * EUR_CONV_RATE, 2) for (key, value) in prices_in_usd.items()}
+
+print(prices_in_eur)
+```
+:::tip
+`round()` function rounds the numbers decimal point to specified number of places. It takes in `float` and a number of decimal places - an `integer`.
+```python interactive
+a = 43.24214213213
+b = round(a, 2)
+print(b)
+```
+:::
+
+:::info
+In the above code we use `EUR_CONV_RATE` to declare **constant**. Constants are just variables, but are not supposed to be changed during running of your program. They are useful for declaring things that would not change during runtime of your program, and its a convention in Python to write them in `ALL_CAPS`. Unlike some other languages, in Python, these are considered just like regular variables and Python will not stop you from changing them during runtime, so you need to consider this when writing your application.
+
+The golden rule is: 
+* If the variable will change during your application runtime, its just a variable and should be written as `variable_name`.
+* If the variable will **not** change during your application runtime, then you can consider it a **constant** and write them as `VARIABLE_NAME`.
+
+Remember that this is just a convention and it is not a rule you *must* follow.
+:::
+
+Now that we covered dictionary coprehensions, we can finally meet **set coprehensions**.
+
+## Set Coprehension
+Set comprehension works best when you want a clean transformation and you also want duplicates to disappear without extra effort. The syntax for **set coprehension** is:
+```python
+{expression for item in iterable}
+```
+
+For example, let's use our *squared* example from before:
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared = {nmb ** 2 for nmb in nmb_list}
+print(squared)
+```
+We can also use conditionals to get only specific values:
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+squared_even = {nmb ** 2 for nmb in nmb_list if nmb % 2 == 0}
+print(squared_even)
+```
 
 :::explore
 Documentation Hunting

From 4b331b8355132b8c9d7aae1ae2e74bde98a1cecb Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Sun, 13 Sep 2026 13:39:34 +0200
Subject: [PATCH 12/21] Fixed code block to be 'interactive'

---
 curriculum/05-data-structures/05-comprehensions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index fedda8e..d7af0c9 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -47,7 +47,7 @@ print(squared)
 Result is completly the same, but our code is simpler and more concise. In this simple example we may not see the benefit, but let's add a check there, to only collect **even** numbers.
 
 If we use **for-loop** we may do something like this.
-```python
+```python interactive
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared_even = []
 for nmb in nmb_list:

From 71088b3b658d0ab67d80e2938b5858c462ebd851 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Sun, 13 Sep 2026 16:57:49 +0200
Subject: [PATCH 13/21] Fixed "WHATS'S NEXT" in dictionary lesson and added
 "WHAT'S NEXT" section to coprehensions lesson

---
 ROADMAP.md                                    | 31 +++++++++----------
 .../05-data-structures/04-dictionary.md       |  2 +-
 .../05-data-structures/05-comprehensions.md   |  3 +-
 3 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 71e85a1..30134b3 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -28,25 +28,22 @@ This may be subject to change.
     * [x] User Input and Conditionals
     * [x] Loops
 5. Data Structures
-    * [x] Lists
-    * [x] Tuples
-    * [x] Sets
-    * [x] Dictionaries
-6. Comprehensions
-    * [ ] List Coprehension
-    * [ ] Set Coprehension
-    * [ ] Dict Coprehension
-7. Code Organization
+    * [x] Lists (WIP)
+    * [x] Tuples (WIP)
+    * [x] Sets (WIP)
+    * [x] Dictionaries (WIP)
+    * [x] Coprehensions (`list`, `dict` `set`) (WIP)
+6. Code Organization
     * [ ] Functions
     * [ ] Scope and Namespaces (LEGB rule)
     * [ ] Understanding Errors and Error Handling
     * [ ] File Handling
     * [ ] Modules
-8. Capstone Project 1
+7. Capstone Project 1
     * [ ] Problem Solving
     * [ ] Problem Solving - Fizz-Buzz Example 
     * [ ] Capstone Project
-9. Built-in and Modules
+8. Built-in and Modules
     * [ ] `math` module
     * [ ] `json` module
     * [ ] `random` module
@@ -54,20 +51,20 @@ This may be subject to change.
     * [ ] `pathlib` / `os` module
     * [ ] `csv` module
     * [ ] `sys` module
-10. Third-party Modules
+9. Third-party Modules
     * [ ] Virtual Environments
     * [ ] Using `pip` and `requirements.txt`
     * [ ] Creating python package -  `pyproject.toml` file
-11. Capstone Project 2
+10. Capstone Project 2
     * [ ] Clean Code Priciples
     * [ ] Capstone Project
-12. Object Oriented Programming - Part 1
+11. Object Oriented Programming - Part 1
     * [ ] Introduction to classes and instances
     * [ ] Methods (instance, class, static)
     * [ ] Dunder Methods (`__str__`, `__repr__`, etc...)
-13. Capstone Project 3
+12. Capstone Project 3
     * [ ] Capstone Project
-14. Object Oriented Programming - Part 2
+13. Object Oriented Programming - Part 2
     * [ ] Four Pillars of Object-Oriented Programming (Encapsulation, Abstraction, Inheritance, Polymorphism)
-15. Capstone Project 4
+14. Capstone Project 4
     * [ ] Capstone Project
diff --git a/curriculum/05-data-structures/04-dictionary.md b/curriculum/05-data-structures/04-dictionary.md
index 9b6c7fa..66c2957 100644
--- a/curriculum/05-data-structures/04-dictionary.md
+++ b/curriculum/05-data-structures/04-dictionary.md
@@ -143,4 +143,4 @@ In this assignment, we will completely eliminate list index tracking by refactor
 ## Deepen Your Knowlege {#learn-more}
 
 ## What's Next {#next-lesson}
-We are now done with basic data structures in Python, next we move on to something even more fun and useful; **functions**. 
\ No newline at end of file
+We are now done with basic data structures in Python, next we move on to something even more fun and useful, kind of a super power in Python: **coprehensions**
\ No newline at end of file
diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index d7af0c9..b625caf 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -144,4 +144,5 @@ Documentation Hunting
 
 ## Assignment {#assignment}
 
-## What's Next {#next-lesson}
\ No newline at end of file
+## What's Next {#next-lesson}
+Coprehensions are very useful in every day life as a Python programmer, but there is one thing that is universal accross all languages, so let's start a new chapter; *code organization*. First thing to learn are **functions** which enable us to write modular code.
\ No newline at end of file

From 8dea13e2dfd0fe75cd152afa95f92756337a6e9f Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Tue, 15 Sep 2026 16:47:23 +0200
Subject: [PATCH 14/21] Fixed typos

---
 .../05-data-structures/05-comprehensions.md   | 42 +++++++++++--------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index b625caf..0aad0ca 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -7,19 +7,19 @@ lesson: true
 isDraft: true
 ---
 # Comprehensions
-Comprehensions in Python provide a short and clear way to create new sequences from existing iterables. Basicly they are a *fancy* syntax for simple **for-loop** pattern.
+Comprehensions in Python provide a short and clear way to create new sequences from existing iterable. Basically they are a *fancy* syntax for simple **for-loop** pattern.
 
 ## Lesson Overview {#overview}
 At the end of the lesson you will know:
 * What are comprehensions in Python
-* How to write `list`, `dict` or `set` coprehension
-* How to use conditions in coprehensions
+* How to write `list`, `dict` or `set` comprehension
+* How to use conditions in comprehensions
 
 The key to understanding list comprehensions is that they’re just `for-loops` over a collection expressed in a more terse and compact syntax.
 
-We will start with **list coprehension** as it is most common.
+We will start with **list comprehension** as it is most common.
 
-## List Coprehension
+## List Comprehension
 Syntax for this looks like:
 ```python
 [item for item in iterable]
@@ -38,13 +38,13 @@ for nmb in nmb_list:
 
 print(squared)
 ```
-And the result is correct, but in Python, we can do better. Let's convert our `for-loop` to **list coprehension**.
+And the result is correct, but in Python, we can do better. Let's convert our `for-loop` to **list comprehension**.
 ```python interactive
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared = [nmb**2 for nmb in nmb_list]
 print(squared)
 ```
-Result is completly the same, but our code is simpler and more concise. In this simple example we may not see the benefit, but let's add a check there, to only collect **even** numbers.
+Result is completely the same, but our code is simpler and more concise. In this simple example we may not see the benefit, but let's add a check there, to only collect **even** numbers.
 
 If we use **for-loop** we may do something like this.
 ```python interactive
@@ -62,13 +62,13 @@ nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared_even = [nmb ** 2 for nmb in nmb_list if nmb % 2 == 0]
 print(squared_even)
 ```
-The result is again, completly the same, but the syntax is shorter and more concise.
+The result is again, completely the same, but the syntax is shorter and more concise.
 
-You do not need to worry about understanding **coprehensions** right away, but they become extremly useful the more you write your code.
+You do not need to worry about understanding **comprehensions** right away, but they become extremely useful the more you write your code.
 
-Now that we learned what are list coprehensions, let's look at **dictionary coprehensions** which are very similar in syntax but allows us to create dictionaries in a similar manner.
+Now that we learned what are list comprehensions, let's look at **dictionary comprehensions** which are very similar in syntax but allows us to create dictionaries similarly.
 
-## Dictionary Coprehension
+## Dictionary Comprehension
 When creating a new dictionary using dictionary comprehension, you can perform various operations using expressions to determine the data (key and/or value) that will be stored in the new dictionary.
 
 Syntax for this looks like:
@@ -85,7 +85,7 @@ for name, price in prices_in_usd.items():
     prices_in_eur[name] = round(price * EUR_CONV_RATE, 2)
 print(prices_in_eur)
 ```
-To use **dict coprehension** we would rewrite the above code to:
+To use **dict comprehension** we would rewrite the above code to:
 ```python interactive
 EUR_CONV_RATE = 0.92
 prices_in_usd = {'pen': 4, 'book': 15, 'keyboard': 60}
@@ -104,7 +104,7 @@ print(b)
 :::
 
 :::info
-In the above code we use `EUR_CONV_RATE` to declare **constant**. Constants are just variables, but are not supposed to be changed during running of your program. They are useful for declaring things that would not change during runtime of your program, and its a convention in Python to write them in `ALL_CAPS`. Unlike some other languages, in Python, these are considered just like regular variables and Python will not stop you from changing them during runtime, so you need to consider this when writing your application.
+In the above code we use `EUR_CONV_RATE` to declare **constant**. Constants are just variables, but are not supposed to be changed during running of your program. They are useful for declaring things that would not change during runtime of your program, and it's a convention in Python to write them in `ALL_CAPS`. Unlike some other languages, in Python, these are considered just like regular variables and Python will not stop you from changing them during runtime, so you need to consider this when writing your application.
 
 The golden rule is: 
 * If the variable will change during your application runtime, its just a variable and should be written as `variable_name`.
@@ -113,10 +113,10 @@ The golden rule is:
 Remember that this is just a convention and it is not a rule you *must* follow.
 :::
 
-Now that we covered dictionary coprehensions, we can finally meet **set coprehensions**.
+Now that we covered dictionary comprehensions, we can finally meet **set comprehensions**.
 
-## Set Coprehension
-Set comprehension works best when you want a clean transformation and you also want duplicates to disappear without extra effort. The syntax for **set coprehension** is:
+## Set Comprehension
+Set comprehension works best when you want a clean transformation, and you also want duplicates to disappear without extra effort. The syntax for **set comprehension** is:
 ```python
 {expression for item in iterable}
 ```
@@ -138,6 +138,14 @@ print(squared_even)
 Documentation Hunting
 :::
 
+:::tip
+Comprehensions are very useful and can make your code smaller and easier to understand and reason about. But it also can make your code very difficult to read and understand.
+
+Use them with caution and remember:
+* USE comprehensions while the code is readable
+* DO NOT use comprehensions when the code starts to become unreadable and go back to **for-loop** for clarity.
+:::
+
 ## Answer These Questions
 
 ## Exercise
@@ -145,4 +153,4 @@ Documentation Hunting
 ## Assignment {#assignment}
 
 ## What's Next {#next-lesson}
-Coprehensions are very useful in every day life as a Python programmer, but there is one thing that is universal accross all languages, so let's start a new chapter; *code organization*. First thing to learn are **functions** which enable us to write modular code.
\ No newline at end of file
+Comprehensions are very useful in everyday life as a Python programmer, but there is one thing that is universal across all languages, so let's start a new chapter; *code organization*. First thing to learn are **functions** which enable us to write modular code.

From dd7c003485e34f5cf0b28c42eb9f6432496cc7fb Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Wed, 16 Sep 2026 16:21:03 +0200
Subject: [PATCH 15/21] Couple of changes to lesson and better ROADMAP.md

---
 ROADMAP.md                                         | 12 ++++++------
 curriculum/05-data-structures/05-comprehensions.md |  8 ++++----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 30134b3..4ce7139 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -10,7 +10,7 @@ This may be subject to change.
 1. Introduction
     * [x] How course works?
     * [ ] Motivation and Mindset
-    * [ ] Asking for Help
+    * [ ] Asking for Help (WIP)
     * [x] Join the Community
     * [x] Computer Science basics, Programming and Python 
 2. Prerequisites 
@@ -28,11 +28,11 @@ This may be subject to change.
     * [x] User Input and Conditionals
     * [x] Loops
 5. Data Structures
-    * [x] Lists (WIP)
-    * [x] Tuples (WIP)
-    * [x] Sets (WIP)
-    * [x] Dictionaries (WIP)
-    * [x] Coprehensions (`list`, `dict` `set`) (WIP)
+    * [ ] Lists (WIP)
+    * [ ] Tuples (WIP)
+    * [ ] Sets (WIP)
+    * [ ] Dictionaries (WIP)
+    * [ ] Coprehensions (`list`, `dict` `set`) (WIP)
 6. Code Organization
     * [ ] Functions
     * [ ] Scope and Namespaces (LEGB rule)
diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index 0aad0ca..abea678 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -39,7 +39,7 @@ for nmb in nmb_list:
 print(squared)
 ```
 And the result is correct, but in Python, we can do better. Let's convert our `for-loop` to **list comprehension**.
-```python interactive
+```python interactive debug
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared = [nmb**2 for nmb in nmb_list]
 print(squared)
@@ -57,7 +57,7 @@ for nmb in nmb_list:
 print(squared_even)
 ```
 If we use **list comprehension** it would look like this:
-```python interactive
+```python interactive debug
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared_even = [nmb ** 2 for nmb in nmb_list if nmb % 2 == 0]
 print(squared_even)
@@ -86,7 +86,7 @@ for name, price in prices_in_usd.items():
 print(prices_in_eur)
 ```
 To use **dict comprehension** we would rewrite the above code to:
-```python interactive
+```python interactive debug
 EUR_CONV_RATE = 0.92
 prices_in_usd = {'pen': 4, 'book': 15, 'keyboard': 60}
 
@@ -128,7 +128,7 @@ squared = {nmb ** 2 for nmb in nmb_list}
 print(squared)
 ```
 We can also use conditionals to get only specific values:
-```python interactive
+```python interactive debug
 nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
 squared_even = {nmb ** 2 for nmb in nmb_list if nmb % 2 == 0}
 print(squared_even)

From 6a7903ff87c46bd8382ffb3e953f4237c6404161 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Wed, 16 Sep 2026 18:37:23 +0200
Subject: [PATCH 16/21] Fixed "Learn More" sections and made them all similar
 style

---
 curriculum/05-data-structures/01-list.md      |  1 -
 curriculum/05-data-structures/02-tuple.md     |  4 +--
 curriculum/05-data-structures/03-set.md       |  7 ++--
 .../05-data-structures/04-dictionary.md       |  9 +++--
 .../05-data-structures/05-comprehensions.md   | 33 +++++++++++++++----
 5 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/curriculum/05-data-structures/01-list.md b/curriculum/05-data-structures/01-list.md
index 926cedf..4adb8f6 100644
--- a/curriculum/05-data-structures/01-list.md
+++ b/curriculum/05-data-structures/01-list.md
@@ -7,7 +7,6 @@ lesson: true
 isDraft: true
 ---
 # List
-## Introduction {#introduction}
 Up until now we have stored a single value in a variable, but what if we need to hold multiple values in some variable? Do we create multiple variables? Of course not, Python has a *built-in* mechanisms for dealing with collections of data which we call **data structures**. In this lesson we first take a look at **list**.
 
 Lists in Python are *built-in* data structure for storing ordered collections of items. They are **ordered** meaning they keep the order in which data came in. They are also **mutable** which means we can change them in place without creating a new copy. They can hold any other type of data including other lists or other data structures. Lists are probably the most used data structure in Python.
diff --git a/curriculum/05-data-structures/02-tuple.md b/curriculum/05-data-structures/02-tuple.md
index 9ff40f0..8be316b 100644
--- a/curriculum/05-data-structures/02-tuple.md
+++ b/curriculum/05-data-structures/02-tuple.md
@@ -51,9 +51,7 @@ Unlike lists, as we cannot modify tuples, we don't have a lot of methods availab
     ```
 
 :::explore[Learn more about Python Tuples]
-Read these resources to learn more about tuples in Python:
-* [Python built-in types: tuples from RealPython](https://realpython.com/ref/builtin-types/tuple/)
-* [Tuples and Sequences from official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)
+Deep dive into Python tuples in this [Deep Dive: tuples](https://realpython.com/python-tuple/) article by **Real Python** which takes you deep in topic of tuples and their usecases.
 :::
 
 ## Exercise
diff --git a/curriculum/05-data-structures/03-set.md b/curriculum/05-data-structures/03-set.md
index 2b259ef..9253acd 100644
--- a/curriculum/05-data-structures/03-set.md
+++ b/curriculum/05-data-structures/03-set.md
@@ -7,7 +7,6 @@ lesson: true
 isDraft: true
 ---
 # Set
-## Introduction {#introduction}
 A **set** in Python is unordered collection of unique elements. **Unordered** means it does not keep the order of the elements and **unique** means it does not allow duplicates.
 
 Its mostly used when removing duplicates from list or performing quick membership tests (checking to see if some element belongs to both sets).
@@ -73,9 +72,9 @@ print("Difference:", set1 - set2)
 ```
 
 :::explore[Learn more about Python Sets]
-Learn more about sets in these materials:
-* [Python built-in data types from RealPython](https://realpython.com/ref/builtin-types/set/)
-* [Python data structures: set from official Python documentation](https://docs.python.org/3/tutorial/datastructures.html#sets)
+Explore Python sets deeper by visiting this [built-in: set] article from **Real Python** (especially the part about additional methods which come in handy when working with sets).
+
+Remember you do not need to remember all the methods there are. Just read through them, to know they exist.
 :::
 
 ## Exercise
diff --git a/curriculum/05-data-structures/04-dictionary.md b/curriculum/05-data-structures/04-dictionary.md
index c946b27..34516ac 100644
--- a/curriculum/05-data-structures/04-dictionary.md
+++ b/curriculum/05-data-structures/04-dictionary.md
@@ -7,7 +7,6 @@ lesson: true
 isDraft: true
 ---
 # Dictionary
-## Introduction {#introduction}
 Dictionaries in Python are mutable and unordered collection data structure. **Mutable** meaning it can be modified after creating and **unordered** meaning it does not keep track of it's elements.
 
 Dictionaries are something special, usually called **key-value** data structure because of the way you store data inside them. You will certanly do a lot of work involving dictionaries in your python applications and its a very powerful concept, so let's get started.
@@ -124,6 +123,12 @@ for key, value in mydict.items():
     print(key, value)
 ```
 
+:::explore[Learn more about Python dicts]
+Read this [built-in: dict](https://realpython.com/ref/builtin-types/dict/) article from **Real Python** and pay special attention to sections **dict Operators** and **dict Methods**.
+
+Remember, just read through, you do not have to know it all.
+:::
+
 ## Exercise
 Complete [[TODO] Exercise 08 — WorkingTitle](#) to practice dictionaries.
 
@@ -140,7 +145,5 @@ In this assignment, we will completely eliminate list index tracking by refactor
 5. Keep `order` as a list of tuples, and update the `unsold_items` variable to check between keys of the dictionary and tuple elements - use `inventory.keys()` to get a *tuple-like* object of dictionary keys that you can use in this case to substract `order` elements from keys of dictionary.
 6. Test your application, make sure it works, commit and push to Github.
 
-## Deepen Your Knowlege {#learn-more}
-
 ## What's Next {#next-lesson}
 We are now done with basic data structures in Python, next we move on to something even more fun and useful, kind of a super power in Python: **coprehensions**
\ No newline at end of file
diff --git a/curriculum/05-data-structures/05-comprehensions.md b/curriculum/05-data-structures/05-comprehensions.md
index abea678..e6e0b86 100644
--- a/curriculum/05-data-structures/05-comprehensions.md
+++ b/curriculum/05-data-structures/05-comprehensions.md
@@ -64,6 +64,31 @@ print(squared_even)
 ```
 The result is again, completely the same, but the syntax is shorter and more concise.
 
+Let's look at the final type of list comprehension, which will produce one value if the condition is `True` or something else if the condition is `False`. For example, let's say we need to produce a list, containing `True` if the number is even or `False` if its odd.
+
+In classic python **for-loop** style, we would do something like this:
+```python interactive
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+even_mask = []
+for nmb in nmb_list:
+    if nmb % 2 == 0:
+        even_mask.append(True)
+    else:
+        even_mask.append(False)
+print(even_mask)
+```
+
+But Python let's us use its super power here also:
+```python interactive debug
+nmb_list = [1, 2, 3, 4, 5, 6, 7, 8]
+even_mask = [True for nmb in nmb_list if nmb % 2 == 0 else False]
+print(even_mask)
+```
+
+:::tip[Superpowers work with any comprehension]
+`if condition` and `if condition else` works will all comprehensions and not just with lists, and they work in the same manner.
+:::
+
 You do not need to worry about understanding **comprehensions** right away, but they become extremely useful the more you write your code.
 
 Now that we learned what are list comprehensions, let's look at **dictionary comprehensions** which are very similar in syntax but allows us to create dictionaries similarly.
@@ -134,11 +159,7 @@ squared_even = {nmb ** 2 for nmb in nmb_list if nmb % 2 == 0}
 print(squared_even)
 ```
 
-:::explore
-Documentation Hunting
-:::
-
-:::tip
+:::warning
 Comprehensions are very useful and can make your code smaller and easier to understand and reason about. But it also can make your code very difficult to read and understand.
 
 Use them with caution and remember:
@@ -146,8 +167,6 @@ Use them with caution and remember:
 * DO NOT use comprehensions when the code starts to become unreadable and go back to **for-loop** for clarity.
 :::
 
-## Answer These Questions
-
 ## Exercise
 
 ## Assignment {#assignment}

From dc1a1863a93dff1c96ec4119c7937a577c3b8df4 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Wed, 16 Sep 2026 22:56:24 +0200
Subject: [PATCH 17/21] Updated roadmap with missing topics

---
 ROADMAP.md | 40 +++++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 4ce7139..6d2a4df 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -36,14 +36,31 @@ This may be subject to change.
 6. Code Organization
     * [ ] Functions
     * [ ] Scope and Namespaces (LEGB rule)
-    * [ ] Understanding Errors and Error Handling
-    * [ ] File Handling
+    * [ ] Type Hints
     * [ ] Modules
 7. Capstone Project 1
     * [ ] Problem Solving
     * [ ] Problem Solving - Fizz-Buzz Example 
+    * [ ] Capstone Project - **Hangman game**
+8. Errors, Debugging, I/O
+    * [ ] Understanding Errors and Error Handling
+    * [ ] `logging` module
+    * [ ] Debugging tehniques
+    * [ ] File Handling
+9. Capstone Project 2
+    * [ ] Git Workflow: Branches and Pull Requests
+    * [ ] Revisiting Project 1 (hangman game):
+        * Creating branch, adding features, merging back to `main`
+        * Loading *words* from external file
+        * Catching and logging errors
     * [ ] Capstone Project
-8. Built-in and Modules
+10. Intermediate Python
+    * [ ] Decorators
+    * [ ] Generators
+    * [ ] Context Managers
+11. Capstone Project 3
+    * [ ] Capstone Project
+12. Built-in and Modules
     * [ ] `math` module
     * [ ] `json` module
     * [ ] `random` module
@@ -51,20 +68,25 @@ This may be subject to change.
     * [ ] `pathlib` / `os` module
     * [ ] `csv` module
     * [ ] `sys` module
-9. Third-party Modules
+    * [ ] `re` module
+13. Third-party Modules
     * [ ] Virtual Environments
     * [ ] Using `pip` and `requirements.txt`
     * [ ] Creating python package -  `pyproject.toml` file
-10. Capstone Project 2
+    * [ ] ? Linting, Formatting, Type Checking (`ruff`, `mypy`) ?
+14. Capstone Project 4
     * [ ] Clean Code Priciples
     * [ ] Capstone Project
-11. Object Oriented Programming - Part 1
+    * [ ] Testing Your Code (`pytest`)
+    * [ ] Revisit Project 4
+        * Develop a testing suite for the project
+15. Object Oriented Programming - Part 1
     * [ ] Introduction to classes and instances
     * [ ] Methods (instance, class, static)
     * [ ] Dunder Methods (`__str__`, `__repr__`, etc...)
-12. Capstone Project 3
+16. Capstone Project 5
     * [ ] Capstone Project
-13. Object Oriented Programming - Part 2
+17. Object Oriented Programming - Part 2
     * [ ] Four Pillars of Object-Oriented Programming (Encapsulation, Abstraction, Inheritance, Polymorphism)
-14. Capstone Project 4
+18. Capstone Project 6
     * [ ] Capstone Project

From b59c0eb19a0560139c98edd198823d9a5a9a0f98 Mon Sep 17 00:00:00 2001
From: amotech <thomasamoadu877@gmail.com>
Date: Sat, 26 Sep 2026 20:06:54 +0000
Subject: [PATCH 18/21] first comm.. for ask4help

---
 .../01-introduction/03-asking-for-help.md     | 37 ++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/curriculum/01-introduction/03-asking-for-help.md b/curriculum/01-introduction/03-asking-for-help.md
index 51b555c..81d05fd 100644
--- a/curriculum/01-introduction/03-asking-for-help.md
+++ b/curriculum/01-introduction/03-asking-for-help.md
@@ -6,5 +6,40 @@ sidebar_position: 3
 lesson: true
 isDraft: true
 ---
+
 # Asking For Help
-## Work in progress
\ No newline at end of file
+**Introduction**: Getting stuck in your coding or even a learning is really part of the journey, and that is the number one why this lesson (ask for help) exists.
+
+## Goal
+In this lesson you will learn how to get help whenever you need it. And by the end of this lesson you should be familiar with getting stcuk and how to seek for help.
+
+
+## Lesson outline
+* How to Get Help
+* 
+
+## How to Get Help
+### 1. Before You Ask
+Check if:
+- your indentations are correct or valid
+- your syntax are correct or valid
+- your code is complete as you intended
+
+**If** any of above is Fasle, Fix them and re-run your code.
+
+**Else**, if all of above is True and error still persist, proceed to the step 2(the question space) of this topic.
+
+
+### 2. The Question space
+Paste your code below:
+
+′′′python
+
+′′′
+
+### 3. How to Format Your Code
+...
+
+### 4. What to Expect Next
+Once you have submitted your help request, sit down tight and the appropriate help will be sent straight to you.
+

From 34f582cd1b4031e5f1d480b9871d480f7cb45d6f Mon Sep 17 00:00:00 2001
From: amotech <thomasamoadu877@gmail.com>
Date: Sun, 27 Sep 2026 14:04:15 +0000
Subject: [PATCH 19/21] First on repo corr...

---
 curriculum/01-introduction/03-asking-for-help.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/curriculum/01-introduction/03-asking-for-help.md b/curriculum/01-introduction/03-asking-for-help.md
index 81d05fd..faba68f 100644
--- a/curriculum/01-introduction/03-asking-for-help.md
+++ b/curriculum/01-introduction/03-asking-for-help.md
@@ -25,7 +25,7 @@ Check if:
 - your syntax are correct or valid
 - your code is complete as you intended
 
-**If** any of above is Fasle, Fix them and re-run your code.
+**If** any of above is False, Fix them and re-run your code.
 
 **Else**, if all of above is True and error still persist, proceed to the step 2(the question space) of this topic.
 

From 030175a3bae15ee72e0c53c0e1c577e3a80f6d8e Mon Sep 17 00:00:00 2001
From: amotech <thomasamoadu877@gmail.com>
Date: Mon, 28 Sep 2026 15:41:50 +0000
Subject: [PATCH 20/21] test3

---
 ROADMAP.md                                    | 76 +++++++++++++++++++
 .../01-introduction/03-asking-for-help.md     |  4 +
 2 files changed, 80 insertions(+)

diff --git a/ROADMAP.md b/ROADMAP.md
index 6d2a4df..1b28d2f 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -61,6 +61,66 @@ This may be subject to change.
 11. Capstone Project 3
     * [ ] Capstone Project
 12. Built-in and Modules
+    * [-] Data Structures
+        * [-] List
+        * [-] Tuple
+        * [-] Set
+        * [-] Dictionary
+     * [ ] Functions
+     * [ ] Project 1
+5. Modules, Working with Files and Error Handling 
+    * [ ] Working with multiple files (`__init.py__`, directory structure, etc...)
+    * [ ] Opening, Closing and Manipulating files
+    * [ ] Error Handling (`try-except-else-finally`)
+    * [ ] Custom Exceptions
+    * [ ] Defensive Coding patterns
+    * [ ] Working with structured data (`json`, `csv`, etc...)
+    * [ ] Project 2
+6. OOP, Virtual Environments and third party libraries, Working with APIs
+    * [ ] Classes and OOP
+    * [ ] Usage and setup of virtual environments
+    * [ ] Installation of third party libraries
+    * [ ] Working with APIs
+    * [ ] Project 3 - *probably: * weather app
+7. Working on Projects, Solving bugs, Reading errors
+    * [ ] Motivation and Mindset
+    * [ ] Asking for Help
+    * [x] Join the Community
+    * [x] Computer Science basics, Programming and Python 
+2. Prerequisites 
+    * [x] Software Installation
+    * [x] Text and Code Editors 
+    * [x] Command Line Basics
+    * [x] Python - REPL vs Scripts
+3. Git Basics
+    * [x] Introduction to Git
+    * [x] Setting up Git and Github
+    * [x] Git Basics
+4. Foundations
+    * [x] Output, Variables, Core Datatypes
+    * [x] Arithmetic and String Operations, Comparisons
+    * [x] User Input and Conditionals
+    * [x] Loops
+5. Data Structures
+    * [x] Lists
+    * [x] Tuples
+    * [x] Sets
+    * [x] Dictionaries
+6. Comprehensions
+    * [ ] List Coprehension
+    * [ ] Set Coprehension
+    * [ ] Dict Coprehension
+7. Code Organization
+    * [ ] Functions
+    * [ ] Scope and Namespaces (LEGB rule)
+    * [ ] Understanding Errors and Error Handling
+    * [ ] File Handling
+    * [ ] Modules
+8. Capstone Project 1
+    * [ ] Problem Solving
+    * [ ] Problem Solving - Fizz-Buzz Example 
+    * [ ] Capstone Project
+9. Built-in and Modules
     * [ ] `math` module
     * [ ] `json` module
     * [ ] `random` module
@@ -89,4 +149,20 @@ This may be subject to change.
 17. Object Oriented Programming - Part 2
     * [ ] Four Pillars of Object-Oriented Programming (Encapsulation, Abstraction, Inheritance, Polymorphism)
 18. Capstone Project 6
+10. Third-party Modules
+    * [ ] Virtual Environments
+    * [ ] Using `pip` and `requirements.txt`
+    * [ ] Creating python package -  `pyproject.toml` file
+11. Capstone Project 2
+    * [ ] Clean Code Priciples
+    * [ ] Capstone Project
+12. Object Oriented Programming - Part 1
+    * [ ] Introduction to classes and instances
+    * [ ] Methods (instance, class, static)
+    * [ ] Dunder Methods (`__str__`, `__repr__`, etc...)
+13. Capstone Project 3
+    * [ ] Capstone Project
+14. Object Oriented Programming - Part 2
+    * [ ] Four Pillars of Object-Oriented Programming (Encapsulation, Abstraction, Inheritance, Polymorphism)
+15. Capstone Project 4
     * [ ] Capstone Project
diff --git a/curriculum/01-introduction/03-asking-for-help.md b/curriculum/01-introduction/03-asking-for-help.md
index faba68f..b5e2a76 100644
--- a/curriculum/01-introduction/03-asking-for-help.md
+++ b/curriculum/01-introduction/03-asking-for-help.md
@@ -43,3 +43,7 @@ Paste your code below:
 ### 4. What to Expect Next
 Once you have submitted your help request, sit down tight and the appropriate help will be sent straight to you.
 
+## Introduction
+This lesson is intended to help you become good in seeking for help
+
+## Work in progress

From 2e9e7cf039a27bb0b6ea276769748f5c48c229e2 Mon Sep 17 00:00:00 2001
From: razorblade23 <81590614+razorblade23@users.noreply.github.com>
Date: Wed, 16 Sep 2026 16:21:03 +0200
Subject: [PATCH 21/21] Couple of changes to lesson and better ROADMAP.md

---
 ROADMAP.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 1b28d2f..7d681ff 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -84,7 +84,7 @@ This may be subject to change.
     * [ ] Project 3 - *probably: * weather app
 7. Working on Projects, Solving bugs, Reading errors
     * [ ] Motivation and Mindset
-    * [ ] Asking for Help
+    * [ ] Asking for Help (WIP)
     * [x] Join the Community
     * [x] Computer Science basics, Programming and Python 
 2. Prerequisites