Merge pull request #6 from S2P2/push-pnmzpoqzsvlv

Push pnmzpoqzsvlv

Author: S2P2

src/SUMMARY.md

@@ -24,13 +24,13 @@
 - [Cooking in Batches (Collections & Loops)](concepts/module-4/README.md)
   - [The Pantry (Arrays & Lists)](concepts/module-4/arrays-and-lists.md)
   - [Stir Until Combined (For Loops)](concepts/module-4/for-loops.md)
-  - [Wait for the Water to Boil (While Loops)]()
-  - [Grocery List (Dictionaries / Name-Value Pairs)]()
+  - [Wait for the Water to Boil (While Loops)](concepts/module-4/while-loops.md)
+  - [The Recipe Card (Name-Value Pairs)](concepts/module-4/key-values.md)
 - [Organizing Your Kitchen (Functions & Imports)](concepts/module-5/README.md)
   - [Kitchen Stations (Functions)](concepts/module-5/functions.md)
   - [Passing Ingredients (Function Parameters)](concepts/module-5/function-parameters.md)
   - [Returning the Dish (Function Returns)](concepts/module-5/function-returns.md)
-  - [Kitchen Gadgets (Using External Code)](concepts/module-5/imports.md)
+  - [Kitchen Gadgets (Imports)](concepts/module-5/imports.md)
 
 # First Project
 

src/concepts/module-2/working-with-text.md

@@ -1,8 +1,12 @@
 # Chopping and Combining (Working with Text)
 
-Working with numbers is about calculation, but working with text—or **strings**—is about communication. The most common task you'll perform with strings is combining them to create new, more meaningful messages.
+Working with numbers is about calculation, but working with text—or **strings**—is about communication. You'll constantly need to prepare your text to be shown to a user, whether it's a welcome message, a menu item, or an error warning.
 
-This process of joining strings together is called **concatenation**. 🔗
+Let's look at the three most common ways you'll work with strings: combining them, inspecting their properties, and changing their style.
+
+### 1. Combining: "Pen Pineapple Apple Pen"
+
+The most frequent task you'll perform with strings is joining them together to create new, more meaningful messages. This process is called **concatenation**. 🔗
 
 It's like connecting two train cars to make a longer train. In many languages, you can use the same `+` symbol you used for addition to concatenate strings.
 
@@ -34,4 +38,74 @@ You got [Pen Pineapple Apple Pen](https://www.youtube.com/watch?v=NfuiB52K7X8)!
 
 Notice that we had to add a space `" "` in the middle. The computer is extremely literal; it only combines *exactly* what you give it. Without that space, the result would have been `"Pen PineappleApple Pen"`.
 
-This is a fundamental building block. You'll use it to create dynamic text (`"Order: " + orderItem`), generate reports, or display any kind of organized text to a user.
+### 2. Inspecting: "Is the Username Too Long?"
+
+Sometimes you don't need to change the text, but you need to get information *about* it. The most common piece of information you'll need is its **length**.
+
+This is useful for checking things like, "Is this username less than 15 characters?" or "Will this menu item name fit on the display?"
+
+<!-- langtabs-start -->
+
+```py
+# In Python, we use the len() function to get the length of a string.
+menu_item = "Extra Cheesy Supreme Pizza"
+item_length = len(menu_item)
+
+print("Menu Item:", menu_item)
+print("Character Count:", item_length)
+
+# Now we can use this information in a decision!
+if item_length > 20:
+  print("Warning: This name might be too long for the menu board!")
+
+```
+
+```js
+// In JavaScript, we use the .length property to get the length of a string.
+let menuItem = "Extra Cheesy Supreme Pizza";
+let itemLength = menuItem.length;
+
+console.log("Menu Item:", menuItem);
+console.log("Character Count:", itemLength);
+
+// Now we can use this information in a decision!
+if (itemLength > 20) {
+  console.log("Warning: This name might be too long for the menu board!");
+}
+```
+<!-- langtabs-end -->
+
+### 3. Styling: "Shouting the Daily Special"
+
+Often, you'll need to change the case of a string for formatting purposes. For example, you might want to display a heading in all capital letters or normalize user input by converting it all to lowercase.
+
+Think of it like deciding how to write something on a menu board. Do you want to SHOUT IT, or write it in normal case?
+
+<!-- langtabs-start -->
+
+```py
+daily_special = "Classic Burger with Fries"
+
+# To make a big headline for the menu board, we use .upper()
+shouted_special = daily_special.upper()
+print(shouted_special) # Displays: CLASSIC BURGER WITH FRIES
+
+# To store it in a database consistently, we might use .lower()
+normalized_special = daily_special.lower()
+print(normalized_special) # Displays: classic burger with fries
+```
+
+```js
+let dailySpecial = "Classic Burger with Fries";
+
+// To make a big headline for the menu board, we use .toUpperCase()
+let shoutedSpecial = dailySpecial.toUpperCase();
+console.log(shoutedSpecial); // Displays: CLASSIC BURGER WITH FRIES
+
+// To store it in a database consistently, we might use .toLowerCase()
+let normalizedSpecial = dailySpecial.toLowerCase();
+console.log(normalizedSpecial); // Displays: classic burger with fries
+```
+<!-- langtabs-end -->
+
+These three operations—combining, checking length, and changing case—are the essential tools in your text-handling toolkit. You'll use them constantly to build dynamic, readable, and user-friendly programs.

src/concepts/module-3/if-else.md

@@ -37,3 +37,44 @@ if (internalTemp >= 165) {
 <!-- langtabs-end -->
 
 Now, try changing the `internal_temp` (or `internalTemp`) to something less than `165`, like `150`, and run the code again. You'll see the program take the other path and execute the code inside the `else` block instead. This is how you make your programs dynamic and responsive, just like a chef adjusting their cooking based on observations!
+
+## The Goldilocks Problem (Multi-Path Decisions)
+
+What if you have more than two options? This is like Goldilocks tasting the porridge: one bowl is too hot, one is too cold, and one is just right. An `if/else` statement only gives you two paths, but you can add more paths using `else if` (or `elif` in Python).
+
+This lets you chain conditions together:
+
+1.  **`if`**: Checks the first condition. If it's `true`, the code runs, and the chain is exited.
+2.  **`else if`**: If the first condition was `false`, this next condition is checked. You can have as many `else if` blocks as you need.
+3.  **`else`**: If none of the above conditions were `true`, this code runs as a fallback.
+
+Let's see how to handle porridge that is too hot, too cold, or just right.
+
+<!-- langtabs-start -->
+
+```py
+porridge_temp = 75
+
+if porridge_temp > 85:
+  print("This porridge is too hot!")
+elif porridge_temp < 65:
+  print("This porridge is too cold!")
+else:
+  print("This porridge is just right.")
+```
+
+```js
+let porridgeTemp = 75;
+
+if (porridgeTemp > 85) {
+  console.log("This porridge is too hot!");
+} else if (porridgeTemp < 65) {
+  console.log("This porridge is too cold!");
+} else {
+  console.log("This porridge is just right.");
+}
+```
+
+<!-- langtabs-end -->
+
+With this structure, you can create clear and effective logic for any number of choices, ensuring your program always knows the right step to take.

src/concepts/module-4/key-values.md

@@ -0,0 +1,75 @@
+# The Recipe Card (Name-Value Pairs)
+
+So far, we've used lists (the "Pantry") to store collections of items in a specific order. This is great for a sequence of recipe steps or a list of ingredients, where you access items by their position (`0`, `1`, `2`, etc.).
+
+But what if you need to store information that isn't a sequence, but a collection of labeled properties? This is where a **dictionary** (or **map**, or **object**, depending on the language) comes in. It's a collection that stores data not by its position, but by a unique **name**.
+
+Think of it as a **Recipe Card**... To find out the cook time, you don't look at the third line; you look for the label that says "Cook Time" and read the value next to it.
+
+This `name: value` pairing is the heart of a dictionary. In programming, the 'name' is officially called a **key**.
+
+-   **Key:** A unique identifier (like a label on the recipe card). It's almost always a string.
+-   **Value:** The data associated with that key. It can be any data type: a string, a number, a boolean, or even another list or dictionary!
+
+Let's create a recipe card for a classic dish.
+
+<!-- langtabs-start -->
+
+```python
+# A dictionary representing a recipe.
+# Notice the {curly braces} and the "key": value syntax.
+recipe = {
+  "name": "Classic Tomato Soup",
+  "servings": 4,
+  "cook_time_minutes": 30,
+  "is_vegetarian": True
+}
+
+# --- Accessing data ---
+# To get a value, you use its key inside [square brackets].
+print("Dish Name:", recipe["name"])
+print("Serves:", recipe["servings"])
+
+# --- Updating data ---
+# You can change a value by assigning a new one to its key.
+print("\nOops, we have more guests! Let's double the recipe.")
+recipe["servings"] = 8
+print("Now serves:", recipe["servings"])
+
+# --- Adding new data ---
+# You can add a new key-value pair just by assigning it.
+recipe["difficulty"] = "Easy"
+print("Difficulty:", recipe["difficulty"])
+```
+
+```javascript
+// An object representing a recipe.
+// Notice the {curly braces} and the key: value syntax.
+let recipe = {
+  name: "Classic Tomato Soup",
+  servings: 4,
+  cookTimeMinutes: 30,
+  isVegetarian: true
+};
+
+// --- Accessing data ---
+// To get a value, you can use dot notation (recipe.key)
+// or square bracket notation (recipe["key"]). Dot notation is more common.
+console.log("Dish Name: " + recipe.name);
+console.log("Serves: " + recipe.servings);
+
+// --- Updating data ---
+// You can change a value by assigning a new one to its key.
+console.log("\nOops, we have more guests! Let's double the recipe.");
+recipe.servings = 8;
+console.log("Now serves: " + recipe.servings);
+
+// --- Adding new data ---
+// You can add a new key-value pair just by assigning it.
+recipe.difficulty = "Easy";
+console.log("Difficulty: " + recipe.difficulty);
+```
+
+<!-- langtabs-end -->
+
+Dictionaries are incredibly versatile. You'll use them constantly to represent anything with a set of properties: a user profile (with keys like `username`, `email`, `id`), a product in an online store (`name`, `price`, `sku`), or configuration settings for an application. They are the go-to tool whenever you need to look up a value by its name instead of its numerical position.

src/concepts/module-4/while-loops.md

@@ -0,0 +1,60 @@
+# Wait for the Water to Boil (While Loops)
+
+In the last section, we used a `for` loop to go through every item on our recipe card. A `for` loop is perfect when you know exactly how many times you need to repeat something—once for each ingredient in a list, for example.
+
+But what if you don't know how many times you need to repeat? What if you need to repeat an action *until* a certain condition is met?
+
+This is where the **`while` loop** comes in. It's like waiting for a pot of water to boil. You don't say, "I'm going to check the temperature 10 times." You say, "**While** the water is not yet boiling, I will keep waiting."
+
+A `while` loop continuously executes a block of code as long as a given condition remains `true`.
+
+### The Danger of a Never-Ending Boil
+
+A `while` loop needs one crucial thing: something inside the loop must eventually change the condition to `false`. If not, the loop will run forever, creating an **infinite loop**.
+
+```admonish warning title="Infinite Loop Warning!"
+An infinite loop is a common bug where a loop's condition never becomes `false`. This will cause your program to get stuck and become unresponsive. It’s like a chef who turns on a mixer and forgets to turn it off—it will just keep running until you pull the plug! Always make sure your loop is making progress toward its end condition.
+```
+
+Let's simulate our boiling water example. We'll start with a low temperature and keep "heating" it (increasing the value) inside the loop until it reaches the boiling point.
+
+<!-- langtabs-start -->
+
+```python
+water_temp = 20 # The starting temperature in Celsius
+
+print("Putting the pot on the stove...")
+
+# The loop will continue as long as this condition is True.
+while water_temp < 100:
+  print(f"Water is at {water_temp}°C. Still simmering...")
+  # This is the crucial part: we change the value we are checking.
+  # Each time the loop runs, the temperature gets closer to 100.
+  water_temp += 10
+
+# Once water_temp is 100 or more, the condition becomes False,
+# and the loop stops. This line runs next.
+print(f"Ding! The water is at {water_temp}°C. Time to add the pasta!")
+```
+
+```javascript
+let waterTemp = 20; // The starting temperature in Celsius
+
+console.log("Putting the pot on the stove...");
+
+// The loop will continue as long as this condition is true.
+while (waterTemp < 100) {
+  console.log(`Water is at ${waterTemp}°C. Still simmering...`);
+  // This is the crucial part: we change the value we are checking.
+  // Each time the loop runs, the temperature gets closer to 100.
+  waterTemp += 10;
+}
+
+// Once waterTemp is 100 or more, the condition becomes false,
+// and the loop stops. This line runs next.
+console.log(`Ding! The water is at ${waterTemp}°C. Time to add the pasta!`);
+```
+
+<!-- langtabs-end -->
+
+The `while` loop is essential for situations where the number of iterations isn't known beforehand, like waiting for a user to type "quit", processing data until a file ends, or, in our final project, giving a player guesses until they win or run out of tries.