update notebooks

Python/006_dictionaries.py

@@ -15,17 +15,17 @@ app = marimo.App()
 def _(mo):
     mo.md(
         """
-        # 📚 Python Dictionaries
+        # 📚 Dictionaries
 
-        Welcome to the world of Python dictionaries — where data gets organized with keys! 
+        Dictionaries are collections of key-value pairs, with each key associated with a value. The keys are unique, meaning they show up only once.
 
-        ## Creating Dictionaries
-        Dictionaries are collections of key-value pairs. Here's how to create them:
+        ## Creating dictionaries
+        Here are a few ways to create dictionaries:
 
         ```python
-        simple_dict = {"name": "Alice", "age": 25}  # direct creation
-        empty_dict = dict()                         # empty dictionary
-        from_pairs = dict([("a", 1), ("b", 2)])    # from key-value pairs
+        simple_dict = {"name": "Alice", "age": 25}
+        empty_dict = dict()
+        from_pairs = dict([("a", 1), ("b", 2)])
         ```
 
         Below is a sample dictionary we'll use to explore operations.
@@ -50,10 +50,23 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Basic Dictionary Operations
+        ## Operations
 
         Let's explore how to work with dictionaries.
-        Try modifying the `sample_dict` above and watch how the results change!
+
+        **Try it!** Try modifying the `sample_dict` above and watch how the results change!
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### Accessing values by key
+
+        Access values by key using square brackets, like below
         """
     )
     return
@@ -61,35 +74,29 @@ def _(mo):
 
 @app.cell
 def _(sample_dict):
-    # Accessing values of the dictionary
-    def access_dict():
-        print(f"Name: {sample_dict['name']}")
-        print(f"Year: {sample_dict['year']}")
+    sample_dict['name'], sample_dict['year']
+    return
 
 
-    access_dict()
-    return (access_dict,)
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""If you're not sure if a dictionary has a given key, use `get()`:""")
+    return
 
 
 @app.cell
 def _(sample_dict):
-    # Safe access with get()
-    def safe_access():
-        print(f"Version: {sample_dict.get('version', 'Not specified')}")
-        print(f"Type: {sample_dict.get('type', 'Unknown')}")
-
-
-    safe_access()
-    return (safe_access,)
+    sample_dict.get("version", "Not specified"), sample_dict.get("type", "Unknown")
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Dictionary Methods
+        ## Enumerating dictionary contents
 
-        Python dictionaries come with powerful built-in methods:
+        Python dictionaries come with helpful methods to enumerate keys, values, and pairs.
         """
     )
     return
@@ -97,20 +104,24 @@ def _(mo):
 
 @app.cell
 def _(sample_dict):
-    # Viewing dictionary components
-    def view_components():
-        print("Keys:", list(sample_dict.keys()))
-        print("Values:", list(sample_dict.values()))
-        print("Items:", list(sample_dict.items()))
+    print(list(sample_dict.keys()))
+    return
+
+
+@app.cell
+def _(sample_dict):
+    print(list(sample_dict.values()))
+    return
 
 
-    view_components()
-    return (view_components,)
+@app.cell
+def _(sample_dict):
+    print(list(sample_dict.items()))
+    return
 
 
 @app.cell
 def _():
-    # Modifying dictionaries
     def demonstrate_modification():
         _dict = {"a": 1, "b": 2}
         print("Original:", _dict)
@@ -132,7 +143,7 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Dictionary Comprehension
+        ## Dictionary comprehension
 
         Create dictionaries efficiently with dictionary comprehensions:
         """
@@ -142,26 +153,21 @@ def _(mo):
 
 @app.cell
 def _():
-    # Dictionary comprehension examples
-    def demonstrate_comprehension():
-        # Squares dictionary
-        _squares = {x: x**2 for x in range(5)}
-        print("Squares:", _squares)
-
-        # Filtered dictionary
-        _even_squares = {x: x**2 for x in range(5) if x % 2 == 0}
-        print("Even squares:", _even_squares)
+    print({x: x**2 for x in range(5)})
+    return
 
 
-    demonstrate_comprehension()
-    return (demonstrate_comprehension,)
+@app.cell
+def _():
+    print({x: x**2 for x in range(5) if x % 2 == 0})
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Nested Dictionaries
+        ## Nested dictionaries
 
         Dictionaries can contain other dictionaries, creating complex data structures:
         """
@@ -189,40 +195,22 @@ def _():
 
 
 @app.cell
-def _(nested_data):
-    # Accessing nested data
-    def access_nested():
-        print("Alice's age:", nested_data["users"]["alice"]["age"])
-        print("Bob's interests:", nested_data["users"]["bob"]["interests"])
-
-        # Safe nested access
-        def _get_nested(data, *keys, default=None):
-            _current = data
-            for _key in keys:
-                if isinstance(_current, dict):
-                    _current = _current.get(_key, default)
-                else:
-                    return default
-            return _current
-
-        print("\nSafe access example:")
-        print(
-            "Charlie's age:",
-            _get_nested(
-                nested_data, "users", "charlie", "age", default="Not found"
-            ),
-        )
-
-
-    access_nested()
-    return (access_nested,)
+def _(mo, nested_data):
+    mo.md(f"Alice's age: {nested_data["users"]["alice"]["age"]}")
+    return
+
+
+@app.cell
+def _(mo, nested_data):
+    mo.md(f"Bob's interests: {nested_data["users"]["bob"]["interests"]}")
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Common Dictionary Patterns
+        ## Common dictionary patterns
 
         Here are some useful patterns when working with dictionaries:
 
@@ -250,25 +238,6 @@ def _(mo):
     return
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Master the Dictionary!
-
-    Next Steps:
-
-    - Practice different dictionary methods
-    - Try creating nested data structures
-    - Experiment with dictionary comprehensions
-    - Build something using common patterns
-
-    Keep organizing your data! 🗂️✨
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
-
-
 @app.cell
 def _():
     import marimo as mo

Python/007_advanced_collections.py

@@ -7,27 +7,22 @@
 
 import marimo
 
-__generated_with = "0.10.14"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🔄 Advanced Collections in Python
+        # 🔄 Advanced Collections
 
-        Let's dive deep into advanced collection handling in Python! 
+        This tutorials hows advanced patterns for working with collections.
 
-        ## Lists of Dictionaries
-        A common pattern in data handling is working with lists of dictionaries - 
-        perfect for representing structured data like records or entries.
+        ## Lists of dictionaries
+
+        A common pattern in data handling is working with lists of dictionaries:
+        this is helpful for representing structured data like records or entries.
         """
     )
     return
@@ -48,10 +43,10 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Working with Lists of Dictionaries
-
         Let's explore common operations on structured data.
-        Try modifying the `users_data` above and see how the results change!
+
+        **Try it!** Try modifying the `users_data` above and see how the results
+        change!
         """
     )
     return
@@ -60,18 +55,22 @@ def _(mo):
 @app.cell
 def _(users_data):
     # Finding users with specific skills
-    python_users = [user["name"] for user in users_data if "Python" in user["skills"]]
+    python_users = [
+        user["name"] for user in users_data if "Python" in user["skills"]
+    ]
     print("Python developers:", python_users)
     return (python_users,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
+    mo.md(
+        """
         ## Nested Data Structures
 
         Python collections can be nested in various ways to represent complex data:
-        """)
+        """
+    )
     return
 
 
@@ -110,11 +109,13 @@ def _(project_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Data Transformation
+    mo.md(
+        """
+        ### Example: data transformation
 
         Let's explore how to transform and reshape collection data:
-        """)
+        """
+    )
     return
 
 
@@ -148,10 +149,11 @@ def _(sales_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Collection Utilities
+    mo.md(
+        """
+        ## More collection utilities
 
-        Python's collections module provides specialized container datatypes:
+        Python's `collections` module provides specialized container datatypes:
 
         ```python
         from collections import defaultdict, Counter, deque
@@ -169,7 +171,8 @@ def _(mo):
         history = deque(maxlen=10)  # Only keeps last 10 items
         history.append(item)
         ```
-        """)
+        """
+    )
     return
 
 
@@ -191,20 +194,21 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Level Up Your Collections!
-
-    Next Steps:
+    mo.md(
+        """
+        ## Next steps
 
-    - Practice transforming complex data structures
-    - Experiment with different collection types
-    - Try combining multiple data structures
+        For a reference on the `collections` module, see [the official Python 
+        docs](https://docs.python.org/3/library/collections.html).
+        """
+    )
+    return
 
-    Keep organizing! 📊✨
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/008_functions.py

@@ -7,57 +7,69 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🧩 Function Design in Python
+        # 🧩 Functions
 
-        Dive into the world of Python functions — where code becomes modular and powerful!
+        This tutorial is about an important topic: **functions.**
 
-        ## Function Basics
-        Functions help you:
+        A function is a reusable block of code, similar in spirit to a mathematical function. Each function has a **name**, and accepts some number of **arguments**. These arguments are used in the function "body" (its block of code), and each function can **return** values.
 
-        - Break down complex problems
+        **Example.** Below is an example function.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    def greet(your_name):
+        return f"Hello, {your_name}!"
+    return (greet,)
 
-        - Create reusable code blocks
 
-        - Improve code readability (good practice)
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""The keyword `def` starts the function definition. The function's **name** is `greet`. It accepts one **argument** called `your_name`. It then creates a string and **returns** it.""")
+    return
 
-        ```python
-        def function_name(parameters):
-            '''Docstring explaining the function'''
-            # Function body
-            return result
-        ```
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        In the next cell, we **call** the function with a value and assign its return value to a variable.
+
+        **Try it!** Try changing the input to the function.
         """
     )
     return
 
 
 @app.cell
-def _():
-    # Example function with parameter
-    def greet(name):
-        return f"Hello, {name}!"
+def _(greet):
+    greeting = greet(your_name="<your name here>")
+    greeting
+    return (greeting,)
 
-    name = "Python Learner"
-    return greet, name
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        **Why use functions?** Functions help you:
 
-@app.cell
-def _(greet, name):
-    greet(name)
+        - Break down complex problems
+        - Create reusable code blocks
+        - Improve code readability
+        """
+    )
     return
 
 
@@ -65,7 +77,7 @@ def _(greet, name):
 def _(mo):
     mo.md(
         """
-        ## Default Parameters
+        ## Default parameters
         Make your functions more flexible by providing default values.
         """
     )
@@ -74,21 +86,30 @@ def _(mo):
 
 @app.cell
 def _():
-    # Function with default parameter
     def create_profile(name, age=18):
         return f"{name} is {age} years old"
+    return (create_profile,)
+
 
+@app.cell
+def _(create_profile):
     # Example usage
     example_name = "Alex"
     example_profile = create_profile(example_name)
     example_profile
-    return create_profile, example_name, example_profile
+    return example_name, example_profile
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""You can also create functions that reference variables outside the function body. This is called 'closing over' variables""")
+    return
 
 
 @app.cell
 def _():
-    # Show closure over values
     base_multiplier = 2
+
     def multiplier(x):
         """
         Create a function that multiplies input by a base value.
@@ -97,49 +118,12 @@ def _():
         values from their surrounding scope.
         """
         return x * base_multiplier
-
-    # Example of using the closure
-    sample_numbers = [1, 2, 3, 4, 5]
-    multiplied_numbers = [multiplier(num) for num in sample_numbers]
-    print(multiplied_numbers)
-    return base_multiplier, multiplied_numbers, multiplier, sample_numbers
+    return base_multiplier, multiplier
 
 
 @app.cell
-def _():
-    def calculate(a, b):
-        """
-        Perform multiple calculations on two numbers.
-
-        Args:
-            a (int): First number
-            b (int): Second number
-
-        Returns:
-            dict: Results of various calculations
-        """
-        return {
-            "sum": a + b,
-            "product": a * b,
-            "difference": a - b,
-            "max": max(a, b)
-        }
-
-    # Example usage with concrete values
-    first_number = 10
-    second_number = 5
-    result = calculate(first_number, second_number)
-    return calculate, first_number, result, second_number
-
-
-@app.cell(hide_code=True)
-def _(mo, result):
-    mo.md(f"""
-    ## Function Results
-
-    Calculation Results:
-    {result}
-    """)
+def _(multiplier):
+    print([multiplier(num) for num in [1, 2, 3]])
     return
 
 
@@ -147,16 +131,10 @@ def _(mo, result):
 def _(mo):
     mo.md(
         """
-        ## Multiple Return Values
-        Python allows returning multiple values easily:
-
-        ```python
-        def multiple_returns():
-            return value1, value2, value3
+        ## Returning multiple values
 
-        # Unpacking returns
-        x, y, z = multiple_returns()
-        ```
+        Functions can return multiple values: just separate the values to return by
+        commas. Check out the next cell for an example.
         """
     )
     return
@@ -182,47 +160,26 @@ def _():
             return "Mild", "Comfortable clothing", "Low"
         else:
             return "Hot", "Stay hydrated", "High"
+    return (weather_analysis,)
 
-    # Example temperature analysis
-    temperature = 25
-    status, recommendation, warning_level = weather_analysis(temperature)
-    return (
-        recommendation,
-        status,
-        temperature,
-        warning_level,
-        weather_analysis,
-    )
 
+@app.cell
+def _():
+    temperature = 25
+    return (temperature,)
 
-@app.cell(hide_code=True)
-def _(mo, recommendation, status, warning_level):
-    mo.md(f"""
-    ## Function Results
-
-    Calculation Results:
-    {status}, {recommendation}, {warning_level}
-    """)
-    return
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Function Design Journey!
-
-    Next Steps:
-
-    - Practice creating functions
-
-    - Experiment with default parameters
 
-    - Explore multiple return values
+@app.cell
+def _(temperature, weather_analysis):
+    status, recommendation, warning_level = weather_analysis(temperature)
+    status, recommendation, warning_level
+    return recommendation, status, warning_level
 
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/{009_modular_programming.py → 009_modules.py}

@@ -7,29 +7,21 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🧩 Modular Programming in Python
+        # 🧩 Using modules
 
-        Unlock the power of organized, reusable, and maintainable code!
+        A `module` in Python is a Python file that defines functions and variables. Modules can be `imported` into other Python files, letting you reuse their
+        functions and variables.
 
-        ## Why Modular Programming?
-        - Break complex problems into smaller, manageable pieces
-        - Improve code readability
-        - Enhance code reusability
-        - Easier debugging and maintenance
+        We have already seen some modules in previous tutorials, including the `math`
+        module. Python comes with many other modules built-in.
         """
     )
     return
@@ -39,8 +31,9 @@ def _(mo):
 def _(mo):
     mo.md(
         """
-        ## Standard Library Imports
-        Python's standard library provides powerful, pre-built modules:
+        ## The Python standard library
+
+        Python's "standard library" provides many modules, for many kinds of tasks.
 
         ```python
         # String manipulation
@@ -56,15 +49,20 @@ def _(mo):
         import math
         ```
 
-        For more details, check the [Python Standard Library Documentation](https://docs.python.org/3/library/)
+        See the [Python standard library documentation](https://docs.python.org/3/library/) for a full reference
         """
     )
     return
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""### Example""")
+    return
+
+
 @app.cell
 def _():
-    # importing and using standard library modules
     import string
     import os
     import datetime
@@ -108,8 +106,9 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Import Strategies
-        Multiple ways to import and use modules:
+        ## Import syntax
+
+        You can import entire modules, and access their functions and variables using dot notation (`math.sqrt`). Or you can import specific members:
 
         ```python
         # Import entire module
@@ -160,8 +159,16 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Code Reusability
-        Create functions that can be used across different parts of your project
+        ## Third-party packages
+
+        In addition to Python's standard library, there are hundreds of thousands of
+        modules available for free on the Python Package index.
+
+        These are distributed as Python "packages", and include packages for
+        manipulating arrays of numbers, creating web applications, and more. `marimo`
+        itself is a third-party package!
+
+        For installing packages on your machine, we recommend using the [`uv` package manager](https://docs.astral.sh/uv/).
         """
     )
     return
@@ -169,64 +176,8 @@ def _(mo):
 
 @app.cell
 def _():
-    def generate_reusable_functions():
-        """
-        Demonstrate different types of reusable functions
-        """
-
-        def process_text(text):
-            '''Reusable text processing function'''
-            return text.strip().lower()
-
-        def normalize_number(value, min_val=0, max_val=100):
-            '''Normalize a number to a specific range'''
-            return max(min_val, min(max_val, value))
-
-        def validate_input(value, type_check=str, min_length=1):
-            '''Validate input based on type and minimum length'''
-            if not isinstance(value, type_check):
-                return False
-            return len(str(value)) >= min_length
-
-        # usage
-        return {
-            "Text Processing": {
-                "Example 1": process_text("  John Doe  "),
-                "Example 2": process_text("  [email protected]  ")
-            },
-            "Number Normalization": {
-                "Oversized Input": normalize_number(150),
-                "Negative Input": normalize_number(-10, min_val=-20, max_val=50)
-            },
-            "Input Validation": {
-                "Username Validation": validate_input("john"),
-                "Age Validation": validate_input(25, type_check=int)
-            }
-        }
-
-    # Run the reusable functions demonstration
-    reusable_function_examples = generate_reusable_functions()
-    reusable_function_examples
-    return generate_reusable_functions, reusable_function_examples
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Modular Programming Journey!
-
-    Next Steps:
-
-    - Explore Python's standard library
-
-    - Practice different import strategies
-
-    - Design reusable functions
-
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/010_exceptions.py

@@ -7,44 +7,78 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        # 🛡️ Handling errors
+
+        Sometimes things go wrong in programs. When that happens, Python raises `exceptions` to tell you what went amiss. For example, maybe you divided by 0:
+        """
+    )
+    return
+
+
 @app.cell
 def _():
-    import marimo as mo
-    return (mo,)
+    1 / 0
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🛡️ Error Management in Python
+        That's a lot of red! The outputs above are Python telling you that
+        something went wrong — in this case, we tried dividing a number by 0.
+
+        Python provides tools to catch and handle exceptions: the `try/except`
+        block. This is demonstrated in the next couple cells.
+        """
+    )
+    return
 
-        Welcome to the world of Python error handling - where bugs become learning opportunities! 
 
-        ## Why Error Handling Matters
-        Imagine your code as a superhero navigating through the treacherous landscape of potential problems. 
-        Error handling is like your hero's shield, protecting your program from unexpected challenges.
+@app.cell
+def _():
+    # Try changing the value of divisor below, and see how the output changes.
+    divisor = 0
+    return (divisor,)
 
-        ```python
-        # Without error handling
-        result = 10 / 0  # 💥 Boom! Unhandled ZeroDivisionError
 
-        # With error handling
+@app.cell
+def _(divisor):
+    try:
+        print(1 / divisor)
+    except ZeroDivisionError as e:
+        print("Something went wrong!", e)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        Python has many types of Exceptions besides `ZeroDivisionError`. If you
+        don't know what kind of exception you're handling, catch the generic
+        `Exception` type:
+
+        ```python
         try:
-            result = 10 / 0
-        except ZeroDivisionError:
-            result = "Oops! Can't divide by zero 🛑"
+            ...
+        except Exception:
+            ...
         ```
         """
     )
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(error_types):
     error_types
     return
@@ -54,6 +88,7 @@ def _(error_types):
 def _(mo):
     # Choose error type
     error_types = mo.ui.dropdown(
+        value="ZeroDivisionError",
         options=[
             "ZeroDivisionError", 
             "TypeError", 
@@ -61,7 +96,7 @@ def _(mo):
             "IndexError", 
             "KeyError"
         ],
-        label="Select an Error Type to Explore"
+        label="Learn about ..."
     )
     return (error_types,)
 
@@ -122,58 +157,12 @@ def _(error_types, mo):
     return (error_explanations,)
 
 
-@app.cell
-def _(division_input, divisor_input, mo):
-    mo.hstack([division_input, divisor_input])
-    return
-
-
 @app.cell(hide_code=True)
 def _(mo):
-    # Try-Except work help
-    division_input = mo.ui.number(
-        value=10, 
-        label="Number to Divide", 
-        start=-100, 
-        stop=100
-    )
-    divisor_input = mo.ui.number(
-        value=0, 
-        label="Divisor", 
-        start=-100, 
-        stop=100
-    )
-    return division_input, divisor_input
-
-
-@app.cell
-def _(division_input, divisor_input, mo):
-    # Safe division function with appropriate error handling
-    def safe_divide(numerator, denominator):
-        try:
-            _result = numerator / denominator
-            return f"Result: {_result}"
-        except ZeroDivisionError:
-            return "🚫 Cannot divide by zero!"
-        except Exception as e:
-            return f"Unexpected error: {e}"
-
-    # Display result with explanation
-    _result = safe_divide(division_input.value, divisor_input.value)
-
-    mo.hstack([
-        mo.md(f"**Division**: {division_input.value} ÷ {divisor_input.value}"),
-        mo.md(f"**Result**: {_result}")
-    ])
-    return (safe_divide,)
-
-
-@app.cell
-def _(mo):
-    # Multiple Exception Handling
     mo.md(
         """
-        ## Multiple Exception Handling
+        ## Handling multiple exception types
+        
         Catch and handle different types of errors specifically:
 
         ```python
@@ -188,64 +177,28 @@ def _(mo):
                 return "No division by zero!"
             except ValueError:
                 return "Conversion error!"
+            finally:
+                # The `finally` block always runs, regardless if there
+                # was an error or not
+                ...
+                
         ```
         """
     )
     return
 
 
-@app.cell
-def _(error_chain_input):
-    error_chain_input
-    return
-
-
-@app.cell
-def _(mo):
-    # Try it out
-    error_chain_input = mo.ui.text(
-        label="Try to break the code",
-        placeholder="Enter something tricky..."
-    )
-    return (error_chain_input,)
-
-
-@app.cell
-def _(error_chain_input, mo):
-    # Error chain demonstration
-    def tricky_function(input_str):
-        try:
-            # Simulating a error scenario
-            number = int(input_str)
-            result = 100 / number
-            return f"Success! Result: {result}"
-        except ValueError:
-            return "❌ Could not convert to number"
-        except ZeroDivisionError:
-            return "❌ Cannot divide by zero"
-        except Exception as e:
-            return f"🤯 Unexpected error: {type(e).__name__}"
-
-    result = tricky_function(error_chain_input.value)
-
-    mo.hstack([
-        mo.md(f"**Input**: {error_chain_input.value}"),
-        mo.md(f"**Result**: {result}")
-    ])
-    return result, tricky_function
-
-
-@app.cell
+@app.cell(hide_code=True)
 def _(finally_input):
     finally_input
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     # Finally Block Demonstration
     finally_input = mo.ui.switch(
-        label="Simulate Resource Management",
+        label="Throw an error?",
         value=True
     )
     return (finally_input,)
@@ -256,7 +209,7 @@ def _(finally_input, mo):
     def simulate_resource_management():
         try:
             # Simulating a resource-intensive operation
-            if finally_input.value:
+            if not finally_input.value:
                 return "🟢 Resource processing successful"
             else:
                 raise Exception("Simulated failure")
@@ -265,12 +218,13 @@ def _(finally_input, mo):
         finally:
             return "📦 Resource cleanup completed"
 
+
     _result = simulate_resource_management()
 
     mo.md(f"""
-    ### Resource Management Simulation
+    ### Example: the finally clause
 
-    **Scenario**: {'Normal operation' if finally_input.value else 'Error scenario'}
+    **Scenario**: {"Normal operation" if not finally_input.value else "An exception was raised"}
 
     **Result**: {_result}
 
@@ -279,22 +233,10 @@ def _(finally_input, mo):
     return (simulate_resource_management,)
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Error Handling Journey Continues!
-
-    Next Steps:
-
-    - Practice creating custom exceptions
-    - Explore context managers
-    - Build robust error-handling strategies
-
-    You're becoming a Python error-handling ninja! 🥷🐍
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":