diff --git a/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Solution_Nelson.ipynb b/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Solution_Nelson.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..a210647f41498c6ca1130bd6705699758588fa9c
--- /dev/null
+++ b/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Solution_Nelson.ipynb
@@ -0,0 +1,670 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup: Review Worksheet Exercises."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup: \n",
+    "# Run this program and think of 2 different kinds of inputs that would crash it.\n",
+    "\n",
+    "# Name the Runtime errors that occurred here:\n",
+    "# ...Entering a slice count of 0....divide by 0   ZeroDivisionError\n",
+    "# ...Entering non-numbers                         ValueError\n",
+    "# ...Entering only 1 number or no comma           IndexError\n",
+    "\n",
+    "# Then, think of other inputs that will give Semantic Errors\n",
+    "# ...Entering a negative number\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    # What do we assume is true here?\n",
+    "    return (radius ** 2) * math.pi     # SemanticError\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    # What could go wrong here?\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)  # ZeroDivisionError\n",
+    "\n",
+    "# What could go wrong here? \n",
+    "args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "args = args.split(',')\n",
+    "radius = float(args[0].strip()) / 2 # ValueError\n",
+    "slices = int(args[1].strip())       # IndexError, ValueError\n",
+    "\n",
+    "size = slice_size(radius, slices)\n",
+    "print('Each pizza slice will be {} square inches'.format(size))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Lecture 25: Error Handling\n",
+    "\n",
+    "**Learing Objectives:**\n",
+    "    \n",
+    " - Explain the purpose of assert statements, try/except blocks, and raise statements.\n",
+    "\n",
+    " - Use an assert statement to force a program to crash, and trace code that uses assert.\n",
+    "\n",
+    " - Use try/except blocks to catch runtime errors and deal with them\n",
+    "   - by specifying the exception(s) caught\n",
+    "   - by using the exception object\n",
+    "\n",
+    " - Use the raise statement to raise an exception that may be caught in another part of the program\n",
+    "\n",
+    " - Hand trace code that uses assert, try/except blocks and raise statements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Being 'Assert'ive\n",
+    "`assert` makes code 'fail fast' rather than continuing with bad data. This is useful because we would prefer to have runtime errors over semantic (thinking) errors.\n",
+    "\n",
+    "An `assert` statement takes a boolean condition, e.g. `assert my_list != []` would assert that the list is not empty.\n",
+    "\n",
+    "If the assert statement is True, nothing happens. If the assert statement is False, a runtime error occurs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age = int(input(\"Enter your age: \"))\n",
+    "assert age >= 0\n",
+    "print(\"In five years, you will be\", age + 5, \"years old\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You try!\n",
+    "# In pizza_size, assert that the radius is positive.\n",
+    "# In slice_size assert that slice_count is positive.\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    assert radius > 0\n",
+    "    return (radius ** 2) * math.pi\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    assert slice_count >= 1\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)\n",
+    "\n",
+    "args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "args = args.split(',')\n",
+    "\n",
+    "radius = float(args[0].strip()) / 2\n",
+    "slices = int(args[1].strip())\n",
+    "\n",
+    "size = slice_size(radius, slices)\n",
+    "print('Each pizza slice will be {} square inches'.format(size))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Use `try`/`except` blocks to \"catch\" runtime errors\n",
+    "`assert` isn't always the prettiest for the user -- their program crashes!\n",
+    "\n",
+    "Often, we prefer to use `try` and `except`. `try` and `except` blocks come in pairs. Python tries to run the code in the `try` block, but if there’s an exception, it jumps to the `except` block -- it does not crash! We call this \"catching\" the exception. If there is no exception, the `except` block does not run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:  \n",
+    "    print(\"2 inverse is\", 1/2)\n",
+    "    print(\"1 inverse is\", 1/1)\n",
+    "    print(\"0 inverse is\", 1/0)   # this line results in a RuntimeError\n",
+    "    print(\"-1 inverse is\", 1/-1)\n",
+    "    print(\"-2 inverse is\", 1/-2)\n",
+    "except:\n",
+    "    print(\"Something bad happened :(\")\n",
+    "    \n",
+    "print(\"Just like ifs, we join here!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You try! Catch the error before the program crashes.\n",
+    "# For this example, do NOT use an if statement!\n",
+    "pizza_slices = 8\n",
+    "try:\n",
+    "    num_people = int(input(\"Enter a number of people to divide the pizza among: \"))\n",
+    "    assert num_people > 0\n",
+    "    pizza_per_person = pizza_slices / num_people\n",
+    "    print(pizza_per_person, \"slices per person.\")\n",
+    "except:\n",
+    "    print(\"Please use a valid number.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Being Descriptive\n",
+    "We can be more descriptive by saying `except Exception as e` and printing out information with `e`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:  \n",
+    "    print(\"2 inverse is\", 1/2)\n",
+    "    print(\"1 inverse is\", 1/1)\n",
+    "    print(\"0 inverse is\", 1/0)   # this line results in a RuntimeError\n",
+    "    print(\"-1 inverse is\", 1/-1)\n",
+    "    print(\"-2 inverse is\", 1/-2)\n",
+    "except Exception as e:\n",
+    "    print(\"Something bad happened :(\")\n",
+    "    print(type(e))\n",
+    "    print(str(e))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a try/catch block to handle all errors\n",
+    "# Be descriptive, print out the error type and message.\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    assert radius > 0\n",
+    "    return (radius ** 2) * math.pi\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    assert slice_count >= 1\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)\n",
+    "\n",
+    "while(True):\n",
+    "    args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "    args = args.split(',')\n",
+    "    \n",
+    "    try:\n",
+    "        radius = float(args[0].strip()) / 2\n",
+    "        slices = int(args[1].strip())\n",
+    "        size = slice_size(radius, slices)\n",
+    "        print('Each pizza slice will be {} square inches'.format(size))\n",
+    "    except Exception as e:\n",
+    "        print(\"Something went wrong!\")\n",
+    "        print(type(e))\n",
+    "        print(str(e))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Nested Exceptions\n",
+    "Exceptions can be thrown from any function. If that function cannot handle the exception, the exception goes to the calling function. If that function cannot handle the exception, to its calling function. If no calling function can handle the exception, the program crashes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    assert cust_happy.lower() == 'y'\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        matt()\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can choose where to handle an exception, e.g. defer all complaints to corporate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    assert cust_happy.lower() == 'y'\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "... or handle them ourselves ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    try:\n",
+    "        print(\"Cole: Hello! :)\")\n",
+    "        cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "        assert cust_happy.lower() == 'y'\n",
+    "        print(\"Cole: Great! :)\")\n",
+    "    except Exception as e:\n",
+    "        print(\"Cole: Dang that's rough\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "... or somewhere in between!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `raise` Our Own Errors\n",
+    "Rather than using `assert` we can also `raise` an error. As we can see by `type(e)`, there are different types of errors in Python. These form a hierarchy [(see here)](https://docs.python.org/3/library/exceptions.html). It helps to know some common exceptions, but you don't need to memorize them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's check if the customer is happy and if they have found everything they needed.\n",
+    " - If they are not happy, `raise` a `FutureWarning`. Corporate can handle this.\n",
+    " - If they have not found everything they needed, `raise` a `ResourceWarning`. Matt can handle this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    cust_found = input(\"Cole: Did you find everything that you needed?\")\n",
+    "    if cust_found.lower() != 'y':\n",
+    "        raise ResourceWarning(\"We are running out of resources!\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    try:\n",
+    "        cole()\n",
+    "    except Exception as e: # ALMOST correct....\n",
+    "        print(\"Matt: I'll order some more!\")\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e: \n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What's wrong with the above function? Fix it below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    cust_found = input(\"Cole: Did you find everything that you needed?\")\n",
+    "    if cust_found.lower() != 'y':\n",
+    "        raise ResourceWarning(\"We are running out of resources!\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    try:\n",
+    "        cole()\n",
+    "    except ResourceWarning as e:\n",
+    "        print(\"Matt: I'll order some more!\")\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e: \n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's also ask the customer if they are feeling healthy. If not, we should `raise` a `UserWarning` and Matt should ask them to leave the store."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    cust_found = input(\"Cole: Did you find everything that you needed?\")\n",
+    "    if cust_found.lower() != 'y':\n",
+    "        raise ResourceWarning(\"We are running out of resources!\")\n",
+    "    cust_healthy = input(\"Cole: Are you feeling healthy today?\")\n",
+    "    if cust_healthy.lower() != 'y':\n",
+    "        raise UserWarning(\"The customer is feeling sick...\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    try:\n",
+    "        cole()\n",
+    "    except ResourceWarning as rw:\n",
+    "        print(\"Matt: I'll order some more!\")\n",
+    "    except UserWarning as uw:\n",
+    "        print(\"Matt: Please leave the store :(\")\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e: \n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Consider the code below and answer the following questions...\n",
+    "\n",
+    "# In your own words, describe what the code does.\n",
+    "# There is a random chance each one of our \"flaky\" functions break,\n",
+    "# and we attempt to catch the exceptions as they happen.\n",
+    "\n",
+    "# In a single iteration, can a FloatingPointError and OverflowError be thrown?\n",
+    "# No, since these are in the same try/catch block, as soon as there is an exception,\n",
+    "# we will skip to the \"except\" block. Either one (or neither) may be thrown,\n",
+    "# but not both.\n",
+    "\n",
+    "# In a single iteration, can a OSError follow an OverflowError?\n",
+    "# Yes. Although we catch the overflow error if it happens,\n",
+    "# there is a 1% chance an OSError follows. They are not in the\n",
+    "# same try/except block.\n",
+    "\n",
+    "# Are there any error(s) we are not catching? If so, name them.\n",
+    "# We are not catching an OSError as it is not inside a try/catch.\n",
+    "# We are also not catching a PermissionError as neither the type\n",
+    "# nor supertype is in the except block.\n",
+    "\n",
+    "# Are there any error(s) we are catching but not raising?\n",
+    "# Yes, FileExistsError is not raised by anything."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import time\n",
+    "\n",
+    "def flaky_math_func1():\n",
+    "    if(random.random() < .5):\n",
+    "        raise FloatingPointError(\"Something went wrong doing some float math!\")\n",
+    "        \n",
+    "def flaky_math_func2():\n",
+    "    if(random.random() < .5):\n",
+    "        raise OverflowError(\"Something went wrong doing some big math!\")\n",
+    "        \n",
+    "def flaky_os_func():\n",
+    "    if(random.random() < .01):\n",
+    "        raise OSError(\"Something went wrong in the OS!\")\n",
+    "        \n",
+    "def flaky_impl_func():\n",
+    "    if(random.random() < .05):\n",
+    "        raise NotImplementedError(\"Something went wrong in the implementation!\")\n",
+    "        \n",
+    "def flaky_perm_func():\n",
+    "    if(random.random() < .2):\n",
+    "        raise PermissionError(\"I don't have permission to do that!\")\n",
+    "         \n",
+    "while(True):\n",
+    "    print(\"Beginning the flaky functions!\")\n",
+    "    \n",
+    "    \n",
+    "    try:\n",
+    "        flaky_math_func1()\n",
+    "        flaky_math_func2()\n",
+    "    except ArithmeticError as e:\n",
+    "        print(\"Phew! I avoided a\", type(e))\n",
+    "        \n",
+    "    flaky_os_func()\n",
+    "    \n",
+    "    try:\n",
+    "        flaky_impl_func()\n",
+    "        flaky_perm_func()\n",
+    "    except (RuntimeError, FileExistsError) as e:\n",
+    "        print(\"Phew! I avoided a\", type(e))\n",
+    "    \n",
+    "    print(\"End of flaky functions!\")\n",
+    "    print()\n",
+    "    \n",
+    "    time.sleep(10) # wait 10 seconds, give time to read the output."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A Word on Hierarchy\n",
+    "All dogs are animals, but not all animals are dogs.\n",
+    "\n",
+    "All ZeroDivisionErrors are ArithmeticErrors, but not all ArithmeticErrors are ZeroDivisionErrors."
+   ]
+  },
+  {
+   "attachments": {
+    "1_iP78XqAbkntOuzbHCoiubg.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![1_iP78XqAbkntOuzbHCoiubg.png](attachment:1_iP78XqAbkntOuzbHCoiubg.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Source](https://levelup.gitconnected.com/java-classes-and-objects-a312db4bc785) (yes this is a Java resource -- but applicable to MANY programming languages!)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Template_Nelson.ipynb b/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Template_Nelson.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..751e6b3cd2ffc3edaa7602a111b153ddcb8a36c3
--- /dev/null
+++ b/f23/Cole_Lecture_Notes/25_Error_Handling/Lec25_Error_Handling_Template_Nelson.ipynb
@@ -0,0 +1,615 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup: Review Worksheet Exercises."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Warmup: \n",
+    "# Run this program and think of 2 different kinds of inputs that would crash it.\n",
+    "\n",
+    "# Name the Runtime errors that occurred here:\n",
+    "#\n",
+    "\n",
+    "# Then, think of other inputs that will give Semantic Errors\n",
+    "#\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    # What do we assume is true here?\n",
+    "    return (radius ** 2) * math.pi\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    # What could go wrong here?\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)\n",
+    "\n",
+    "# What could go wrong here? \n",
+    "args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "args = args.split(',')\n",
+    "radius = float(args[0].strip()) / 2\n",
+    "slices = int(args[1].strip())\n",
+    "\n",
+    "size = slice_size(radius, slices)\n",
+    "print('Each pizza slice will be {} square inches'.format(size))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Lecture 25: Error Handling\n",
+    "\n",
+    "**Learing Objectives:**\n",
+    "    \n",
+    " - Explain the purpose of assert statements, try/except blocks, and raise statements.\n",
+    "\n",
+    " - Use an assert statement to force a program to crash, and trace code that uses assert.\n",
+    "\n",
+    " - Use try/except blocks to catch runtime errors and deal with them\n",
+    "   - by specifying the exception(s) caught\n",
+    "   - by using the exception object\n",
+    "\n",
+    " - Use the raise statement to raise an exception that may be caught in another part of the program\n",
+    "\n",
+    " - Hand trace code that uses assert, try/except blocks and raise statements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Being 'Assert'ive\n",
+    "`assert` makes code 'fail fast' rather than continuing with bad data. This is useful because we would prefer to have runtime errors over semantic (thinking) errors.\n",
+    "\n",
+    "An `assert` statement takes a boolean condition, e.g. `assert my_list != []` would assert that the list is not empty.\n",
+    "\n",
+    "If the assert statement is True, nothing happens. If the assert statement is False, a runtime error occurs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "age = int(input(\"Enter your age: \"))\n",
+    "# TODO Assert age is positive\n",
+    "print(\"In five years, you will be\", age + 5, \"years old\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You try!\n",
+    "# In pizza_size, assert that the radius is positive.\n",
+    "# In slice_size assert that slice_count is positive.\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    return (radius ** 2) * math.pi\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)\n",
+    "\n",
+    "args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "args = args.split(',')\n",
+    "\n",
+    "radius = float(args[0].strip()) / 2\n",
+    "slices = int(args[1].strip())\n",
+    "\n",
+    "size = slice_size(radius, slices)\n",
+    "print('Each pizza slice will be {} square inches'.format(size))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Use `try`/`except` blocks to \"catch\" runtime errors\n",
+    "`assert` isn't always the prettiest for the user -- their program crashes!\n",
+    "\n",
+    "Often, we prefer to use `try` and `except`. `try` and `except` blocks come in pairs. Python tries to run the code in the `try` block, but if there’s an exception, it jumps to the `except` block -- it does not crash! We call this \"catching\" the exception. If there is no exception, the `except` block does not run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:  \n",
+    "    print(\"2 inverse is\", 1/2)\n",
+    "    print(\"1 inverse is\", 1/1)\n",
+    "    print(\"0 inverse is\", 1/0)   # this line results in a RuntimeError\n",
+    "    print(\"-1 inverse is\", 1/-1)\n",
+    "    print(\"-2 inverse is\", 1/-2)\n",
+    "except:\n",
+    "    print(\"Something bad happened :(\")\n",
+    "    \n",
+    "print(\"Just like ifs, we join here!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You try! Catch the error before the program crashes.\n",
+    "# For this example, do NOT use an if statement!\n",
+    "pizza_slices = 8\n",
+    "num_people = int(input(\"Enter a number of people to divide the pizza among: \"))\n",
+    "pizza_per_person = pizza_slices / num_people\n",
+    "print(pizza_per_person, \"slices per person.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Being Descriptive\n",
+    "We can be more descriptive by saying `except Exception as e` and printing out information with `e`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "try:  \n",
+    "    print(\"2 inverse is\", 1/2)\n",
+    "    print(\"1 inverse is\", 1/1)\n",
+    "    print(\"0 inverse is\", 1/0)   # this line results in a RuntimeError\n",
+    "    print(\"-1 inverse is\", 1/-1)\n",
+    "    print(\"-2 inverse is\", 1/-2)\n",
+    "except Exception as e:\n",
+    "    print(\"Something bad happened :(\")\n",
+    "    print(type(e))\n",
+    "    print(str(e))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a try/catch block to handle all errors\n",
+    "# Be descriptive, print out the error type and message.\n",
+    "\n",
+    "import math\n",
+    "\n",
+    "def pizza_size(radius):\n",
+    "    assert radius > 0\n",
+    "    return (radius ** 2) * math.pi\n",
+    "\n",
+    "def slice_size(radius, slice_count):\n",
+    "    assert slice_count >= 1\n",
+    "    total_size = pizza_size(radius)\n",
+    "    return total_size * (1 / slice_count)\n",
+    "\n",
+    "while(True):\n",
+    "    args = input(\"Enter pizza diameter(inches), slice count: \")\n",
+    "    args = args.split(',')\n",
+    "\n",
+    "    radius = float(args[0].strip()) / 2\n",
+    "    slices = int(args[1].strip())\n",
+    "    size = slice_size(radius, slices)\n",
+    "    print('Each pizza slice will be {} square inches'.format(size))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Nested Exceptions\n",
+    "Exceptions can be thrown from any function. If that function cannot handle the exception, the exception goes to the calling function. If that function cannot handle the exception, to its calling function. If no calling function can handle the exception, the program crashes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    assert cust_happy.lower() == 'y'\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        matt()\n",
+    "    time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can choose where to handle an exception, e.g. defer all complaints to corporate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    assert cust_happy.lower() == 'y'\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "        \n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "... or handle them ourselves ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    try:\n",
+    "        print(\"Cole: Hello! :)\")\n",
+    "        cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "        assert cust_happy.lower() == 'y'\n",
+    "        print(\"Cole: Great! :)\")\n",
+    "    except Exception as e:\n",
+    "        print(\"Cole: Dang that's rough\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "... or somewhere in between!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `raise` Our Own Errors\n",
+    "Rather than using `assert` we can also `raise` an error. As we can see by `type(e)`, there are different types of errors in Python. These form a hierarchy [(see here)](https://docs.python.org/3/library/exceptions.html). It helps to know some common exceptions, but you don't need to memorize them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    cole()\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e:\n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's check if the customer is happy and if they have found everything they needed.\n",
+    " - If they are not happy, `raise` a `FutureWarning`. Corporate can handle this.\n",
+    " - If they have not found everything they needed, `raise` a `ResourceWarning`. Matt can handle this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    cust_found = input(\"Cole: Did you find everything that you needed?\")\n",
+    "    if cust_found.lower() != 'y':\n",
+    "        raise ResourceWarning(\"We are running out of resources!\")\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    try:\n",
+    "        cole()\n",
+    "    except Exception as e: # ALMOST correct....\n",
+    "        print(\"Matt: I'll order some more!\")\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e: \n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What's wrong with the above function? Fix it below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's also ask the customer if they are feeling healthy. If not, we should `raise` a `UserWarning` and Matt should ask them to leave the store."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cole():\n",
+    "    print(\"Cole: Hello! :)\")\n",
+    "    cust_happy = input(\"Cole: Are you having a pleasent shopping experience?\")\n",
+    "    if cust_happy.lower() != 'y':\n",
+    "        raise FutureWarning(\"This customer may not return in the future!\")\n",
+    "    cust_found = input(\"Cole: Did you find everything that you needed?\")\n",
+    "    if cust_found.lower() != 'y':\n",
+    "        raise ResourceWarning(\"We are running out of resources!\")\n",
+    "    # TODO: Ask the customer if they are feeling healthy.\n",
+    "    print(\"Cole: Great! :)\")\n",
+    "    \n",
+    "def matt():\n",
+    "    print(\"At Matt's store...\")\n",
+    "    try:\n",
+    "        cole()\n",
+    "    except ResourceWarning as rw:\n",
+    "        print(\"Matt: I'll order some more!\")\n",
+    "    except UserWarning as uw:\n",
+    "        print(\"Matt: Please leave the store :(\")\n",
+    "    \n",
+    "def pig_wig_corp():\n",
+    "    while(True):\n",
+    "        print(\"At the pig wig...\")\n",
+    "        try:\n",
+    "            matt()\n",
+    "        except Exception as e: \n",
+    "            print(\"Corp: We are sorry to hear this.\")\n",
+    "            print(\"Err msg:\", str(e))\n",
+    "            print(\"Err type:\", type(e))\n",
+    "        time.sleep(5)\n",
+    "pig_wig_corp()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Consider the code below and answer the following questions...\n",
+    "\n",
+    "# In your own words, describe what the code does.\n",
+    "# \n",
+    "\n",
+    "# In a single iteration, can a FloatingPointError and OverflowError be thrown?\n",
+    "# \n",
+    "\n",
+    "# In a single iteration, can a OSError follow an OverflowError?\n",
+    "# \n",
+    "\n",
+    "# Are there any error(s) we are not catching? If so, name them.\n",
+    "# \n",
+    "\n",
+    "# Are there any error(s) we are catching but not raising?\n",
+    "# "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import time\n",
+    "\n",
+    "def flaky_math_func1():\n",
+    "    if(random.random() < .5):\n",
+    "        raise FloatingPointError(\"Something went wrong doing some float math!\")\n",
+    "        \n",
+    "def flaky_math_func2():\n",
+    "    if(random.random() < .5):\n",
+    "        raise OverflowError(\"Something went wrong doing some big math!\")\n",
+    "        \n",
+    "def flaky_os_func():\n",
+    "    if(random.random() < .01):\n",
+    "        raise OSError(\"Something went wrong in the OS!\")\n",
+    "        \n",
+    "def flaky_impl_func():\n",
+    "    if(random.random() < .05):\n",
+    "        raise NotImplementedError(\"Something went wrong in the implementation!\")\n",
+    "        \n",
+    "def flaky_perm_func():\n",
+    "    if(random.random() < .2):\n",
+    "        raise PermissionError(\"I don't have permission to do that!\")\n",
+    "         \n",
+    "while(True):\n",
+    "    print(\"Beginning the flaky functions!\")\n",
+    "    \n",
+    "    \n",
+    "    try:\n",
+    "        flaky_math_func1()\n",
+    "        flaky_math_func2()\n",
+    "    except ArithmeticError as e:\n",
+    "        print(\"Phew! I avoided a\", type(e))\n",
+    "        \n",
+    "    flaky_os_func()\n",
+    "    \n",
+    "    try:\n",
+    "        flaky_impl_func()\n",
+    "        flaky_perm_func()\n",
+    "    except (RuntimeError, FileExistsError) as e:\n",
+    "        print(\"Phew! I avoided a\", type(e))\n",
+    "    \n",
+    "    print(\"End of flaky functions!\")\n",
+    "    print()\n",
+    "    \n",
+    "    time.sleep(10) # wait 10 seconds, give time to read the output."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A Word on Hierarchy\n",
+    "All dogs are animals, but not all animals are dogs.\n",
+    "\n",
+    "All ZeroDivisionErrors are ArithmeticErrors, but not all ArithmeticErrors are ZeroDivisionErrors."
+   ]
+  },
+  {
+   "attachments": {
+    "1_iP78XqAbkntOuzbHCoiubg.png": {
+     "image/png": "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"
+    }
+   },
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![1_iP78XqAbkntOuzbHCoiubg.png](attachment:1_iP78XqAbkntOuzbHCoiubg.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Source](https://levelup.gitconnected.com/java-classes-and-objects-a312db4bc785) (yes this is a Java resource -- but applicable to MANY programming languages!)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}